# making a bubble machine with a touch sensor?

hello

so i am trying to make a 9V bubble machine that is motion-sensored and will turn on when someone walks by. Basically, i rewired the wires in the bubble machine such that 2 wires are extruded that when put together will activate the machine. Now i tried to put this on my arduino. But frankly, i am at a loss. What kinds of things should i be looking at for putting on the arduino? Would i need a relay?

solid state relay, power MOSFET, darlington transistor? A suitable circuit will depend on the circuit inside your "bubble machine" that you want to "close".

Measure the current when you short the trigger wires together - base your relay choice on that.

alright, thanks for the suggestions first off.

I decided to mess around with the mosfet and get that working, and it has been quite successful!!

Now the next step would be to make this more interactive, ie using a touch sensor.

So basically, the touch sensor will work with MOSFET to turn on the machine.

the touch sensor code is the following:

``````// CapSense.pde

// Fun with capacitive sensing and some machine code - for the Arduino (or Wiring Boards).
// Note that the machine code is based on Arduino Board and will probably require some changes for Wiring Board
// This works with a high value (1-10M) resistor between an output pin and an input pin.
// When the output pin changes it changes the state of the input pin in a time constant determined by R * C
// where R is the resistor and C is the capacitance of the pin plus any capacitance present at the sensor.
// It is possible when using this setup to see some variation in capacitance when one's hand is 3 to 4 inches from the sensors
// Try experimenting with larger sensors. Lower values of R will probably yield higher reliability.
// Use 1 M resistor (or less maybe) for absolute touch to activate.
// With a 10 M resistor the sensor will start to respond 1-2 inches away

// Setup
// Connect a 10M resistor between pins 8 and 9 on the Arduino Board
// Connect a small piece of alluminum or copper foil to a short wire and also connect it to pin 9

// When using this in an installation or device it's going to be important to use shielded cable if the wire between the sensor is
// more than a few inches long, or it runs by anything that is not supposed to be sensed.
// Calibration is also probably going to be an issue.
// Instead of "hard wiring" threshold values - store the "non touched" values in a variable on startup - and then compare.
// If your sensed object is many feet from the Arduino Board you're probably going to be better off using the Quantum cap sensors.

// Machine code and Port stuff from a forum post by ARP  http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1169088394/0#0

int  i;
unsigned int x, y;
float accum, fout, fval = .07;    // these are variables for a simple low-pass (smoothing) filter - fval of 1 = no filter - .001 = max filter
int ledPin =  10;    // LED connected to digital pin 10

void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT);

DDRB=B101;     // DDR is the pin direction register - governs inputs and outputs- 1's are outputs
// Arduino pin 8 output, pin 9 input, pin 10 output for "guard pin"
//  preceding line is equivalent to three lines below
//  pinMode(8, OUTPUT);     // output pin
//  pinMode(9, INPUT);      // input pin
//  pinMode(10, OUTPUT);    // guard pin
digitalWrite(10, LOW);  //could also be HIGH - don't use this pin for changing output though
}

void loop() {
y = 0;        // clear out variables
x = 0;

for (i=0; i < 4 ; i++ ){       // do it four times to build up an average - not really neccessary but takes out some jitter

// LOW-to-HIGH transition
PORTB = PORTB | 1;                    // Same as line below -  shows programmer chops but doesn't really buy any more speed
// digitalWrite(8, HIGH);
// output pin is PortB0 (Arduino 8), sensor pin is PortB1 (Arduinio 9)

while ((PINB & B10) != B10 ) {        // while the sense pin is not high
//  while (digitalRead(9) != 1)     // same as above port manipulation above - only 20 times slower!
x++;
}
delay(1);

//  HIGH-to-LOW transition
PORTB = PORTB & 0xFE;                // Same as line below - these shows programmer chops but doesn't really buy any more speed
//digitalWrite(8, LOW);
while((PINB & B10) != 0 ){            // while pin is not low  -- same as below only 20 times faster
// while(digitalRead(9) != 0 )      // same as above port manipulation - only 20 times slower!
y++;
}

delay(1);
}

fout =  (fval * (float)x) + ((1-fval) * accum);  // Easy smoothing filter "fval" determines amount of new data in fout
accum = fout;

Serial.print((long)x, DEC);    // raw data - Low to High
Serial.print( "   ");
Serial.print((long)y, DEC);    // raw data - High to Low
Serial.print( "   ");
Serial.println( (long)fout, DEC); // Smoothed Low to High

if(x > 1) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
delay(10); //Delay for good measure! (not strictly necessary but might as well have it)

}
``````

Anybody have any suggestions or ideas?

The bit where you write to the LED, just write to the MOSFET instead.

@grumpyMike

alright, so what "lingo" do i use for a MOSFET in coding?
could you give me an example

What he meant was that you would connect one leg of the MOSFET to the Arduino, in place of the LED.

``````PORTB = PORTB | 1;                    // Same as line below -  shows programmer chops but doesn't really buy any more speed
// digitalWrite(8, HIGH);
``````

vs.

``````void digitalWrite(uint8_t pin, uint8_t val)
{
uint8_t timer = digitalPinToTimer(pin);
uint8_t port = digitalPinToPort(pin);
volatile uint8_t *out;

if (port == NOT_A_PIN) return;

// If the pin that support PWM output, we need to turn it off
// before doing a digital write.
if (timer != NOT_ON_TIMER) turnOffPWM(timer);

out = portOutputRegister(port);

if (val == LOW) *out &= ~bit;
else *out |= bit;
}
``````

Strange comment :o

Use:-

``````if(x > 1) {
digitalWrite(ledPin, HIGH);
digitalWrite(devicePin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
digitalWrite(devicePin, LOW);
}
``````

Where you have previously defined 'devicePin' to be the pin number of the arduino that you connect the FET gate to.

alright....i tried taking the source pin of the MOSFET and inserting it into the ground of the digital output of the arduino. Also, i connected the negative terminal of the 9V battery of the bubble machine to pin 10. However, it just turns on regardless of whether i touch the capacitive sensor or not.....

@ Grumpy Mike
i actually connected the MOSFET to the breadboard...where exactly on the arduino pin can i insert it?

That is not the way to connect a MOSFET, I find it hard from the description to know what you have done and how you think you are switching on the machine but what you are describing will not work. Can you post a schematic and we can go from there.

where exactly on the arduino pin can i insert it?

Any free arduino pin, like pin 10.

alright here is the image of the setup i have so far with the MOSFET connections and the touch sensor setup (minus the LED which goes into pin 10).

on the side with the (+) and (-), that is the touch sensor components, including a wire from pin 8 to (+) a resistor connecting to (-) and another wire from the (-) to pin 9.

The mosfet components are the rest

It is only a low res photograph not a schematic. Not much use for seeing what you are trying to do.
In an earlier post you said you had some success using a FET but didn't say what you were doing or how.

You need to get the hardware to a state where you can turn it on / off with a simple software statement. Take the blinking LED example and use it to turn your machine on and off say for three seconds at a time.

Only when that is working try to add the capacitive sensor bit working.

You need the -ve of the battery to go to the arduino ground and you want the -ve terminal of what used to connect to the battery (the -ve of your machine) to the drain of the FET. Source of FET to arduino ground, output pin of arduino (the one you want to use) through a resistor to the FET gate. Finally the +ve of your battery to the +ve input of your machine.
It is a bit confusing in words but try and draw it out.

alright....i did according to your instructions, and whenever i connect the (+) terminal of the battery to the (+) of the machine, the machine turns on! Fantastic....

now what would be the next logical step from here? i really am not very good at schematically drawing circuits...so i apologize for that

and whenever i connect the (+) terminal of the battery to the (+) of the machine, the machine turns on!

Not good. It should only turn on when the FET gate is driven high and turn off when the FET gate is low.

Will it do this?

So have you the blink sketch working with your machine to turn it on and off at a fixed rate?

alright...my bad...i readjusted it and now when i touch the two (+)s it does NOT turn on...alright

i have not yet written the code for the blinking...
would be something like this?

``````int ledPin = 10;                 // LED connected to digital pin 10

void setup()
{
pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

void loop()
{
digitalWrite(ledPin, HIGH);   // sets the LED on
delay(1000);                  // waits for a second
digitalWrite(ledPin, LOW);    // sets the LED off
delay(1000);                  // waits for a second
}
``````

alright i got the blinking LED code to work and it blinks every 5 seconds....

now how would i make this machine turn on with code?

now how would i make this machine turn on with code

Connect the gate of the FET through a resistor to pin 10 of the arduino in place of the LED.

@grumpymike

yes! the machine turns on and off at 3 second intervals!

i have the capacitive touch sensor code and i uploaded it and attempted to connect it the appropriate way along with the MOSFET connections....

funny thing is, the touch sensor bit is not even working at all with the MOSFET....

how can this be so?

Are you using the same pin for the MOSFET and the capacitive sensor?

In what way does it not work? Have you printed the readings you get from it through the monitor?