The SmURV Robotics Platform Jonas Schwertfeger Daniel Hartmann Mark Buller Odest Chadwicke Jenkins

Table of Contents

1. Introduction
2. Parts needed
   1. iRobot Create
   2. Mini-ITX computer
   3. Optional parts
3. Costs
4. Assembly Instructions
5. Software
   1. Operating System
   2. Robot Hardware Abstraction
   3. Sample Control Program

Introduction

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.

Parts needed

iRobot Create

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.

Mini-ITX computer

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.

A remark:
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.

Mainboard

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.

Storage

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.

Case

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.

Power Supply

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

Power Connector

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 Plate/Parts

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.

Optional parts

WiFi

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.

Camera

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.

IR emitter

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.

Costs

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:

Assembly Instructions

Software

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.

Operating System

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.

Installation

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 /media/usbdisk. In most cases the device is either /dev/sda or /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:

umount /dev/sda
dd if=/dev/zero of=/dev/sda bs=512 count=1

parted /dev/sda mklabel msdos mkpartfs primary ext2 0 1000 mkpartfs primary ext2 1000 100% set 1 boot on

mount -t ext2 /dev/sda0 /mnt/usbdisk

mkdir /tmp/smurv
tar -C /tmp/smurv -xf smurv_slax_xxx.tar.gz
cp -Rp /tmp/smurv/os/* /mnt/usbdisk

mkdir /mnt/iso
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

cp /etc/ssh /mnt/hda1/rootcopy/etc/ssh

Robot Hardware Abstraction

Sample Control Program