So I built an Arduino frame using nothing but the parts from the Mindstorms kit (it’s all just Technics parts). It’s pretty sturdy and the little rubber ends hold the board down pretty good. I figure it’s good enough to put on wheels or a quad-ped bot. I don’t know if I’d send it up in the air. I’d probably want to add a few more cross bars in there. Anyway, I did a lot of refactoring (if you could call it that) and I think this design is pretty good. Here’s the money shot with the rest of the build shots so you can copy it. I’m fresh brand-new to the Lego scene so leave some comments if I did something stupid.

Top down without the board.

Bottom face without the board.

Room and support for plugs.

Doesn’t shake loose.

Final hardware rig

Background

My cat likes to drink fresh and cold water directly from the faucet. We get up and turn on the faucet only to leave it running after she’s jumped down. It’s not really a big problem for us but I saw a fun problem that I could work on. As much as this seems like a weird and freakish oddity, it’s a potential start of a smarthome sensor network that may provide some utility. I also saw an opportunity to learn various things such as MongoDB, mechanical construction with Microrax, Rails3 and more development on Arduino with an Xbee module.

Some informal goals I had in mind when starting the project:

• Extensible – Something where I can add new sensors of any time of function. Say I want an ambient temperature history. Sure a SQL schema can be designed to be extensible and flexible but I wanted something super generic like a big hashtable
• Analysis – I wanted to know what hour of the day my cat drinks the most.
• Control – I wanted a protocol coming from the Arduino that would be flexible enough to not only collect metrics but also accept commands.
• Temporary – Any installation had to be easily undone. No holes in the wall, no new pipes and nothing I can’t undo.

Video and detail past the break.

Here’s a video of it in action for the first time.

Design

I spent some time drawing sketches first of the physical problem. I drew a sink and sketched out some frames around it. I sketched out the angles and vectors in play. I played with the sink handle and tried to break down the physical forces and simplify it to it’s most basic components. I built a small wooden sink faucet with the same dimensions as my real one so I wouldn’t have to work in the bathroom. I took some reference pictures and looked through my sparkfun parts box to see what components I had lying around.

I eventually came up with a small box built around a base platform that would hold both an IR sensor and a servo. From my wooden sink mock up, I knew that the servo’s fulcrum would have to be directly over the handle’s fulcrum. Anything else would cause sliding or rubbing which would lead to more difficult mechanical problems. That meant that I needed something pretty fancy and precise in terms of a support structure. I couldn’t just cut up some wood and nail it together. I would later solve this problem with the microrax structure, but I didn’t know that yet.

Early prototype and testing

I built some pretty rough prototypes using the wood faucet and handle. I first started out by playing with the IR sensor. I figured out a way to smooth the input values coming from the sensor and create a range window which could equate to “cat detected”. I saved that bit of code off to the side and moved on to playing with the servo. This was pretty simple to begin with, using the built-in Arduino library, you just create a Servo instance and write an angle to it. The angle greatly depends on where and how you attach the servo gear so the exact values have to be calibrated for your physical install. In any event, the code to move a servo looks like this:

Servo servo;  // create servo object to control a servo
// attaches the servo on pin 9 to the servo object
servo.attach(9);
servo.write(180); // turns servo to angle 180 but this has to be calibrated
// sink is on at this point

It’s a little more complicated than this (I have the code posted in full) but the idea is pretty simple. The servo library writes a value as a resistance to the data pin running to the servo and the servo moves. The servo requires a bit of time to actually move the arm so you have to put a delay() in. Also, there’s some jitter and debouncing issues you have to consider, like if the servo can’t get to it’s destination then it’s going to buzz (this was a major problem for me). As I’ll talk about later, the code in practice doesn’t just work, you have to play with it and calibrate it until it works the way you want in the physical world.

So at this point, I had a servo that would move 90 degrees on and off when I put my hand (representing the cat) in front of the IR sensor. I was moving a pencil attached to the servo gear that was representing a handle. Later I’d realize that I didn’t need to move a full 90 degrees because all I needed was a small stream of water (with about 10 degrees of movement). There were many other things to do but this was a good first prototype. I combined all my IR and servo code together and saved it off to the side.

Microrax Frame

Cat Faucet 3d sketch

I needed some way to hover the servo directly over my sink handle. I needed a mount for the IR sensor. I needed something to either put on the sink, or on the wall or something. I considered many options but I eventually found an erector set type product called Microrax. I ordered a basic starter set with 6 pieces of the piping. I figured I’d screw up quite a bit of it so I ordered extra lengths. Suprisingly, after it arrived, I didn’t screw up any lengths of it and the whole experience with Microrax was fun as hell.

Microrax lets you create almost any object you can think of, as long as it’s 45 or 90 degree angles. Maybe there are other configurations that are possible but the easiest ones are the structures like they have pictured on their website and the structures I have pictured here. I also ordered a servo bracket which fit perfectly on a Microrax pipe piece. I drew up some rough 3D sketches on graph paper. You can see the final one to the right.

From this 3d sketch, I could count how many lengths and pieces I needed to make the frame. So I made a parts list for myself. It was pretty funny making a parts list like a BOM but it’s was very necessary. I had planning-me and then there was hacksaw-me. Hacksaw me didn’t care about the plan, he was there to cut. So it was good to review the segment lengths on paper a few times to make sure I wasn’t ruining my Microrax parts.

Showing the pivot point on the handle

After I had a rough design, I cut out the pieces for the base of the frame and put together the base. I then double checked my lengths by putting it on the sink, also to visualize the rest of the pieces. There were some definite anchoring problems that I was trying to solve because I knew that when the servo pushed on the sink handle, it would push back on the frame and I didn’t want the frame to move.

I cut the rest of the pieces and eventually got a frame that placed the servo directly over the sink handle fulcrum which is exactly what I wanted. You can see here (to the right) I’m illustrating that the servo gear is directly over the handle pivot point. My screwdriver isn’t exactly pointing on the pivot point, it’s just there for depth reference.

My frame was built and I attached a servo bracket to it. At this point I actually ran out of parts. So I ordered some more and scavenged microrax pipes from other parts of the frame.

Microrax frame and base

Arm and grip

Faucet arm and servo gear mount

But now I needed to attach an arm to the handle. The servo attachment is just a little plastic star-shaped gear and I had to somehow attach that to a microrax piece. I sandwiched two plates together and eventually got this little piece you see here. The hole on the black star is where the servo gear threads go. A screw goes through this and holds this servo sandwich piece in and keeps it from falling in the sink. This star piece attaches to a Microrax piece that acts as the arm. I simply made a 90 degree downward post that acts as fingers off the arm. A lot of this I modeled just by using my real hand on the faucet and trying to reduce the mechanics as much as possible.

I tried a few variables on a grip (you can see the rubber band attempt). I even tried velcro and some other weird ideas. But the servo wasn’t transferring enough force to the handle, or at least seemed like it could be doing better. Also a lot of calibration came when I went to actually attach the grip. If you do anything that is physically or deployed, make sure you have some wiggle room to adjust to your target. Coming from a software world, I was horrified at how imprecise this is. Automatic deployment like capistrano, chef and other tools obviously have no relevancy here in the physical/hardware world.

Grip attempt with too little leverage

Anyway, pontifications aside, the rubber band connection around the handle instead of a hand-life device was transferring too much power to the inner portion of the lever. That wasn’t good.

I eventually realized that the most torque I could get was to push at the outer point on the handle (ie: a lever). So I positioned the grip so that it would squeeze all the way at the tip of the sink handle. This allowed the servo to easily and smoothly turn the handle. I put some rubber bands the pieces to give the arm some grippiness and it has worked very consistently for months. This is the grip I settled on. Some of the pieces need to be trimmed up but you get the idea.

Final grip with downward "fingers"

Rig Polish

So at this point, my arm was gripping the handle and my code was turning on the faucet. That pretty much finished up the hardware portion of the prototype. After that, it was just polish and finish. I got a box from sparkfun to mount the Arduino in and I wired it all up under the sink. I made wire connectors that go to servo extension cables that make the box easy to unplug from the servo and IR hookups. The wires go down the back of the sink to this box which is holding the Arduino and the Xbee shield.

Inside the Arduino project box

Software Components

Before talking about the software components, here’s an overview of how everything works together.

So let’s start off by talking about the Xbee component that’s attached to the Arduino.

Xbee Integration

I played around with the usb-serial driver using an Xbee explorer and integrated some code that would print to serial instead of printing to console from the Arduino. This would allow me to send a message from the sink to a full-on computer with a proper software stack to do something interesting. In my case, I wanted to send a message when the sink is tripped. I made up a little protocol based on JSON for the message. The Arduino can’t really do JSON per se but it can send plain-text that looks like it. This is what my Arduino sends over Xbee when the cat jumps up into the sink:

// example JSON message
{
  "sensor": "sinks",
  "name": "basement",
  "proximity": "true",
  "running": "true",
  "hash": "82C61D54A77D6A90219E4E40CE6C8440",
  "type": "metric"
}

Proximity is a bit redundant but I put it in there because the Arduino actually knows proximity before it knows running (debouncing) so in the future, I could have it send a message on every proximity event.

The hash is actually computed on the Arduino using an MD5 library. This was a b*tch to get working. I’d actually drop this functionality right away if I did this over. All it does is hash the sensor value and the name value together as a checksum. I didn’t know how good the Xbee would be. Definitely overengineered this but I was following serial advice I read on the Arduino forums. Almost every serial protocol has a checksum or sanity mechanism.

Ruby Serial Bridge AKA: The Cat Bridge

So on the other side of the Xbee link is a Linux box that is running a do-forever ruby script. It has an Xbee Explorer USB dongle and it watches for valid JSON coming in. I’m cheating quite a bit on reading the serial and this part could be toughened up against garbage data. I just look for opening and closing braces (meh).

Regardless of fragility, when a message comes in, it does a bit of sanity checking to make sure the message is valid. If it is valid, it does an HTTP POST and passes the JSON message along, stripping the hash key. The MD5 hash is just used for serial, TCP should handle error correction in a real software stack.

Here’s the function that posts to rails.

# do JSON HTTP post to rails
def post_json(url, input_json)
 
  # we don't need the serial hash anymore so we
  # can reuse the serial json payload from the sensor
  input_json.delete "hash"
 
  # parse our input url
  uri = URI.parse(url)
 
  # make a new request
  req = Net::HTTP::Post.new(uri.path, initheader = {'Content-Type' =>'application/json'})
 
 
  # have to format it as json again with .to_json to avoid a
  #   undefined method 'bytesize' for #<Hash: ...
  # error message.
  req.body = input_json.to_json
 
  response = Net::HTTP.new(uri.host, uri.port).start {|http| http.request(req)}
  puts "Response #{response.code} #{response.message}: #{response.body}"
end

When it goes through, you see this on the console.

VALID: <metric>, proximity:0 running:false
Posting to http://localhost:3000/sinks/ -->
{"sensor"=>"sinks",
"name"=>"basement",
"proximity"=>"0", "running"=>"false", "type"=>"metric"}
Response 200 OK : mapped json_request.

The response message “mapped json_request” is coming from a Rails action which I’ll talk about next.

Rails and MongoDB

The rails app was pretty straight-forward. I played around with MongoDB
and the Mongoid gem (for ORM) for a few days, making some sample projects and reading up about document design (vs schema design). I’m not an expert on MongoDB but I got enough working to starting loading data in.

I created a sensor registration page and model where I identify sensors by name, ie: “sink”. And then the json post updates the values for that sensor name and type. I should really use IDs as keys but this is pretty easy and flexible to just use names.

Sensor registration

The interesting part was flipping on versioning in the Mongoid gem. This gave me automatic versioning on historical states of the sink. With this enabled, I could make a graph summarizing what hours the cat drinks the most (or whatever report). Versioning is dead simple to enable but later it would turn tricky to work with because the queries are very different in MongoDB vs a SQL database.

My model with versioning looks like this:

class Sink
  include Mongoid::Document
  include Mongoid::Timestamps
  include Mongoid::Versioning
 
  validates_uniqueness_of :name
 
  field :running, :type => Boolean
  field :proximity, :type => Boolean
  field :collected_at, :type => Time
 
  def plot_by_hours
    hours_hash = Hash.new(0)
 
    # count up our hours
    self.versions.each do |v|
      # we only care about when the sink is running to count cat drinking
      if v.running == true
        hours_hash[v.collected_at.hour] += 1
      end
    end
 
    hours_hash[self.collected_at.hour] += 1
 
    total = 0
    hours_hash.each_key do |h|
      total += hours_hash[h]
    end
 
    hours_percentage = Hash.new
    hours_hash.each_key do |h|
      percent = hours_hash[h].to_f / total.to_f
      hours_percentage[h] = (percent.round 2) * 100
    end
 
    # flot needs an array of arrays for data values
    hours_percentage.to_a
  end
 
end

The plot_by_hours method returns an array of of values that represents how many times the sink was tripped per hour.

 > Sink.first.plot_by_hours
 => [[23, 20.0], [22, 40.0], [18, 40.0]]

All this was enough to get a basic interface up and make a graph with flot.

Certainly there’s a ton of refactoring that could be done (if you look at the code especially). First, naming the model “Sink” is sort of stupid. It should be called “Sensor” or something like that. Second, I should not use font color tags because those are going away. Lastly, I should move the do-forever cat bridge serial monitor thing into a God process or something else that starts and ends with rails. But that would couple it to the webserver.

Development Problems

While building this whole thing, I ran into some places where I got stuck.

Servo buzzing
The biggest problem I had was getting the servo under control. The servo would buzz when moving to a position because the resistance of the handle would not let it get completely to the target position. For example: 90 is off and 180 is on. It would try to turn off but get to 91. At 91, it buzzes but it’s not moving enough to get to 90. I solved this by jerking to 20 and then moving to 70,80 and then 90. Seemed to work but then the microrax rig would eventually de-calibrate my fine tuning. I was not happy about this and it wasn’t very elegant. I tried many times simply to turn off the servo when it was done moving but many attempts would cause the servo to completely reset itself which would jerk the handle violently as it went back to position 0 and then to 90 (or 180 whatever). For a long time I didn’t think turning off the servo was actually possible. I thought the Arduino servo library was either buggy or incapable of doing what I wanted. I kept playing with it and I really don’t know exactly how but I managed to get a bit of working code that did turn off the servo after moving. This way, I don’t need to jerk to 91,70,80 or anything else weird. I just move, turn off. The snippet of relevant code for turning off an Arduino servo is below:

// full code available, this is just an excerpt
void setup() {
// attaches the servo on pin 9 to the servo object
  servo.attach(9);
}
 
// do forever loop
void draw() {
 
// if cat detected, move faucet to on
servo.attach(9);  // reattach
servo.write(105);  // or whatever angle
servo.detach();  // this would jerk/spaz the servo out
....
 
// cat is gone, move faucet to off
servo.attach(9);  // reattach
servo.write(85);  // or whatever angle for off
servo.detach();  // this would jerk/spaz the servo out
}

The important thing to get out of the code here is that the servo detaches after moving and only reattaches when it needs to move. This is way better than just moving and staying attached because it won’t buzz if it doesn’t reach its destination.

Frame torque
Torque on the faucet handle was a problem. When the faucet would turn on, the opposite force would torque the frame. I had to “anchor” it with some hobby putty. A better solution would be to clamp it down but I didn’t have a lot of lip around my sink to do that.

Flot
Flot is what I used to draw the graph. It’s a client-side javascript graphing library. Flot is nice but it gave me a lot of trouble trying to figure out exactly what format it needed the data coming from the rails webservice to return. I had to play with this a lot and sometimes it would silently die (like javascript likes to do). I was using Chrome to test but I switched to Firefox with Firebug to help catch the javascript errors. Getting the javascript data from the rails app (really from the DB) to the jQuery graph was a pain. I got stuck on this for at least a week. But flot is really cool. No imagemagick problems.

Deployment Problems
After getting ready for “deployment” (where I wanted to take my code from my laptop and put it on my home Linux box), I found that Ubuntu was really out of date on my server. So I ran a bunch of `do dist-upgrade’ commands on it to update it and that’s when my server’s HDD died. I mean, I guess it’s a logical time for it to die. The dist-upgrade thing lights up the disks pretty good.

Luckily, I had the root disks mirrored so I could get all the data off (not much). The problem was, it’s software raid and it was using mdadm instead of the newer LVM. Compounded by that, it was still running some older version of Ubuntu so I couldn’t just switch to LVM and re-mirror the disks. A bit of an environmental issue but lesson learned, just spring for the 3ware card.

So I ordered a new one and ran into problems there. The box I am using is a Shuttle SFF thing. It was supposed to have graphics on it. Well guess what. You have to buy a CPU with graphics on it (wut). The i5-750 doesn’t have a GPU on it and the Shuttle VGA port is actually just a pass through for the GPU on the CPU. So I had to buy a i5-650 which fixed this problem.

Then I had a virtual console resolution problem. Console mode would boot up at 1680×1050 (way too high a resolution and VGA cable noise). Setting nomodeset fixed it.

Then I had a networking problem. Large secure copies over SSH (or presumably anything) would cause kernel panic with r8169 network driver. I tried moving to 2.6.37-20637rc2 off ubuntu’s ppa site but it would still happen. I wasn’t even past the OS build at this point. I was just trying to copy some files over (not even code) and the box would panic. Awesome. Well, I’m glad I found it early. So eventually I found that the r8169 driver sucks. Everyone said to use the r8168 driver even if that doesn’t match the chip exactly. Apparently the devices are really similar but the drivers are very different in terms of stability. Ok! Yak shaving ho!

This solution worked. It’s pretty lengthy and I’ll save it for another post. There’s some stuff on the web about it. Basically you use dkms to build a module that supposed to be updated everytime you update the kernel. It actually worked pretty well for a while but I had to undo it all because of the next problem.

So I had a working box at this point and I built up all the DBs, loaded code and tools (rails3, rvm, etc). I documented all of the install as I went and made a cheat sheet that’s come in handy ever since (I’ll post it later).

Unforunately, I ran into massive problems with the usb-serial port driver. My bridge script cat_faucet_bridge.rb wouldn’t start because it can’t open /dev/ttyS0 or /dev/ttyUSB0. The new kernel had a problem with the usb-serial driver. So I was stuck. I could either have:

1. a box that works with my Arduino but crashes under 90MB of network traffic transfer (or who knows under what load)
2. a box that doesn’t work with the Arduino but has a rock-solid network driver

Awesome! Either options are useless because I needed both. I tried building my own kernel from source (which I’ve done many times back in the day) but it was turning out to be a lot of work because of how Ubuntu packages it’s thing and runs grub-update. Also, picking modules can be tricky. I didn’t want to get in my Delorean and be a sysadmin again. So I gave up. Which turned out to be the right solution because another Ubuntu PPA hit (2.6.38-020638rc5-generic) that fixed everything.

False hits

So now the Arduino is running, sending data to the cat bridge which is posting JSON to rails which is storing everything in MongoDB. It works great. Now I can figure out at what hour in the day my cat drinks the most. Except when I wash my hands in the sink and trip the IR sensor. Now I have a MongoDB entry in the versions document that’s a false positive. I need to go into the DB and remove it manually (or add an interface to do this).

My collection looks like this:

{ "_id" : ObjectId("5d5c9d56f2c31e1d0f000001"), 
"collected_at" : "Tue Mar 01 2011 18:12:12 GMT-0500 (EST)", 
"created_at" : "Wed Feb 16 2011 23:00:23 GMT-0500 (EST)", 
"name" : "basement",
"proximity" : false, 
"running" : false, 
"updated_at" : "Fri Mar 04 2011 19:39:18 GMT-0500 (EST)",
"version" : 5, 
"versions" : [
        {
                "version" : 1,
                "collected_at" : "Wed Feb 16 2011 23:00:32 GMT-0500 (EST)",
                "created_at" : "Wed Feb 16 2011 23:00:23 GMT-0500 (EST)",
                "name" : "basement",
                "proximity" : false,
                "running" : false,
                "updated_at" : "Wed Feb 16 2011 23:00:32 GMT-0500 (EST)",
                "_id" : ObjectId("4d6879ddf2c31e2ede000001")
        },
        {
                "version" : 2,
                "collected_at" : "Thu Feb 17 2011 22:16:05 GMT-0500 (EST)",
                "created_at" : "Wed Feb 16 2011 23:00:23 GMT-0500 (EST)",
                "name" : "basement",
                "proximity" : true,
                "running" : true,
                "updated_at" : "Thu Feb 17 2011 22:16:05 GMT-0500 (EST)",
                "_id" : ObjectId("4d6879ddf2c31e2ede000002")
        },
        {
                "collected_at" : "Thu Feb 17 2011 22:16:13 GMT-0500 (EST)",
                "created_at" : "Wed Feb 16 2011 23:00:23 GMT-0500 (EST)",
                "name" : "basement",
                "proximity" : false,
                "running" : false,
                "updated_at" : "Thu Feb 17 2011 22:16:13 GMT-0500 (EST)",
                "version" : 3,
                "_id" : ObjectId("4d6879ddf2c31e2ede000003")
        },
        {
                "collected_at" : "Fri Feb 25 2011 22:56:13 GMT-0500 (EST)",
                "created_at" : "Wed Feb 16 2011 23:00:23 GMT-0500 (EST)",
                "name" : "basement",
                "proximity" : true,
                "running" : true,
                "updated_at" : "Fri Feb 25 2011 22:56:13 GMT-0500 (EST)",
                "version" : 4,
                "_id" : ObjectId("4d6879e4f2c31e2ede000004")
        }

So let’s say that I just tripped the sink. The sink has a versions[] nested document because Mongoid has its versioning feature set to on. Version 2 has a running:true attribute, Version 3 has running:false and the current version (5) is false. That means the sink started off, turned on (by a cat) and turned off. Then I accidentally turned it on (version 4). I only graph and care about running:true because I’m graphing what hour the sink turns on. So all I have to do is rollback the version in the versions embedded document.

Well it’s not that easy on the command line. First of all, I really want to pop off a version and substitute the current version with what I popped off the versions[] array. I don’t know how to do that in the mongo shell. Maybe it’s possible. I can explain (however temporary) how I fix problems like this until I do it in the ORM layer (Mongoid) and build a proper UI around it.

First, make a backup. MongoDB is unforgiving. The command mongodump -d database_name -o ~/tmp will dump a binary dump that is not plain-text like mysqldump (unfortunately). I was able to drop and re-import a collection like this:

// drop the collection I just eff'd up in the mongo shell
> db.mycollection.remove();

# now I can restore my collection from the Unix shell
$ mongorestore -d database_name -c mycollection ~tmp/database_name/mycollection.bson

Of course there are many options other than this. But now that I have some confidence in messing with my data directly, so I updated the false positive. To do this, I need to delete 2 versions from my versions[] embedded document and possibly update the current document’s date. I don’t always need to update the data (if it’s running:false I don’t care) but I thought I’d mention how to do it anyway.

// rollback the current document's date, replace the string in new Date() with a timestamp
db.sinks.update( { _id:ObjectId("5d5c9d56f2c31e1d0f000001") },
{$set: {'collected_at' : new Date("Tue Mar 01 2011 18:12:12 GMT-0500 (EST)") }});
// delete versions, sets to nulls
db.sinks.update( { _id:ObjectId("5d5c9d56f2c31e1d0f000001") }, {$unset: {'versions.3':1}});
db.sinks.update( { _id:ObjectId("5d5c9d56f2c31e1d0f000001") }, {$unset: {'versions.4':1}});

Lessons Learned

1. The Arduino has very little memory and is annoying to code on. This is because I’m used to rapid high level languages and embedded C is very far away from that. I’m not trolling, it was really annoying when doing simple MD5 things took a night or two. There’s also memory problems and when things crash they crash hard with no exception handling. My best advice is to try to get your problems off the Arduino as soon as possible.
2. The adjustable nature of Microrax means you don’t have to be 1/16″ accurate on your hacksaw skills. This is nice.
3. If you build something intricate with Microrax, order lots of extra bolts, back-plates and joint pieces. The lengths of aluminum channels don’t go quick but the joint pieces do.
4. Servo torque changes depending on the voltage given.
5. Installation is a bit tricky. Don’t be afraid to change your design.
6. Calibration of the physical space is key. Environmental and slight adjustments will be necessary unless you have many, many safeguards and overlapping functionality.
7. Iterate, iterate, iterate
8. Don’t over-engineer. Check your assumptions with simple tests.

The Biggest Lesson

The biggest thing I learned from all this is how a project like this resonates with people more than software. When a friend would come over, it was a more interesting presentation because of the physical component versus just a pure software demo.

Here’s my IRC Arduino Bot. It uses a regular Arduino 328 and an Ethernet Shield both from sparkfun. As for software, I’m using the Ethernet2 library (see my previous post about this), the WString library and a homerolled IRC protocol parser. The breadboard’s power is connected to arbitrary pin 5 and some resistors to keep the LED from burning out.

Basically, my bot joins an IRC channel and then listens for PRIVMSG commands starting with a password. It takes those commands and controls an LED. For example, I’d send this privately to the Arduino:
command password LEDON

And then the red LED comes on. I tell it “LEDOFF” and it turns off. Ok, it’s not a new RFC spec worthy of IEEE recognition and international adoption. But it got the job done in a human-readable manner. Previously on my facebook status light project, I had done much of the processing on my laptop and only send hex codes to the Arduino to light up LEDs. The difference now is that the Arduino is doing the processing and no computer is needed.

While I was working on this little project, I had the bot join the channel and announce itself.

At one point, I was working on code and then my bot would disconnect. I checked the serial monitor and the server seemed to drop me after a few minutes. The channel would say that I timed out. I realized that I wasn’t responding to the PING from the server. So I threw in some code that checks for anything from the server that starts with “PING :”. I then respond with “PONG”. I remember seeing PING?/PONG! messages in mIRC back in the day. Now it makes sense why mIRC was doing that in the console window.

It works great and I was excited about how much this little board could do in 14KB. And then I kept testing it. After about 7 or 8 “turn on” and “turn off” commands, the Arduino wouldn’t do anything anymore. It’s like it just froze. If I typed 5 commands, it’d stay connected for a long time. But every time I’d send it 7 to 8 commands, it would lock up. And by lock up, I mean the commands wouldn’t work anymore and it would time out from the server. WTF. So close!

So I figure that it’s something to do with pointers and memory. I really don’t have a solid grasp on pointers and C. I got a lot of this working by iterative experimentation over many days. So I was looking for a better way to send human readable commands to my bot. By human readable I mean something that works like a unix command “command arg1 arg2″. Of course this human readable bit introduces strings which is tricky enough in C (for me) and even worse on the Arduino. I figured this was a problem that someone smarter than me had solved.

I found a library called Messenger. It’s pretty simple to install, just throw it in your ~/Documents/Arduino/libraries folder on Mac and um … the equivalent on Windows? There are examples in the Messenger folder that you can checkout. HOWEVER the whole point of me posting this big long thing is the following.

The example checkString really threw me for a loop. It did exactly what I need it do to in a much cleaner way. I uploaded to the Arduino and then broke out to a shell.

$ screen /dev/tty.usbserial-A9005bCr 115200

Substitute your virtual usb device for the /dev/tty path. Note that the sketch uses 115k serial speed. You won’t see anything when you type but if you hit “enter” (to clear the buffer) “on[enter]” in screen LED 13 will turn on. Type “off[enter]” ([enter] means the enter key) and it will turn off. Great! Exactly what I need. But then I tried typing “on” then “off” then “muffins” then “on” and the light stayed off. Any garbage gets the Arduino stuck like my sketch. Ok, is what I’m trying to do impossible or is this just coincidence?

I modified the checkString example to look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// This example demonstrates Messenger's checkString method
// It turns on the LED attached to pin 13 if it receives "on"
// It turns it off if it receives "off"
 
 
#include <Messenger.h>
 
 
// Instantiate Messenger object with the message function and the default separator 
// (the space character)
Messenger message = Messenger(); 
 
 
// Define messenger function
void messageCompleted() {
  // This loop will echo each element of the message separately
  while ( message.available() ) {
    if ( message.checkString("on") ) {
      digitalWrite(13,HIGH);
    } else if ( message.checkString("off") ) {
      digitalWrite(13,LOW);
    } else {       // ADD THIS
      break;     // ADD THIS
    }                // ADD THIS
  }
 
 
}
 
void setup() {
  // Initiate Serial Communication
  Serial.begin(115200); 
  message.attach(messageCompleted);
 
  pinMode(13,OUTPUT);
 
}
 
void loop() {
 
  // The following line is the most effective way of 
  // feeding the serial data to Messenger
  while ( Serial.available() ) message.process( Serial.read() );
 
 
}

I added the break and it’s able to deal with garbage. I tested more than 20 commands with banging on the keyboard in between and it seems pretty solid. Now I just need to integrate this with my IRC bot and I might have something that can stay online for a while.

By the way, after you use screen to connect to a serial port, hit “Ctrl+A, k” to kill the window and break out of screen.

Update: People have asked for the code. It’s posted after the break.

// UNSTABLE IRC BOT
// TODO: Integrate with Messenger.h for stability
#include <Ethernet2.h>
#include <WString.h>
 
#define STRING_BUFFER_SIZE 128
String buffer = String(STRING_BUFFER_SIZE);
 
// string variable to hold server name detection
String hostString = String(50);
 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
 
// CHANGE ME
byte ip[] = { 1, 2, 3, 4 };  // arduino IP: 1.2.3.4
byte gateway[] = { 1, 2, 3, 4 };  // your router IP: 1.2.3.4
byte subnet[] = { 255, 255, 255, 0 };  // your network mask
 
// irc.freenode.net
byte ircServer[] = { 74, 208, 174, 239 };  // IP of freenode.net
 
int responseWait = 100;         // default: 1000
int joinWait = 100;             // default: 1000
int pingCheckThrottle = 10000;  // check for PING event every 10 seconds once connected
int reconnectWait = 5000;
 
// CHANGE ME
char ircNick[20] = "DuinoFace";
char channel[20] = "#freebsToTheDee";
boolean isLoggedIn = false;
 
Client client(ircServer, 6667);
 
// turn on when debugging
boolean isDebugOn = true;
 
// logged in (in channel) status light
int ledPin = 2;
 
void setup()
{
  //router time?
  delay(500);
  Serial.begin(9600);	// opens serial port, sets data rate to 9600 bps
 
  // Say hello:
  debugNoLine("String Library version: ");
  debug(buffer.version());
 
  Ethernet.begin(mac, ip, gateway, subnet);
  delay(responseWait);
 
  debug("client.connect()");
  if (!client.connect()) {
    debug("client.connect() failed.");
  }
 
  // status light
  pinMode(ledPin, OUTPUT);
 
}
 
 
void loop()
{
  if (client.available() && client.connected()) {
    // parse the incoming buffer
    readIRCRequest(client);
  }
 
  if (!client.connected()) {
    debug("Disconnected");
    client.stop();
    delay(reconnectWait);
 
    debug("Reconnecting...");
    isLoggedIn = false;
    setStatusLight();
    client.connect();
  }
}
 
 
int readIRCRequest(Client client) {
  char inChar = client.read();
 
  if (inChar != '\n') {
    buffer.append(inChar);
  } 
  else {
    debugNoLine("Buffer: ");
    debug(buffer);
 
    if (!isLoggedIn) {
      if (buffer.contains("NOTICE * :*** No Ident response")) {
        login();
        buffer = "";
      } 
      else if (buffer.contains(":End of /MOTD command.")) {
        join();
      } 
      else if (buffer.contains(":End of /NAMES list.")) {
        say();
        isLoggedIn = true;
        setStatusLight();
      } 
    } 
    else {
      checkCommand();        
      checkPing();
      //delay(pingCheckThrottle);
    }
 
    // clear out buffer for next line read
    buffer = "";
 
  }
}
 
 
/* We need to send something that looks like this
 *   NICK yaytofu
 *   USER yaytofu 0 * yaytofu
 * Where yaytofu is our nickname
 */
 
void login() {
  String msg = String(50);
  msg = "NICK ";
  msg.append(ircNick);
  //if (debug) Serial.println(msg);
  debug(msg);
  client.println(msg);
  delay(responseWait); /* wait for a response */
 
  msg = "USER ";
  msg.append(ircNick);
  msg.append(" 0 * ");
  msg.append(ircNick);
  debug(msg);
  client.println(msg);
 
  delay(responseWait); /* wait for a response */
}
 
 
void join() {
  delay(joinWait);
  debug("JOIN...");
  client.println(strcat("JOIN ", channel));
  delay(responseWait);
}
 
 
void say() {
  //if (debug) Serial.println("Sending something to the channel.");
  debug("Sending something to channel.");
  client.println("PRIVMSG #freebsToTheDee :Arduino with Ethernet Shield is here.");
}
 
void say(char *msg) {
  debug("Sending something to channel.");
  client.print("PRIVMSG #freebsToTheDee :");
  client.println(msg);
}
 
 
void checkPing() {
  if (buffer.startsWith("PING :")) {
    debug("GOT PING!");
 
    // parse and store hostname in string
    if (hostString.length() == 0) {
      hostString = buffer.substring(5, buffer.length()-1);
    }
 
    // respond to ping
    debug("PONG!");
    client.print("PONG ");
    client.println(hostString);
    setStatusLight();
 
  }
}
 
void checkCommand() {
  // :nick!~nick@static-1-13-5-1.domain.com PRIVMSG #freebsToTheDee :wut
  // state codes 0=DNS   1=PRIVMSG   2=channel  3=message
 
  if (buffer.startsWith(":") && buffer.contains("PRIVMSG")) {
 
    int state = 0;
    int spaces[3] = { 0, 0, 0};
 
    // split on spaces, TODO: state check
    char *bufferArray = buffer.getChars();
    for (int i=0; i < buffer.length(); i++) {
      char test = bufferArray[i];
      if (test == ' ') {
        debugNoLine("found space at:");
        debug(i);
        spaces[state] = i;
        state++;
      }
    }
 
 
    String dnsName = buffer.substring(0, spaces[0]);
    String privMsg = buffer.substring(spaces[0]+1, spaces[1]);
    String channel = buffer.substring(spaces[1]+1, spaces[2]);
    String cmd = buffer.substring(spaces[2]+2, buffer.length());
 
    debugNoLine("dnsName:");
    debug(dnsName);
    debugNoLine("privMsg:");
    debug(privMsg);
    debugNoLine("channel:");
    debug(channel);
    debugNoLine("cmd:");
    debug(cmd);
  }
}
 
void setStatusLight() {
  if (isLoggedIn) {
    debug("Setting status light to ON.");
    digitalWrite(ledPin, HIGH);
  } 
  else {
    debug("Setting status light to OFF.");
    digitalWrite(ledPin, LOW);
  }
}
 
// No carriage return
void debugNoLine(char *msg) {
  if (isDebugOn) Serial.print(msg);
}
 
// No carriage return overloaded
void debugNoLine(String *msg) {
  if (isDebugOn) Serial.print(*msg);
}
 
void debugNoLine(int *msg) {
  if (isDebugOn) Serial.print(*msg);
}
 
// Carriage return
void debug(char *msg) {
  if (isDebugOn) Serial.println(msg);
}
 
// Carriage return overloaded
void debug(String *msg) {
  if (isDebugOn) Serial.println(*msg);
}
 
void debug(int msg) {
  if (isDebugOn) Serial.println(msg);
}

Be sure to change the two sections of CHANGE ME. Also please note that like I said in my post, I never integrated these two source files together. So the IRC bot is unstable after about 8 commands.

After it was put together I had a few built-in LED lights to play with. I had seen this 555 timer in a piece kit I bought and I wondered what it does. I found a ton of examples and apparently you can do a zillion things with it. I wanted to start with the basics so I set out to make a light blink using only hardware. I’m only using the arduino for power in this one.

I found a great tutorial on youtube and modified it to work on a larger breadboard. I had some trouble because it turns out that this breadboard has its power rails split down the middle. I was confused and stuck on this for a day. Eventually I found a video that hinted at this fact and connected the two sides like so. After that, the power rails on each side will work like I expected. This is by design on these boards so that you can have two different voltages but I found it annoying.

So here’s the schematic that I followed for the configuration on the big breadboard.

I transferred this layout onto a mini breadboard and it works like a champ. The protoshield has room for a mini self-adhesive breadboard. Here’s the actual wiring shot. This uses a light on the protoshield vs the light on the breadboard schematic. The concept is the same though. Pin3 on the 555 is the output which makes the light blink rapidly. You could use this chip as a cpu clock for example.

You don’t have to use the breadboard switch (the black thing on the left), it’s just more convenient to flip a switch rather than plug in/out of the 3v. Oh yeah it’s powered by 3v on the arduino. The cap is 100uf. You can use 2x orange,orange,maroon (gold) resistors or one of those and a blue,gray,maroon one (sorry I don’t have the resistance values). Play with the resistor values to change the blink rate.

$ svn co http://tinkerit.googlecode.com/svn/trunk/Ethernet2%20library/Ethernet2

Now change your sketch to use Ethernet2.h instead of Ethernet.h. Wondeful? No. You’ll get this error in 0017.

'EthernetClass' has not been declared

Ok, the forums have a fix. But it didn’t work for the longest time because I didn’t know what they meant by Server.cpp. There’s two of them! The original or the new one?! If you edit the old one you’ll get this:

Print.cpp:129: first defined here

So:
1. Edit Server.cpp in Ethernet2 to include Ethernet2.h and not Ethernet.h.
2. Delete the Print.cpp and Print.h files from Ethernet2.
3. Compile.
4. Have some yay.

I also put together a wingshield kit. I makes connecting wires to the arduino a little more stable because you can screw them into the screw terminals. I seriously screwed up at one point, snipping off the header pins when you aren’t supposed to snip them, doh (what will plug in to the headers if you snip the pins?). I had to desolder and use parts from another kit. Amazingly the desoldering went better (although it takes a long time) and the shield seems to work.

WRL-08664 XBee 1mW Chip Antenna
DEV-09063 Arduino XBee Shield Empty
KIT-09285 Beginner Parts Kit
DEV-09282 ScrewShield
DEV-00666 Arduino USB Board
LCD-00258 Serial Enabled LCD Backpack
TOL-09465 Tool Kit - Beginner
TOL-09317 Third Hand
KIT-09343 Simon Game - Through-Hole Soldering Kit
TOL-00298 Wall Adapter Power Supply - 9VDC 650mA
SEN-08958 Infrared Proximity Sensor Long Range - Sharp GP2Y0A02YK0F
SEN-08733 Infrared Sensor Jumper Wire - 3-Pin JST

Chief amongst the loot was a soldering iron and a simon game kit. Really, I could care less if the thing worked. I wanted to learn soldering. I seriously have never done it before. I couldn’t believe my eyes when the damn thing lit up and worked! I thought for sure my scorch marks had screwed something up. When I was soldering the legs on the mega-168 processor the thing got warm. I was working kind of fast and nervous. I guess I didn’t burn anything too bad. Many of my connections look like shiz and I have pointy parts all over the place. I was really trying to peer and study how the solder was making the connections. I’d shake and bend the pins to see how much strength it had and so on. I was really surprised at out unintuitive the whole process is. You’d think it’d be harder but after doing the same pins over and over you start to see what a good solder bead looks like. I just followed the instructions (some of which were a bit off because of a newer board rev) and it wasn’t too hard when I took my time and read ahead making sure I wasn’t doing something stupid.

Crazy pants! I can’t believe it worked! The cheapy soldering iron and solder they sent with a starter kit worked really well. I just held the solder inside the plastic tube it came in. I thought that the cheapy iron would be crappy but it worked well. I got some helping hands to help. They helped. :D What was also helpful was having a workbench, damp sponge, helping hands and some youtube videos for instruction. It’s just not as hard as I thought it was. Now SMD soldering, I have no idea how people do that.

So really I was expecting the kit to be a learning experience and I’d throw it away. But somehow, despite the weird and PCB-stress-inducing battery clips, the Simon game worked. When it lit up and I played a little game of simon, I was really surprised. Kristin has it on the coffee table and she plays it a lot. I don’t think she ever played it in the 80s, weird. I tweeted about my success and the freaking official Sparkfun twitter account saw my #sparkfun tag and congratulated me. Awesome!

After a holiday break, a sudden rush of software-type-hacky-motivation came to me. I grabbed my arduino and laptop and checked it out. First, it didn’t work. The laptop is new and I had to set up the dev-env again. Apparently the default now is the ATmega328 and my Arduino is based on the ATmega168. After that was settled, I had a led blinking again.

So I had this Hitachi based LCD panel that I had never done anything with. I got it powered (3.3v) and was trying to figure out how to run the thing. I read and read and found that I didn’t have the right crap on hand. First, it seems like there’s two ways to drive it. You can drive it “manually” with a bunch of parallel type wires or you can buy a serial backpack and solder it on (I think). I tried getting things working parallel but it turned out to be a little more than I was comfortable with. I don’t understand multiplexing yet and I actually didn’t have enough hook up wires to get it done. So part of the order you see up top is a serial backpack. Well somehow I managed to get it wired up but it’d short out my Arduino board, I was just using the board for power. My LED would fade away, it seems to do that when I short something out. Thinking that this was a power problem, I plugged in the 9v adapter with the usb (5v). Well then I started smelling a plastic smell. I heard a crackle and then I saw a little bubble appear on the backpack chip. Ow. I threw it away and I don’t have a picture of it. All it reminded me off is when Tim and I burned up a southbridge on my old AMD computer. Smells like fail.

So I just played around with the broken backpack. I desoldered some of the headers off for practice. Desoldering is hard, I burned up the PCB pretty bad but it was a good learning experience. Then threw it away. I ordered a proper serial LCD from sparkfun. I recently got that working electrically although the code side of it I need to clean up a little bit and grok it some more.

I built an arduino project that monitor’s Facebook online status (the chat app in the lower right when you are on the facebook page). It lights up bright when someone is Online, dimly lit when idle and is unlit when someone is offline. I wired 3 LEDs so it can only monitor 3 people as of right now. It won’t tell you who is who because there’s no text display. I suppose you could make little stickers. In the end, it’s a simple little project that provides a benefit of being able to have a small secondary display of who’s on and not. Is the little device a keeper? Would people want it? Probably not. This was a test.

It was a fun little project but it had a lot of challenges. First, this is an online app with dependancies on online resources. I read forums and wikis and saw that much has changed lately with Facebook’s API. So this is an article about how I got it working but doesn’t mean that it’s going to work for you. Things change online and at best this might be a starting point in how to “get your arduino online”. When things change online, this article can get dated.

And about that online bit. The arduino is just a simple microprocessor. I found that a lot of fancy Java features won’t run on it. Strings, System.arraycopy and many network Java packages just aren’t supported. So you’re going to need a laptop or computer hooked up to the arduino to make this work. The arduino doesn’t have a direct network adapter on it, a network stack or a lot of RAM. It’s job is to do the simple stuff like blink LEDs. So I found it’s best to keep the arduino code simple.

Two apps run. One is the Processing app which connects to Facebook and queries 3 facebook IDs for their status. One is an Arduino app that simply loads the code onto the Arduino. The Processing app has to stay open because it queries every 10 seconds and sends special codes to the Arduino. The codes may look like this:

#0FF = 1st LED full brightness, 1st friend is online
#110 = 2nd LED dimly lit, 2nd friend is idle
#000 = 1st LED off, 1st friend went offline
#2FF = 3rd LED full brightness, 3rd friend came online

The first character, #, is just a marker. The next character tells the arduino which LED to light up (starts with 0), The next two characters is a hexadecimal number telling how bright to light up the light 0-255. So the Processing app queries Facebook and sends a code over serial to the Arduino. The Arduino parses the code and changes the LEDs.

Dependencies

There are a ton of dependencies that you’re going to need.
- Facebook account
- A dummy app on facebook, instructions below.
- An infinite session key (also called offline access). This allows you to create a desktop app that doesn’t have to be in a web container (nor prompt for a facebook login).
- An arduino and some simple electronics components. I ordered a starter kit from Amazon for $40.
- Processing
- The arduino IDE
- A facebook java API from google code. It has some dependancies that should be covered by the below steps.

Wiring the arduino

If you mess with the arduino a lot, it shouldn’t be a problem to wire 3 LEDs. But I’ll try my best with my non EE background and crappy drawing skills. The longer lead on the LED is the + side (the signal) and the shorter is the ground. Put your LEDs anywhere on your breadboard, + on the left. Run 3 signal wires to your breadboard and connect them to the + side (the left). Each LED needs to be grounded. I used a common ground along the top (the – symbol at the top left of the above diagram). I didn’t use the common + on the breadboard because each LED needs to light up independently.

This is the basic approach I took wiring mine. Now, my green LEDs are weak so I added a few to make it brighter. My blue LED is blinding so I added a resistor in the lead to it (still is too bright). It’s pretty messy in there.

Arduino code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

int val = 0;
char buffer[7];
char oldBuffer[7];
int pointer = 0;
byte inByte = 0;
 
// define pins
int red = 10;
int green = 11;
int blue = 9;
 
byte r = 0;
byte g = 0;
byte b = 0;
 
void setup() {  
  // set pinouts
  pinMode(red,OUTPUT);
  pinMode(green,OUTPUT);
  pinMode(blue,OUTPUT);
 
  // open serial port
  Serial.begin(9600);
 
  Serial.println("DONE WITH SETUP!");
}
 
void loop() {
  if (Serial.available() > 0) {
    // read incoming byte
    inByte = Serial.read();
 
    if (inByte =='#') {
      Serial.println("Got something with #");
      Serial.println(inByte, DEC);
      while (pointer < 3) {
        buffer[pointer] = Serial.read();
        pointer++;
        Serial.println(buffer[pointer], DEC);
      }
     if (buffer[0] == '0') {     
      r = hex2dec(buffer[2]) + hex2dec(buffer[1]) * 16;
     }
     if (buffer[0] == '1') {     
      g = hex2dec(buffer[2]) + hex2dec(buffer[1]) * 16;
     }
     if (buffer[0] == '2') {     
      b = hex2dec(buffer[2]) + hex2dec(buffer[1]) * 16;
     }     
    }
 
      analogWrite(red, r);
      analogWrite(green, g);
      analogWrite(blue, b);
 
      pointer = 0;      
      }
 
      delay(100);
}
 
// convert on HEX characeter into decimal number
int hex2dec(byte c) {
  if (c >= '0' && c <= '9') {
    return c - '0';
  } else if (c >= 'A' && c <= 'F') {
    return c - 'A' + 10;
  }
}

Fire up the Arduino IDE and paste this in. Hit Command+U (or the menu equivalent) to upload the sketch to the board. Now click the serial monitoring button (it’s the one all the way to the right). This will let you send and receive serial messages. Try sending #0FF. The board should light up the first blue LED all the way to full brightness. Try #1FF and #2FF. If those work then you’re good to go.

Now comes the Facebook stuff. This part takes the longest. Sign into facebook (of course you have an account) and go to http://developer.facebook.com/. Create a new app, just follow the wizard steps (you can name it anything). Then write down your API_KEY and SECRET_KEY. They’ll be used quite a bit below.

First, we need to get an infinite session key from Facebook. I found some code online that gets part of the way there but it was extremely confusing as to what to do with it. It took me many hours to realize that what is returned by this class is the infinite session key.

Go to the main method below and change API_KEY, SECRET_KEY and AUTH_TOKEN_HERE. Compile this code with javac (or in Eclipse). Now run it. It will return a raw http response with a session element in it. It will be a long hash type value. Copy this, this is the infinite session key.

Infinite session key code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

/* 
 * Web Site: http://as-m-going-on.blogspot.com/2010/05/tiny-java-connector-for-facebook.html
 * Author: Prasanta Paul 
 *---------------------------------------------- 
 *Command Line Option 
 *-Dhttp.proxyHost=your.proxy.dom -Dhttp.proxyPort=XX 
 *----------------------------------------------- 
 * TODO: Write a wrapper for HTTP Post 
 * TODO: XML Parser to parse API output 
 */
package com.excoflare.facebook;
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.util.Arrays;
import java.util.Date;
 
public class FBAgent {
	private URL FB_URL = null;
	private String SECRET;
 
 
	private String apiReqParms[] = null;
	private int parmIndex = 0;
 
	public FBAgent(int numParms) {
		try {
			parmIndex = 0;
			apiReqParms = new String[numParms];
			FB_URL = new URL("http://api.facebook.com/restserver.php");
		} catch (Exception ex) {
			printLog("Error: " + ex.toString());
			ex.printStackTrace();
		}
	}
 
	public void setAPISecret(String secret) {
		this.SECRET = secret;
	}
 
	public void addAPIParm(String key, String value) {
		apiReqParms[parmIndex++] = (key + "=" + value).trim();
	}
 
	public void sendHTTPRequest() throws Exception {
		String reqParms = "";
		for (int i = 0; i < apiReqParms.length; i++) {
			reqParms += apiReqParms[i];
			reqParms += "&";
		}
		// Add Signature
		reqParms += "sig=" + genSig();
		printLog("Data to Reg=" + reqParms);
		if (FB_URL == null) {
			printLog("Empty URL....");
			return;
		}
		HttpURLConnection conn = (HttpURLConnection) FB_URL.openConnection();
		conn.setRequestMethod("POST");
		conn.setDoOutput(true);
		conn.setDoInput(true);
		conn.setRequestProperty("Content-Type",
				"application/x-www-form-urlencoded");
		conn.connect();
 
		// Send Request Parameters
		printLog("Sending Request Parameters...");
		OutputStream out = conn.getOutputStream();
		out.write(reqParms.getBytes());
		out.flush();
 
		printLog("Response Code=" + conn.getResponseCode());
 
		printLog("Get Response...");
		BufferedReader rd = new BufferedReader(new InputStreamReader(conn
				.getInputStream()));
		String line;
		StringBuffer outputData = new StringBuffer();
		while ((line = rd.readLine()) != null) {
			// Process line...
			outputData.append(line);
			printLog(line);
		}
 
		out.close();
		rd.close();
 
	}
 
	public String genSig() {
		try {
			// Sort Alphabetically
			Arrays.sort(apiReqParms, String.CASE_INSENSITIVE_ORDER);
			String reqParmsStr = "";
 
			// Concate
			for (int i = 0; i < apiReqParms.length; i++) {
				reqParmsStr += apiReqParms[i];
			}
			reqParmsStr += this.SECRET;
			printLog("Sig Input=" + reqParmsStr);
			// Get MD5 Hash
			MessageDigest md = MessageDigest.getInstance("MD5");
			md.update(reqParmsStr.getBytes());
			byte keyB[] = md.digest();
			printLog("Key=" + new String(keyB));
			printLog("Key-UTF=" + URLEncoder.encode(new String(keyB), "UTF-8"));
			return getHexCode(keyB);
		} catch (Exception ex) {
			printLog("Error in Generating Signature: " + ex.toString());
		}
		return "";
	}
 
	public String getHexCode(byte byteA[]) {
		byte dig = 0;
		char hexCode[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
				'a', 'b', 'c', 'd', 'e', 'f' };
		// Capital doesn't work
		String hexVal = "";
		byte msn, lsn;
		for (int i = 0; i < byteA.length; i++) {
			dig = byteA[i];
			msn = (byte) ((dig >> 4) & 0x0F);// Most Significant Nibble
			lsn = (byte) (dig & 0x0F);// Least Significant Nibble
			hexVal = hexVal + hexCode[msn] + hexCode[lsn];
		}
		return hexVal;
	}
 
	public void printLog(String msg) {
		System.out.println(msg);
	}
 
	public static void main(String args[]) {
		/*
		 * -------------------------------------------- Auth.createToken
		 * fb.addAPIParm("api_key", fb.API_KEY); fb.addAPIParm("method",
		 * "auth.createToken"); fb.addAPIParm("v", "1.0");
		 * --------------------------------------------
		 */
		try {
			FBAgent fb = new FBAgent(4);
			fb.setAPISecret("SECRET_KEY_GOES_HERE");
			fb.addAPIParm("api_key", "API_KEY_GOES_HERE");
			// Get auth_token from http://www.facebook.com/code_gen.php?v=1.0&api_key=API_KEY
			fb.addAPIParm("auth_token", "AUTH_TOKEN_HERE");
			fb.addAPIParm("method", "auth.getSession");
			fb.addAPIParm("v", "1.0");
			fb.sendHTTPRequest();
		} catch (Exception ex) {
			System.out.println("Error:" + ex.toString());
			ex.printStackTrace();
		}
	}
}

Now take your API_KEY, SECRET and AUTH (infinite session key) and put them into the below Processing code. Also change the Serial.list()[2] line to be your serial port. On mac, you need to install the usb to serial driver included with the Arduino IDE folder.

Processing code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

import processing.serial.*;
 
import com.google.code.facebookapi.*;
import org.json.*;
 
FacebookJsonRestClient facebook;
 
int interval = 10; // retrieve every 10 seconds
int lastTime;
 
// 3 Facebook IDs to watch
int[] ids = {  515470367,  // patton oswalt
               26670531942,  // mccoy tyner
              508305963}; // hugh mcleod
 
Serial port;
 
// Customize setup to fit your environment
void setup() {
  frameRate(10);
 
  String apiKey = "CHANGETHIS"; // your api key
  String secretKey = "CHANGETHIS"; // your secret
  String sessionKey = "CHANGETHIS";  // infinite session key goes here
  facebook = new FacebookJsonRestClient(apiKey,secretKey,sessionKey);
 
  // 
  String arduinoPort = Serial.list()[2];
  port = new Serial(this, arduinoPort, 9600); // connect to Arduino
 
}
 
 
 
void draw() {  
  int n = (interval - ((millis()-lastTime)/1000));
 
  if (n <= 0) {
 
    for (int i = 0; i <= 2; i++) {
      int uid = ids[i];
      String userStatus = fetchData(uid);
 
      /* light up arduino based on facebook status
         facebook API says: 
         online_presence string	 The user's Facebook Chat status. Returns a string, 
         one of active, idle, offline, or error (when Facebook can't determine presence
         information on the server side). The query does not return the user's Facebook
         Chat status when that information is restricted for privacy reasons.
         */
      if (userStatus.equals("active")) {
        sendSerial("#" + i + "FF");
      }
      if (userStatus.equals("idle")) {
        sendSerial("#" + i + "10");
      }
      if (userStatus.equals("null")) {
        sendSerial("#" + i + "00");
      }
      if (userStatus.equals("offline")){
        sendSerial("#" + i + "00");
      }
      if (userStatus.equals("error")){
        sendSerial("#" + i + "00");
      }
 
    }
 
    lastTime = millis();
 
 
  }
}
 
String fetchData(int uid) {
      try {
        String query = "SELECT name FROM user WHERE uid=" + uid;
        JSONArray resultArray = (JSONArray)facebook.fql_query(query);
        JSONObject result = resultArray.getJSONObject(0);
        print("Querying online status of " + result.getString("name") + ": ");
 
 
        query = "SELECT online_presence FROM user WHERE uid=" + uid;
        resultArray = (JSONArray)facebook.fql_query(query);
        result = resultArray.getJSONObject(0);
        String userStatus = result.getString("online_presence");
        println(userStatus);
        return userStatus;
 
} catch (Exception jex) {
  jex.printStackTrace();
}
return "";
}
 
void sendSerial(String message) {
  port.write(message);
}

Save this sketch but don’t run it yet. We’re missing some libraries.

Libraries for the facebook java lib need to go under: ~/Documents/Processing/libraries/facebook/library. I had the following jars in that folder. The json jar

activation-1.1.jar jaxb-api-2.1.jar
commons-logging-1.1.1.jar jaxb-impl-2.1.3.jar
facebook-java-api-schema-2.0.4.jar json-20070829.jar
facebook.jar stax-api-1.0-2.jar


All of these jars should come from the Google Code project I liked at the beginning of this post. After all these things are ready, get the arduino running and then run your Processing sketch.

It should pop up the default Processing window. There’s nothing sexy about this app. It has no GUI and writes simple status lines to the console. It will run until this window is closed. Every 10 seconds it should update the LEDs with the status from Facebook. I’ve found that the status isn’t always real-time. But it’s close enough for our purposes. You can change the IDs to monitor in the Processing code. The IDs can be found on Facebook by looking at someone’s profile. For example, Patton Oswalt’s profile page is http://www.facebook.com/profile.php?id=515470367. His ID is 515470367.

Conclusion

It was a fun little project. I’m glad I got it working in my time off from work. It took me about 6 hours straight and I was really in the zone at the end (1:15am). The facebook bits took me almost 4 hours just because of the lack of documentation about that freaking infinite session key. There are a lot of examples on the web on Java in a web container (or PHP) but very few desktop app examples.

Please let me know if you found this interesting, attempted it, ran into problems, have suggestions for improvements or anything else by leaving a comment.