Jeff and I are giving a presentation on the Formica robots on Tuesday evening for the University of Southampton IEEE Student Branch. We’ll be doing a live demonstration with robots. More information can be found on the UoS IEEE site.
If you’re at the University of Southampton, this should be a nice opportunity to see what sort of stuff you can get up to during your fourth year.
I’ve just received excellent news. Toshaan and his colleagues have built some of their own Formica robots. True to the spirit of open source projects, they tried out their own improvements to the robot drive (see the photos Toshaan has made available). It is really cool to see our designs used and developed by someone else who isn’t in the same country as us!
And if that wasn’t good enough, Toshaan and I are both going to FOSDEM at the end of the week. So we’ll be able to compare notes about our robot minions. If anyone else is headed to FOSDEM and is interested in meeting up about the Formica robots, then send me some sort of electronic communication over these here interwebs.
I’ve been working on some bits of software that’ll allow the firmware of an MSP430 to be updated via I2C. This will allow us to upgrade the firmware in all of the Student Robotics boards via the web. The firmware updates will be shipped out in the zip archives that our web-based IDE spits out when teams program their robots.
I got this mostly working in early September but I’ve only just got around to cleaning it up and making it usable. I’ve written a utility called “flashb” that, when configured correctly, just takes the name of the board to program and the two binaries necessary for the flashing. Here’s a demonstration screencast of it working:
In that video I’m loading new firmware into the JointIO board. I have an OSIF plugged into my laptop that is in turn connected to the JointIO board. I’ve reflashed this thing at least 50 times today without any failures, which bodes well for deployment.
“Why two binaries?” I hear you say. Each of these binaries only uses half of the MSP430’s flash. The two binaries contain the same code but one is linked to reside in the top half of flash and the other resides in the bottom half. Only one of these is executing at one particular time whilst the other can be overwritten with a later firmware version. I went for this approach for two reasons. Firstly, I’m new to writing bootloaders and so I decided to do something simple that could easily be slotted in with our existing code. Secondly, I had already written some of the code to do this for the Formica robots.
There’s still a lot of room for improvement, but I’ve almost achieved something that’s shippable. The code for the Formica robots was written so that they could gradually receive new firmware whilst still operating. Student Robotics doesn’t place this constraint on the bootloader. The firmware could stop operating and jump to a small bootloader, which would erase all flash except for itself. For now we’re not doing that. The time to consider that will be when we run into code size issues.
As with all of the Student Robotics code, the source for these things can be found in the Student Robotics subversion repository. The JointIO firmware can be grabbed by doing this:
svn co http://svn.srobo.org/boards/jointio/firmware/trunk/
Similarly, the flashb code can be accessed like so:
svn co http://svn.srobo.org/slug/utils/flashb/trunk/
We’ve finally got around to releasing the designs and code for the Formica robots. You can find a technical report over at Jeff’s website Warranty Void if Removed. The hardware designs are under a CC license, and we’ve GPL’ed the firmware.
I’ve made the firmware available here. To build this, you’ll need to have an install of mspgcc that’s been built (and probably patched) to compile for the MSP430F2254. If you’re using Fedora 9, then you should be able to use my mspgcc RPMs.
Compilation
Compiling it is as should be as simple as running “make”:
[rob@zarniwoop formica-fw-r468]$ make ./freq.py 500 3500 3 > freq.c cp .freq.h freq.h sed -i -e "s/_NFREQ/`echo "$(((1 << 3) + 2))"`/" freq.h sed -i -e "s/_NBITS/3/" freq.h sed -i -e "s/_MIN_PERIOD/500/" freq.h sed -i -e "s/_MAX_PERIOD/3500/" freq.h sed -i -e "s/_SYMBOLS_PER_BYTE/`./.sym_per_bit.py 3`/" freq.h curl -s http://users.ecs.soton.ac.uk/rds204/formica/rev.php > .fw_ver msp430-gcc -o main -mmcu=msp430x2254 -g -Wall -Os -mendup-at=main -DRAND_WALK_SPEED=3 -DFW_VER=`cat .fw_ver` main.c ir-rx.c freq.c net-rx.c opamp-1.c ir-tx.c ir-tx-data.c net-tx.c adc10.c random.c motor.c virus.c smbus_pec.c battery.c ir.c food.c bearing.c flash.c behav/braitenberg.c time.c behav/parking.c behav/watchdog.c -Wl,-T,lkr/msp430x2254-lower.x Firmware revision 485 msp430-gcc -o main-top -mmcu=msp430x2254 -g -Wall -Os -mendup-at=main -DRAND_WALK_SPEED=3 -DFW_VER=`cat .fw_ver` main.c ir-rx.c freq.c net-rx.c opamp-1.c ir-tx.c ir-tx-data.c net-tx.c adc10.c random.c motor.c virus.c smbus_pec.c battery.c ir.c food.c bearing.c flash.c behav/braitenberg.c time.c behav/parking.c behav/watchdog.c -Wl,-T,lkr/msp430x2254-upper.x Firmware revision 485 cp -f freq.h .freq.h.win cp -f freq.c .freq.c.win [rob@zarniwoop formica-fw-r468]$
This will generate two binaries: main and main-top. These contain the same code but they are linked into different regions of the flash. You can load either one of them into the robot’s MSP430. However, when you start working on getting them to flash each other over IR, you’ll need to make sure that you’ve got the right ones loaded.
You may notice that there’s a curl in that make output. This grabs a firmware version number from the web. Obviously you can change the URL this grabs it from, but feel free to use the one that I’ve set up in my ECS account.
p.s. I should add that none of the stuff from the Alife conference has involved the title “Formica” or our logo, which was a little dissapointing. So, let me point out that this is the same project as in all of these news stories.
Project Formica is now over. We’ve given our final demonstration to our lecturer, and we’ve said goodbye to all of our robots. I think that this has been by far the best coursework that I’ve been involved in at Southampton. It’s a shame that it wasn’t the best coursework when measured marks-wise! I strongly recommend the “biologically-inspired robotics” module to anyone doing electronic engineering at Southampton University.
In the end we built 25 robots. These robots are designed to be very cheap. If you strip away our prototyping costs, then each of them cost just over £10. If you build 1000 of them, then the components only cost around £6.50. That’s quite cheap!
We got the 25 robots constructed in a 14 hour build-fest. We are indebted to Klaus-Peter, Tom, Tobias and Justyn for their help in this experience, and hopefully we’ll express our gratitude in some way soon! In 14 hours we managed to solder over 1500 components between us.
For our demo, we got the robots doing a random walk until they found food. Food in this case is a piece of cardboard with a cuboid piece of wood stuck in the middle. They’d then push the food towards light. When they’d reached the light (which they determine through light level), they’d reverse for a bit and then go about finding some more food. Every so often, they’d go and charge themselves from the charging station. Charging is just a case of driving straight into a charging bay — with their prongs and skis making the electrical connections to the power supply. They use their IR communications to talk to other robots and ascertain how much food is left around in the arena that isn’t near the light. The liklihood of going to charge is affected by this food level.
So, all that remains now of my degree is 2 exams and a 3-minute presentation. Pretty scary!
A couple of unedited videos of the Formica robots that Jeff, Steve, Alexis, Jo and I have been working on:
More on these soon!
Some of the things that I did today:
Programmable Matter
I read a 1998 paper called “Programmable Matter Methods” — Programmable matter is a multi-dimensional grid of computing devices with local connections. The term is usually applied to grids that have a large number of nodes (like hundreds, millions or more…) and some of the “Connection Machines” are instances of it.
Image licensed under Creative Commons Attribution-Share Alike 2.5 Generic, sourced from Wikipedia.
Also read “Richard Feynman and The Connection Machine“, which is good. I particularly enjoyed the part about how Richard Feynman used differential equations with terms in that represented “the average number of 1 bits in a message address”!
Fractal Compression
“Once an image has been converted into fractal code its relationship to a specific resolution has been lost, it becomes resolution independent since the image can be recreated to fill any screen size.” – Fractal Compression, Wikipedia.
Was interested to find that Fractal compression is (or maybe was…) employed in RealVideo, and that fractal image compression failed to become widely used because wavelet approaches also popped up. FIASCO is/was an image format that, according to Linux Journal, is better than JPEG at low bitrates. FIASCO looks cool, but as far as I can tell it’s doesn’t really exist any more. There’s also a surprisingly old Wired article on it.
Whilst searching for bits of software to manage a database of papers, I came across Optar, a tool for encoding data onto paper. Maybe I’ll find some applications for this one day… perhaps the schematic of a PCB could be encoded in it and placed on the PCB surface… The authors mention something about photographing the images and then decoding them — they doesn’t say whether that’s actually possible.
Spent more hours on a tutorial on how to fix some Student Robotics hardware. Ended up editing the video using mplayer edit lists.
We’re about a month into the new semester now (argh!), and the work is piling up. However, it’s all really interesting this semester. There’s no managementy goo courses that we have to take, so it’s a semester of continuous technology and knowledge pumping. Excellent.
One really exciting course is Biologically Inspired Robotics (ELEC6087). For this we have to build robots that are in some way biologically inspired. I’m in a group with Jeff, Steve, Alexis and Jo. Our project is called “Formica”. We’re going to build a lot of really cool and small robots that will hopefully exhibit some sort of emergent behaviour from simple rules.
We built this prototype over the weekend:
The prototype is made from bits that we had lying around the place, but it’s pretty true to the design that we had in mind for the final platform. The motors are pager motors, the big chip on top is an MSP430 and there’s a Li-ion battery attached to the underside. We spent some time trying to find two pager motors that had similar characteristics, and in the end resorted to removing the motor from my mobile and the motor from my Dad’s old phone (which is the same model as mine). So if you try to phone me at the moment when my phone’s on silent, I almost certainly won’t answer. Jeff had a stroke of genius and extracted the battery from his bluetooth headset (it could be a Li-ion Polymer and not just a Li-ion, I’m not sure). The wheels are formed using a magic tool that Jeff lathed up, I’m sure he’ll blog about that soon…
The concept of having around 50 of these things driving around and interacting is pretty amazing. I can’t wait until it’s a reality!
It’s only a few months late, but we released the Student Robotics hardware at about 4 AM last Friday:
From left to right: The slug (nslu2), power board, motor controller, jointio board (analogue in, digital i/o), Servo PWM board.
Now these robots can actually get built :-)
| Older Posts >> |
Site by Rob Gilton. © 2008 - 2019