A few months ago, I spent some time writing a MIDI sequencer for the Arduino. I finished the sequencer, wrote a couple of songs with it, and then got sucked into MSc thesis mode and had to abandon it.

Well, I’ve finally got round to publishing it as an open source project on Google Code, so hopefully others will be able to have some fun with it. I’ve also written some documentation which will hopefully make it a little easier to get started creating music with it. I’ve named it ‘Cahors,’ which is a word I found in The Deeper Meaning of Liff. See the FAQ page on the Google Code side for a full explanation.

http://code.google.com/p/cahors/

You can hear the first full piece I wrote with Cahors on last.fm here, or you can download the MP3 from the Google Code project page. I’ve not had a chance to go back and write and more music for it recently, but hopefully I’ll get back into that soon.

into this..

I was given a lovely glowing cube by the generous people at Linden Labs as a freebie at a job fair yesterday, and I decided that it was far too attractive to simply sit there on a shelf, pulsating forlornly until its batteries went flat. How about making it useful, while maintaining its visual appeal?

The following guide is deliberately fairly high-level, because the exact details will vary depending on your operating system and particular hardware setup. I did this with my Mac, but hopefully there’ll be enough information here for you make it work on your system, perhaps with a little Googling.

If you don’t happen to have a glowing cube lying around, you can modify this to work with almost any output device you could think of, from a simple LED, or a buzzer, to something far more clever like moving a servo (Gmail Notifier Robot, anyone?)

The basic system has three components:

• the software that runs on your computer,
• the electronics hardware that sits between the computer and the output device,
• and the software that runs on that hardware.

Every so often, the computer checks for new emails in your Gmail account, and then tells the electronics board whether any have arrived. If they have, the board turns on the output device (the cube). Simple.

Hardware

The hardware itself is the popular Arduino board, the tinkerer’s dream device. I’m actually using a Boarduino, but any variant should work (subject to a small but important detail, see below). This might be particularly interesting with a Bluetooth Arduino..

The Arduino talks with your computer over a serial connection, which runs over the normal USB cable you use to communicate with your Arduino.

Here’s the first important note: the latest Arduino Diecimila has an “auto-reset” feature which allows you to upload programs to the board without manually pressing the Reset button every time. This works by resetting the board whenever it receives any data over the serial port. Because we are going to be sending serial data to the board regularly, this is not what we want. Fortunately, this feature can be disabled on my Boarduino by simply removing a capacitor (C6), but it may be trickier on the official Arduino. Any suggestions for how to get round this in software would be gladly received (leave a comment!). One way is to simply keep the serial port open all the time (perhaps using the Serial Proxy, link at the bottom of this page). This solution isn’t much use for me, as I’ll be unplugging the USB connection regularly and don’t want to have to disable anything first. However this may be fine if your computer is a desktop and you can leave the Arduino plugged in all the time. If you go this route, you’ll have to use a different script running on the computer, and make sure it runs continually rather than repeatedly. I’ll leave this to you!

I connected up the cube using a PC fan extension cable from Maplin – simply because the connector on the end fits perfectly on the pins of my Boarduino. Use your own method to connect your output device.

I chopped off the “plug” end of the cable and soldered it onto the battery connectors on the cube, drilling a hole in the battery cover to allow the wires to pass through:

Connected up to the Boarduino for testing:

Software

This project requires two bits of software: one running on the Arduino to receive serial data and toggle the output accordingly, and one running on the computer to check for new emails and send data out over the serial port. To re-iterate, these code listings should only be used as a guide. They work for me, but I don’t guarantee they’ll work for you, and I accept no responsibility for breaking things. If you don’t understand what this code is doing, you probably shouldn’t be running it.

The Arduino software is fairly trivial. It just loops round, watching for bytes coming in over the serial port, and sets a variable called “mail” to be true if the data is an ‘M‘, and false if it’s an ‘N‘ (of course these characters are arbitrary). It then updates the value of the output pin to be equal to this mail variable. You can hack this and expand it or modify it however you like – perhaps you could make an LED blink when you have new email instead of just turn on?

1. int outPin = 12; // Output connected to digital pin 12
2. int mail = LOW; // Is there new mail?
3. int val; // Value read from the serial port
4.  
5. void setup()
6. {
7. pinMode(outPin, OUTPUT); // sets the digital pin as output
8. Serial.begin(9600);
9. Serial.flush();
10. }
11.  
12. void loop()
13. {
14. // Read from serial port
15. if (Serial.available())
16. {
17. val = Serial.read();
18. Serial.println(val);
19. if (val == 'M') mail = HIGH;
20. else if (val == 'N') mail = LOW;
21. }
22.  
23. // Set the status of the output pin
24. digitalWrite(outPin, mail);
25. }

Upload this to your Arduino, and then connect your output device to pin 12.

The software for the computer takes the form of a Python script, and is slightly trickier. First, it tries to open the serial port for communication with your Arduino. If it can’t do this (say, if your USB cable is unplugged), it quits immediately. If the serial port opens successfully, the script has to talk to Google’s servers to determine if you have any new email waiting for you. It does this by authenticating with your Gmail username and password, and then requesting the Atom feed for your inbox (this part of the script is based on code from here). It then parses out the line containing the number of unread messages (the XML tag is called ). If the unread message count is zero, it sends an ‘N‘ over the serial connection. If it’s greater than zero, it sends an ‘M‘.

This requires the pySerial library!

1. import urllib2, re, serial, sys
2.  
3. #Settings - Change these to match your account details
USERNAME="username@gmail.com"
PASSWORD="yourpassword"
4.  
5. PROTO="https://"
SERVER="mail.google.com"
PATH="/gmail/feed/atom"
6.  
7. SERIALPORT = "/dev/tty.usbserial" # Change this to your serial port!
8.  
9. # Set up serial port
10. try:
11. ser = serial.Serial(SERIALPORT, 9600)
12. except serial.SerialException:
13. sys.exit()
14.  
15. # Get Gmail Atom feed
16. passman = urllib2.HTTPPasswordMgrWithDefaultRealm()
17. passman.add_password(None, SERVER, USERNAME, PASSWORD)
18. authhandler = urllib2.HTTPBasicAuthHandler(passman)
19. opener = urllib2.build_opener(authhandler)
20. urllib2.install_opener(opener)
21. page = urllib2.urlopen(PROTO + SERVER + PATH)
22.  
23. # Find the mail count line
24. for line in page:
25. count = line.find("fullcount")
26. if count > 0: break
27.  
28. # Extract the mail count as an integer
29. newmails = int(re.search('\d+', line).group())
30.  
31. # Output data to serial port
32. if newmails > 0: ser.write('M')
33. else: ser.write('N')
34.  
35. # Close serial port
36. ser.close()

UPDATE: See below for a nicer version of this script.

Now, this script needs to be run regularly (say, once a minute) so that when you get a new email, your notifier will light up promptly. On Mac OS X, the launchd service handles, among other things, launching programs at set intervals (on other Unix systems liked Linux, you may need to use cron. On Windows, I have no idea – but I’d imagine it’s possible somehow).

Put this code in a .plist file (mine’s called org.j4mie.check-gmail.plist – I have no idea if you have to follow the weird naming format, but it works for me) and save it in ~/Library/LaunchAgents (create this folder if it doesn’t exist). Don’t forget to change the second ProgramArguments string to the location of your Python script.

1. <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>org.j4mie.check-gmail</string>
<key>OnDemand</key>
<true/>
<key>ProgramArguments</key>
<array>
2. <string>/usr/bin/python</string>
<string>/Users/yourusername/path/to/check-gmail.py</string>
</array>
<key>StartInterval</key>
<integer>60</integer>
</dict>
</plist>

UPDATE: As Jonas Stenberg pointed out in the comments, you may need to alter the /usr/bin/python string in this plist file to point to the location of the Python interpreter on your machine, for example /usr/local/bin/python2.5.

To load this plist file into launchd, type launchctl load ~/Library/LaunchAgents/org.j4mie.check-gmail.plist at the terminal (or reboot your computer).

And, with any luck, that should be it! Once a minute, your Python script will execute, checking for any new emails in your inbox. If any have arrived, your cube (or other output device) should spring into life!

UPDATE: Here’s a much nicer version of the Python script, using the Universal Feed Parser module from www.feedparser.org

1. import serial, sys, feedparser
2.  
3. #Settings - Change these to match your account details
USERNAME="username@gmail.com"
PASSWORD="yourpassword"
4. PROTO="https://"
SERVER="mail.google.com"
PATH="/gmail/feed/atom"
5.  
6. SERIALPORT = "/dev/tty.usbserial-FTDK0P3M" # Change this to your serial port!
7.  
8. # Set up serial port
9. try:
10. ser = serial.Serial(SERIALPORT, 9600)
11. except serial.SerialException:
12. sys.exit()
13.  
14. newmails = int(feedparser.parse(PROTO + USERNAME + ":" + PASSWORD + "@" + SERVER + PATH)["feed"]["fullcount"])
15.  
16. # Output data to serial port
17. if newmails > 0: ser.write('M')
18. else: ser.write('N')
19.  
20. # Close serial port
21. ser.close()

It is possible to modify servos to rotate continuously. There are several guides online about how to do this (this one, for example). Each servo is slightly different, though, and I thought it might be useful to post a guide about how to hack the servo that I happened to buy – the extremely cheap Acoms AS-16 – in case any future Googlers happen to run into the same problems.

You will need:

Acoms AS-16 servo (may work with other servos too!)
Two 2.2kΩ resistors
Small Philips screwdriver
Small flat head screwdriver
Wire clippers or sharp knife
Soldering iron
Solder
Heatshrink

Click on each picture for a larger version. To see the Flickr set containing all the photos, click here.

Step 1: Remove the four screws on the outside of the servo.

Step 2: Remove the top of the servo case to reveal the gears inside.

Step 3: Remove the top three gears. Try to keep as much of the grease on them as you can.

Step 4: Remove the two screws next to the remaining gear.

Step 5: Lift the next part of the case. The potentiometer is connected to the circuit board by three wires.

The potentiometer is held in place with a small amount of glue and two clips.

Step 6: Scrape off the glue with a screwdriver. Give it a good wiggle in the slot until all the glue is broken.

Step 7: Pull open the clips with your fingernail or a screwdriver. Press on the shaft of the potentiometer until it slides out of the servo case.

Step 8: Heat up the solder on the potentiometer tags and pull off the wires.

Step 9: Cut three pieces of heatshrink, each approx 10mm long. Slide them to the bottom of the three wires.

Step 10: Solder 2.2kΩ resistors to the white and grey wires.

Step 11: Twist the legs of the two resistors together, and solder the brown wire to them.

Step 12: Slide the heatshrink up the wires to cover the joints and heat it with the soldering iron to shrink it.

Step 13: Carefully wrap the wires up and push them into the servo case. Leave a gap next to the motor for the plastic support on the top case.

Step 14: Slide on the motor cover piece. Reattach it with the small screws.

Step 15: Find the gear which is connected to the servo’s output shaft. It looks like this:

On the back of the gear is a small plastic stop which prevents the shaft rotating all the way round. Carefully remove it, using either a sharp knife or a pair of wire cutters. If you use the latter method, it should “ping” off quite easily in one piece.

Before:

After:

Step 16: Sit this gear on the plastic axle that used to contain the potentiometer shaft. Spin it round with your fingers and make sure it can move 360 degrees freely and smoothly, with no catching. If it does catch, use a small file or knife to make sure the plastic stop is completely gone.

Step 17: Reattach the other two gears.

Step 18: Place the top of the servo case back on, and screw in the four long screws.

Finished!