BubbleViz is an internet-enabled toy bubble gun that uses an Arduino, XBee and ConnectPort to poll a PHP script and check an IMAP server for new messages, upon which the device showers you with a delightful cascade of bubbles.

View it in action:

More information, pictures and code follow!

As you can see, this project more than meets the “looks like a bomb” quota.

Here’s my relevant PHP code (using my modified Email to DB class):

include_once("class.emailtodb_tedb0t.php");
 
$edb = new EMAIL_TO_DB();
$edb->connect('imap.gmail.com:993', '/imap/ssl/novalidate-cert', 'username@gmail.com', 'password');
echo $edb->getNumNewMessages();
$edb->close();

Here’s the pertinent function from the classfile.  I’m certain there is a better, more logical way to do this.  We can’t use PHP Sessions because Rob’s ConnectPort server doesn’t implement them… maybe I will add that in

function getNumNewMessages(){
	$myFile = "numMessages.txt";
	$fh = fopen($myFile, 'r');
	$lastNum = intval(trim(fgets($fh)));
	$currentNumMessages = $this->num_message();
	fclose($fh);
	$fh = fopen($myFile, 'w+');
	fwrite($fh, $currentNumMessages);
	fclose($fh);
 
	return $currentNumMessages - $lastNum;
}

And the Arduino code:

// BubbleViz
//   Bubble Gun Controller
//   by Ted Hayes <www.liminastudio.com>
 
#include 
 
#define PIN_SWITCH 4
#define PIN_MOTOR 12
#define DUR_MAX 3000
 
Servo myservo;
int lastRead = HIGH;
long i = 0;
int dur = 1000;
int durMult = 500;    // ms per new emails
int curByte;
int curVal;
int curDur;
 
void setup()
{
  Serial.begin(115200);
  pinMode(PIN_SWITCH, INPUT);
  pinMode(PIN_MOTOR, OUTPUT);
  digitalWrite(PIN_SWITCH, HIGH);  // set pullup on pin 2
  digitalWrite(PIN_MOTOR, LOW);    // motor off
 
  //// software serial
  pinMode(rx,INPUT);
  pinMode(tx,OUTPUT);
  digitalWrite(tx,HIGH);
 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
  myservo.write(80);  // reset to "closed" position
}
 
void loop()
{
  int switchRead = digitalRead(PIN_SWITCH);
  if(switchRead == LOW && lastRead == HIGH){
    fire(dur);
  }
  lastRead = switchRead;
 
  if (Serial.available() > 0) {
    curByte = Serial.read();
    curVal = curByte - 48;    // "decodes" ASCII number to DEC number
 
    if(curVal > 0){
      curDur = durMult * curVal;    // ms * num of new emails
      if(curDur > DUR_MAX) curDur = DUR_MAX;
      fire(curDur);
    }
  }
 
  // poll web script every n iterations of loop (as opposed to using delay())
  if(i > 300000){
    Serial.print("http://verge.myftp.org:81/Listereen/emailtodb_v0/check_mail.php");
    i=0;
  }
  i++;
}
 
void fire(int duration){
  // trigger gun motor
  digitalWrite(PIN_MOTOR, HIGH);
  delay(300);               // wait for loop to wet
  myservo.write(105);          // pull loop out
  delay(duration);                 // wait for bubbles to blow
  // reset motor and servo
  digitalWrite(PIN_MOTOR, LOW);
  myservo.write(80);
}

Here’s a brief overview of my thought process so far for my NetObjx final.I initially was interested in the Telepathic Mesh Society concept:

But I have been in collaboration with Adam Harvey on a blog-data-auralization installation art piece:

Here are some common AT commands I have most frequently while working on XBee projects.  Remember, ALL NUMBER VALUES ARE IN HEX!

• ATID – PAN ID
• ATDH/DL – Destination address high/low: which local address to send ADC data
• ATMY – Local address of this unit
• I/O:
  • ATD0…D8 – digital pins I/O enable
  • ATP0…P1 – PWM output enable
  • ATIU – I/O output enable (UART) – send out through serial
  • ATIA – I/O input address – address to pay attention to for serial output
  • ATIT – ADC Samples before TX
  • ATIR – ADC Sample rate (ms)
  • ATBD – Baud Rate:
    • 3 = 9600
    • 4 = 19200
    • 5 = 38400
    • 6 = 57600
    • 7 = 115200
• ATWR – Write parameter values

Remember to ATWR to save changes to parameters.

Interesting note from the manual: “The maximum sample rate that can be achieved while using one A/D line is 1 sample/ms or 1 KHz (Note that the modem will not be able to keep up with transmission when IR & IT are equal to “1”).”

Adam and I got our Bluetooth link in the Espionage chain working.

What you see here are two arduinos each with a SparkFun BlueSMiRF RP-SMA module. The transmitter (my end) is configured using Autoconnect Master mode, and the receiver (Adam) is in Slave mode (the default). With this configuration they pair automatically when within range of each other.

Once paired, I trigger the transmission manually and begin sending my message. His arduino receives the message and initiates its own sending procedure for the next link in the chain.

For our NetObjx Espionage class project, I am initiating a chain of data transfer with a collaborative “blow” interface that transmits over Bluetooth.So far my Bluetooth partner and I have managed to get our BlueSMiRF modules to pair (albeit over a short distance since we’re not using external antennae) and we even managed to get terminal-to-terminal bidirectional communication working!  Video here:

We’ve got our BlueSMiRFs connected to the TX and RX pins of some simple USB-to-Serial FTDI chips.  In order to get the modules to pair, I had to configure my BlueSMiRF module to use “Autoconnect Master” mode and set the destination address, which in this case was Adam’s module, which stays in its default mode of “slave.”  To configure a module, you can connect directly to it over Bluetooth with your computer.  Your OS should have some kind of Bluetooth utility that will detect nearby devices and allow you to connect to them.  Once you find yours (I’m not sure what the default names of these BlueSMiRFs are, mine was BlueRadios), try to pair with it.  It will ask for a password, which by default is, amazingly, “default.”  If it works, the utility will give you a serial port that allows you to talk directly to the Bluetooth module.

Now you need a terminal with which to talk and listen to the serial port (this is both similar and different to the “Terminal” program you have in OS X). I used ZTerm for this; with ZTerm you have to hold <shift> as it starts to select which serial port to talk to.  You can also use the “screen” shell program on *nix systems.  First list your serial connections and pick out the one that sounds right, i.e.:

ls /dev/tty.*
screen /dev/tty.BlueRadios-COM0-1

Once you’re talking to your module, you can try typing “AT<cr>” to test your connection, if it responds with “OK” you’re in command mode.  In my experience all commands are followed by a carriage return, so from now on I’ll leave that out.  You may have to type “+++” to get into command mode first.  The command references I looked at claimed the command mode string is “$$$” but none of the modules we used responded to this, weird.  Anyway, to get your module’s address, enter:

ATSI,1

It should hit you back with an address like this: 00A0961B284D.  If you want to set your module to Autoconnect Master mode, first you set the startup address and then set your startup mode:

ATSMA,<destination address>,1101
ATSW25,1,0,0,0

The “1101″ specifies serial communication.  You can change your startup mode back to the default with:

ATSW25,0,1,0,0

Once you’ve entered these commands, restart your circuit, and the module will begin trying to connect to the destination address you specified.  During this time your BlueSMiRF should be blinking green.  If you are monitoring it over serial you will see “CONNECT,<addr>”.  Once both modules pair, they will turn to solid red.  Without antennae, the RP-SMA modules will need to be within 2 feet or so of each other.  The silver and gold modules use better on-chip antennae so they’ll have much better range.

Now if both modules are being monitored with a terminal, you should be able to talk to each other!

I’ll follow up with video of my blow interface and hopefully soon we’ll get serial bluetooth data transfer working!

The Breath Pong networked objects controller lives!  I completely changed the sensor design from the last iteration.  I suspected the DC motor would have too much friction to make the sucking action reliable, so in conversation with Rob I decided to go for a much simpler design: a dual-pole switch.

Here is a video showing the prototype construction, and a video demonstrating the controller—it works quite well!

Here is a sectional diagram:

Sectional Diagram

And here’s a network diagram:

Network Diagram

Successfully tested the WizNet ethernet module.  First, I loaded the WebClient Arduino code; video here.  This worked fine, so I added a “connected” LED and “connect” switch, which caused problems because I wasn’t using a voltage dividing resistor to ground, so I enabled the Arduino’s internal pull-up resistor and changed the code around.

For kicks, I went ahead and tried the WebServer code too—video here.  Worked great!

For my networked Pong controller, I am attempting to create a device that senses inhalation and exhalation as methods of moving the Pong paddle left and right.  To do this, I am using a simple fan to generate an induction current.  The two conductors of the fan motor are connected to two Arduino analog inputs with 10k-ohm resistors bridging them to ground to create voltage dividers.  In this sense the motor acts exactly like any typical resistance-based sensor, like a flex sensor, except that the motor is not connected to any voltage source, as it generates its own current.

This works surprisingly well!  I just have to set a small threshold to ignore the small amount of noise generated if you touch the motor or an EM source is moved near it.  The next step is to figure out a reliable way to move the fan with your breath; I’m going to try a computer fan with a blowing/sucking tube (har!) attached to it.  It’s an unusual kind of action to try to sense.

Video here: http://vimeo.com/3152151

Images:

The DC test motor with plastic-cup fan blower