The Sneeze-Ray Remote-Controlled Nose Tickler

Do you know that old wives' tale about how when you sneeze, it means someone is thinking of you? Apparently, most people don't. I didn't realize that, so I made this project. :)

I recently gave my first demo as Maker Advocate for Pinoccio, a new, open-source kit for your own personal Internet of Things. Since it was part of San Francisco's Sensored meetup, I wanted to demonstrate something interactive. Thus, the Sneeze-Ray, which empowers people to tickle your nose over the internet!

In its final form, this project sends a signal from a phone to our online routing system, which sends a signal through a WiFi network to one Pinoccio board, which relays the command over radio to another Pinoccio board that I'm wearing. (It's needlessly complex because I wanted to demonstrate each type of communication.) I built it at TechShop SF.

This instructable assumes a basic familiarity with the structure of programming. Don't worry, it ain't bad!

Step 1: Materials

2 x Pinoccio scouts - Pinoccio boards come in two flavors, right now: a Field Scout is a basic board, similar to an Arduino Mega with built-in radio mesh networking, and a Lead Scout is one of those with a WiFi shield on top. Any board with a WiFi "backpack" can connect the entire mesh network up to the internet. I named my Lead Scout "Buckaroo" (after noted brain surgeon / rocket scientist / rock star Buckaroo Banzai), and my Field Scout "Tommy".
You don't actually need two Scouts for this; I simply wanted to demonstrate the different types of communication available.

1 x pair of glasses - I used a pair that had lost their side-arms.
1 x vibration motor - I dug this one out of an old cell phone.
1 x feather
1 x LED
A few feet of thin cable (solid-core preferred, so that you can plug it directly into the board's headers)

Step 2: Computer to Board (Serial)

First, I mapped out what I needed the system to do:
1. I want to define a function, tickle, that turns pin 2 on and sets the LED to red, waits 1 second, then turns both off.
2. I want to send this signal from my phone to a board on my person.
3. When pin 2 goes on, a feather will tickle my nose. (The LED shows that the process is working.)

So, first I had to write the function and get it onto my board. A configured Scout has a sketch on it that allows you to control it by entering code in the serial monitor. (This means you can program it on the fly, without needing to re-compile and upload your code with each change!) I plugged in my Lead Scout (Buckaroo) and fired up the monitor via the Pinoccio IDE, a slightly-modified version of the Arduino IDE.

Onboard Functions

Power-cycling the board clears its defined pins, so in order to use pin 2, I had to make sure it'd be defined every time the Scout was turned on. This meant setting a startup function:

function startup { pin.makeoutput("d2"); pin.write("d2", LOW); };

// This function defines digital pin 2 as an output, and makes sure it's off ("LOW").

And here's the tickle function:

function tickle { pin.write("d2", HIGH); led.red; snooze(1000); pin.write("d2", LOW); led.off; };

// This turns digital pin 2 on, sets the Scout's onboard LED to red, waits 1000ms, and the rest should be pretty clear...

So, now I had a board that would perform those actions when I sent it the tickle function. Time to go truly wireless!

Step 3: Computer to Board... to Board (WiFi / Radio)

WiFi ENGAGE!

Actually, I could have set those functions over the internet as well -- but for simplicity's sake, we'll put all the connectivity steps together.

I tossed Buckaroo the keys to the internet:
wifi.config("Network ID", "network-password")
wifi.reassociate

Now that these have been run, it'll automatically try to connect to that network as long as it's powered on.
We're building out docs right now that include all available commands for your Scouts.

After this, Buckaroo started showing up in our online HQ (as seen in the picture), and I could send commands to it from our website. Here's a video of my colleague Eric demonstrating this.

RADIO ENGAGE!

At this point, I had a Lead Scout hooked up to receive the "tickle" command from any internet-enabled device, anywhere in the world, at which point it would turn on pin 2 and a red LED for 1 second, then turn both off.

But I wanted to demonstrate the boards' innate capacity for telepathy among themselves, so I designated Tommy, my Field Scout, as the brains of my tickle machine. This meant setting him up with the same functions as Buckaroo (at which point I could well have erased them from Buckaroo, since each board maintains its own set of functions).

Since I have Buckaroo and Tommy configured as part of the same "troop", they will always be able to talk to each other over radio as part of a mesh network. If I add more boards to the troop, any Scout can relay commands to any other Scout, or to the group as a whole. And what's more, since Buckaroo has a line to the internet, that means the entire troop can receive commands via WiFi.

I powered up Tommy and sent the startup and tickle functions through our HQ. I stuck an LED on pin 2 to verify that it went high, and so it did!

Step 4: Phone to Board to Board (cell / WiFi / Radio)

GET RESTFUL

Okay! So, for this step, I learned how to trigger Scouts without using our HQ or a wired connection -- via our REST API, a system that enables you to send commands directly from any website or app.

One way to do it is by building a simple URL, then hitting via a web browser:
https://api.pinocc.io/v1/2/3/command/led.torch?token=YOURTOKEN

Here's the breakdown on that:
https://api.pinocc.io/v1 -- The stub to access the REST API.
/2/3 -- This means that you're addressing Scout #3 (Buckaroo, who was the third configured) in troop #2 (the Blue Blaze Irregulars). Sharp-eyed readers may note that this structure is part of the URL for the HQ page I was using earlier: https://staginghq.pinocc.io/troops/2/scouts/3
/command/led.torch -- What you want the board to do. In this case, the command tells the scout to turn the built-in LED to its "torch" color (a signature color that you can customize for each board).
?token=YOURTOKEN -- Most REST APIs require authentication in order to control access. I wouldn't want just anybody to be able to jump on the internet and mess with my Scouts. As an alternative to logging in, you can include this token with your command to authenticate.

Here's a somewhat awkward video of me demonstrating this with the "tickle" function. :)

PHONE IT

I wanted to try building an Android app to hit this from my phone, but that turned out to be kind of heinously complex for my basic needs, so I'm saving it for later. Instead, I built a simple HTML page that shows the Pinoccio logo and a "Tickle!" button, and triggers "tickle" for Tommy when either is clicked. Here's the code.

I saved this as an icon on my home screen, but during testing, it turned out to be too annoying to open the page, wait for it to load, then click again to send the REST command. So, in the end, I simply put a link to the REST URL on my home screen. Clicking that pulled up the page and triggered the function on Tommy.

Finally, time to get my hands dirty and build the Apparatus!

Step 5: Board to Nose! (hardware)

Oh man, I had so much fun making this ridiculous thing.

I don't have a lot of pictures of the build process, but here's a photo of the finished product.

Process:
• Soldered a couple of long wires to the vibration motor leads. It doesn't matter which is ground or power, since that only affects which way the motor spins inside its casing.
• Stripped the other ends of the wires and hot-glued them into Pin 2 and ground on the board. (Hot glue is sturdy but easily removable.)
• Glued the wires to the glasses frame and centered the motor over my nose.
• Glued the feather to the motor, and trimmed it to an appropriately tickly size and shape.
• Attached a ribbon to the board, to hang its weight from my neck and prevent stress on the wires.

That's all! Since it was so simple, all of the hardware thankfully worked on the first go-round. The bio-control system still needs work, though, as the thing was tickly but did NOT in fact make me sneeze. (Pepper, maybe?)

I jetted off to Lemnos Labs and gave my talk, hopefully injecting a welcome bit of silliness into this excellent event.

Cheers :)