The SmURV Robotics Platform
The SmURV platform (Small Universal Robotics Vehicle) is a comparatively cheap and easy to assemble robotics platform for educational, research and hobby purposes. Essentially, the platform consists of an iRobot Create and a small computer mounted on top of it. Due to this very simple design, using components available at any larger electronics store, we are able to build an autonomous robot in a very short amount of time and can focus on the real interesting part: Namely, Making the robot do something exciting! In the following paragraphs we show what parts are needed to build a SmURV, how much they approximately cost and how they have to be assembled. Further, we offer one particular (out of many possible) software solutions to control a SmURV and to write software for it.
The iRobot Create is used as the basic robot unit. Since we are going to use the Create's own battery to power the Mini-ITX computer on top of it, it is a good idea to buy the Create with the Advanced Power System (APS) which provides a capacity of 3Ah.
We chose Mini-ITX computers because they are just small enough to fit on top of a Create and at the same time offer the most computational power, connectivity and extensibility currently available in that form factor.
For those familiar with the much smaller Gumstix computers: We considered the Gumstix products but as of now they lack USB host and Firewire capabilities. Apart from that, they are limited in terms of CPU and RAM. Another option is the PC/104 form factor computing platform which is smaller than the Mini-ITX as well. Even though those systems offer great connectivity and computational power, they are relatively expensive. Microsoft recently proposed a Create-based robot called Sumo Robot in the context of the sumo robot competition. They are using an ICOP eBox 2300 computer which again is smaller than the Mini-ITX standard but very limited in CPU speed (200 MHz) and thus not useful for many more advanced robot projects. A newer form factor standard called Nano-ITX seems to becoming available more and more. These computers are smaller than Mini-ITX systems and look promising for future SmURV systems.
Basically, one can choose whatever Mini-ITX mainboard best fulfills your specific project requirements. We strived for a mainboard with low power consumption and a Firewire port. The Jetway Hybrid J7F2WE1G2E is a fan-less system with a CPU 1.2 GHz and a Firewire port. Because it is a fan-less, passively cooled board, it uses less power than other systems. We equipped the Jetaway board with a 1 GB RAM module.
Even though it is possible to operate standard IDE or SATA hard disks with a Mini-ITX board, we suggest using flash memory solutions because they draw less power, do not contain any moving parts (and you do want as few moving parts as possible because you will bump into all kinds of obstacles and if you are unlucky even accidentally run down a staircase) and are lighter. Both USB memory sticks and compact flash (CF) cards are viable options. We chose 2 GB high speed CF cards which are available nowadays for a mere US$24.
The California-based company Ituner Networks Corp. manufactures a small, rugged enclosure for Mini-ITX boards which already includes a CF card slot with a CF to IDE adapter. Thus, a CF card appears to the mainboard as a standard IDE hard disk. There are two versions of this enclosure, the M200 and the M300, where the only difference between them is that the latter is a bit taller because it offers space for a PCI slot. Since we use a PCI WiFi card we chose the M300.
The iRobot Create battery has 14.4V DC but the Mini-ITX board requires the standard ATX voltage of 5/12V DC. Hence, we need to use a DC-DC converter. Ituner Networks Corp., the same company that manufactures the M300 enclosure, also manufactures a tiny DC-DC adapters called picoPSU. The picoPSU-60WI is wide input adapter that takes any voltage from 6 to 26V as input and outputs ATX voltages at up to 60 Watts. Also, the picoPSU fits perfectly into the M200/M300 enclosures and exposes a DC jack at the back of the case
As mentioned above, we are powering the computer using the Create's battery. Fortunately, iRobot gives us access to the Create's battery through the 25-pin cargo bay connector. Manufacturing your own power connector is easy and requires only minimal soldering. Further down we explain how the connector is built.
Mounting the computer on top of the Create is probably the only thing that requires some more work. In general we need a plate on which we can mount the computer case. Then, we need something that creates some space between the Create and the mounting plate; if we mount the plate directly onto the Create we cannot the reach the Create's power button anymore. We cut an aluminum plate and used hexagonal aluminum spacers with a screw on one side and a thread on the other. Another idea is to cut a plate out of wood and use threaded rods and screw nuts for the spacing.
For many applications it is interesting to have WiFi (802.11b/g) on the robot. For that purpose we can either install a USB, a PCMCIA or a PCI Wireless adapter, depending on the functionality of the chosen mainboard. Since the both the M300 case and the Jetway mainboard allow to install a PCI card we chose the PCI solution.
Just having the bump, cliff and IR sensors built into the Create is not a lot fun. Adding a camera to the robot however is! You can either go with a cheap USB Webcam or, if having uncompressed high quality images is a requirement, with a more expensive Firewire camera. We chose to use a Unibrain Fire-I camera which is available for around US$120.
The Create allows attaching an IR emitter to the 25-pin connector located in the cargo bay. However, iRobot does not sell such an emitter. Later on we show you how you can create your own emitter with a few cheap components and a soldering iron.
In the following we list the cost of each part as of May 27, 2007, including a link to an online store where the part can be ordered:
|Part||Name||Cost in US$||Available at|
|Robot||iRobot Create Premium Development Package, also includes APS, virtual walls and remote control||299.99||irobot.com|
|Mainboard||Jetway Hybrid J7F2WE1G2E||169.99||newegg.com|
|Memory||Kingston ValueRAM 1GB 240-Pin 533 DDR2 SDRAM (PC2 4200)||37.49||newegg.com|
|Storage||Transcend 2GB CF Card TS2GCF120||23.99||newegg.com|
|Power Connector||D-Sub 25 connector and hood (part #276-1547 and #276-1549), male DC jack (part #274-1573), some hookup wire (18 or 20 gauge)||7.50||radioshack.com|
|Mounting Plate/Parts||Aluminum sheet (e.g. #8973K89), pack of screws and nuts (#90279A148 and #90480A007), 4 hex spacers (#93620A446)||27.00||mcmaster.com|
|Base system total:||680.86|
|WiFi Adapter||GIGABYTE GN-WP01GS IEEE 802.11b/g PCI Wireless Adapter||19.99||newegg.com|
|IR Emitter||LED and holder (#276-143 and #276-080), some hookup wire||3.70||radioshack.com|
|Complete system total:||813.55|
In order to control the Create we need to install an operating system on the Mini-ITX system and write software that talks to the Create through either the Create's Mini-DIN or D-SUB 25 connector. iRobot released the Open Interface Specification (OIS) for the Create, a document that explains the wiring of the D-SUB 25/Mini-DIN connectors and specifies what commands can be sent to the Create over an ordinary serial port. Because the communication takes place through a serial port on the Mini-ITX side, we can write software in any programming language and for any operating system we desire, as long as it supports accessing a serial port. However, we suggest you do not reinvent the wheel and write your own implementation of the Create's OIS since there already exist libraries for this robot. Besides that, if you are using a library that abstracts robot hardware in general, then you are able to write robotics code which does not only run on the Create but on any robot that is supported by that library.
For both major operating systems Linux and Windows there exist libraries or programming frameworks to control robots. We do not have any experience with Windows-based systems because the use of Windows would add additional licensing costs and make the SmURV platform more expensive. Further, currently it seems the robotics community is more active on Linux-based than on Windows platforms; however, this might change in the future, depending on Microsoft's success with its Robotics Studio. There is an important, third reason why we chose Linux over Windows: We are going to install the operating system on flash memory and run it from there. This fact is important because the lifespan of flash memory is limited by the number of write cycles. In other words, this kind of memory has a physical limitation of how often data can be written into it. Since operating systems use hard disks heavily as temporary data storage (for memory swapping, logging and caching) we have to apply some trickery to prevent the operating system from doing this with the flash memory. Fortunately, there already exists a solution to this problem in the Linux world: So-called Linux Live CDs are stripped-down Linux installations burnt onto bootable CDs which computers can then use to boot a Linux operating system directly from CD. During the boot process these CDs create a virtual file system in RAM. From the operating system's point of view there exists a physical disk with a file system that it can use for temporary storage, in reality however no data is ever physically written onto a disk, all read and write operations are carried out in RAM. Instead of burning a live Linux onto a CD we simply copy it onto the flash disk. To the best of our knowledge, this behavior can currently not be accomplished with Windows.
We chose SLAX as the base Linux live distribution because of its modular and slim architecture. Of course any other live distribution would work as well; refer to Wikipedia for a list of other distributions.
There are two ways to get and install SLAX. One is to download and install
the official distribution from the slax website and the second is to download a pre-configured, but
not most up-to-date package from this website (this package
is based on SLAX Frodo Edition 5.1.8). It is a good idea to familiarize with the way SLAX works; a good
starting point for this is the official documentation.
In order to write to the CF card we connect a CF card reader (such as the SUPER TALENT EXT-AI1-C for roughly
$7) to a computer with Linux installed on it. Once the reader is connected and the CF card is inserted into it,
most Linux will automatically mount the new disk to some subdirectory of
/media/. To determine the
CF card's actual device name we execute
mount in a console and search the output for a line similar to
/dev/sda1 /media/usbdisk. This line indicates that the card's
device name is
/dev/sda and that the first parition on the card is mounted to
In most cases the device is either
/dev/sdb. Now, we want to make sure there
is no bootloader installed on the flash disk and we do this by first unmounting the card and then erasing the first 512 bytes on it
using the following commands:
dd if=/dev/zero of=/dev/sda bs=512 count=1
sdashould be replaced with your specific device name. The second step is to partition the disk as desired. We chose to create two partitions, one containing the actual Linux distribution and one containing user data. We use
partedfor partitioning, but any other tool with the same capabilities should be fine. The command
parted /dev/sda mklabel msdos mkpartfs primary ext2 0 1000 mkpartfs primary ext2 1000 100% set 1 boot oncreates two partitions with an ext2 file system. The first partition starts at the beginning of the disk and ends at 1000 megabytes, the second partition starts at 1000 megabytes and ends at the end of the disk. Further, we need to make the first partition bootable which is achieved in the above command through
set 1 boot on. Now we mount the the first parition on the CF card to the directory
mount -t ext2 /dev/sda0 /mnt/usbdiskIf
/mnt/usbdiskdoes not exist it can be created using
mkdir -p /mnt/usbdisk. At this point we copy the Linux distribution into
/mnt/usbdisk. In case you downloaded the pre-configued SLAX package from this site proceed as follows:
tar -C /tmp/smurv -xf smurv_slax_xxx.tar.gz
cp -Rp /tmp/smurv/os/* /mnt/usbdisk
mount -o loop slax-xxx.iso /mnt/iso
cp -Rp /mnt/iso/* /mnt/usbdisk
cat /mnt/smurv/mbr.bin > /dev/sda
/mnt/smurv/extlinux -i /mnt/usbdisk/boot
/mnt/usbdisk/modules/. The wireless settings for the pre-configured package are located in
/mnt/usbdisk/rootcopy/etc/Wireless/RT61STA/rt61sta.datand the IP address configuration can be found in
/mnt/usbdisk/rootcopy/etc/rc.d/rc.wlanfor WiFi and in
/mnt/usbdisk/rootcopy/etc/rc.d/rc.ethernetfor Ethernet respectively. The hostname can be changed
/mnt/usbdisk/rootcopy/etc/hostname. Once we are done with configuring the system we can unmount the CF card (
umount /mnt/usbdisk), remove it from the card reader and stick it into the SmURV's CF slot. After connecting a power, a monitor and a keyboard cable to the Mini-ITX we can start up our system. After the system is up an running we can either control it using the attached keyboard or by connecting to it using SSH. The only installed user is
rootand the SLAX default password is
toor. Either way you connect there is one important step left: Whenever the SSH daemon is started on the SmURV it checks whether there exist private keys in
/etc/ssh. If none exist it generates randome ones and stores them in that directory. These keys should not change after every restart since in that case there is no way an SSH client can actually determine it is connecting to the same machine it always connected. Therefore we need to manually copy the keys onto the CF card:
cp /etc/ssh /mnt/hda1/rootcopy/etc/ssh