From University of Washington - Ubicomp Research Page
Jump to: navigation, search


The iMote2 is an embedded platform developed by researchers at Intel Santa Clara. It consists of an Intel PXA271 XScale processor, Chipcon CC2420 802.15.4 radio, and various expansion slots. The PXA271 consists of a Processor combined with 32MB of on-board Flash storage and 32MB of SRAM.


PXA27x Developers Manual - 280000003.pdf
iMote2 Datasheet Rev 2.0 (pdf)
Intel Research Seattle PlatformX wiki
iMote2 Yahoo Group (documentation, mailing list, TinyOS focus)

Flash Filesystem

Imote2 flash filesystem.png

The 32MB of flash is currently divided as shown on the right. The system consists of three main components:


      The bootloader, called BLOB, is the first piece of software run when the iMote2 is booted. It does basic system startup and initialization of the various system components. For example, when the processor is turned on the system memory must be initialized, system clocks setup, GPIOs initialized, and the various system peripherals setup. Once the bootloader has finished initializing the system it is setup to automatically boot the Linux kernel. However, BLOB has several additional modules and plugins that allow for programming of the system via serial, Ethernet, or USB programming. Currently various parts of the programming via BLOB system are working; however, some are not. Nearly all programming is simply carried out by using JTAG flash programming.

    Linux Kernel

      The Linux kernel is stored in a special area of FLASH instead of on the flash filesystem on the iMote2. Traditionally the kernel is read from a mounted filesystem by the bootloader and then loaded; however, due to the setup of our system we instead have a dedicated section of FLASH memory where the kernel resides. Note: If your kernel is larger than the 2MB window allocated than the kernel will be corrupted by filesystem programming, or the filesystem will be corrupted.

    JFFS2 Filesystem

      The main root filesystem on the iMote2 is stored at the end of the FLASH memory range as a JFFS2 filesystem. JFFS2 is a journaling filesystem incorporating compression, wear leveling, versioning, and garbage collection. Since FLASH memories wear out after ~10,000 write operations it’s necessary to use wear leveling to avoid damaging frequently used portions of the memory. While the JFFS2 filesystem uses wear leveling it is best to not have your applications write to the / root filesystem. Instead it is preferable to use the mounted miniSD storage card as it should provide faster and less resource consuming storage.

Compiling software for the iMote2

CSE users should use the GCC compiler at: /projects/ubicomp/uwar/arm-linux/3.4.3_binutils/bin/arm-linux-gcc. Non-CSE users can download the toolchain here.

Using a GCC cross-compiler is very similar to using a native GCC. For example, the following command will build a simple "Hello, World!" application for the iMote2:

/projects/ubicomp/uwar/arm-linux/3.4.3_binutils/bin/arm-linux-gcc -O helloworld helloworld.c

Of course, for most projects you will probably want to use a makefile. Simply set the CC variable to point at the cross-compiling GCC in your makefile, your project will be built for the iMote2. Below is a simple makefile for the "Hello, World!" app:


helloworld: helloworld.o

If you're attempting to compile software that uses autoconf, you can usually configure the software using the command:

CC=/projects/ubicomp/uwar/arm-linux/3.4.3_binutils/bin/arm-linux-gcc ./configure --host arm-linux

Test Points

    Test Point Description
    TP3 V Batt On-board
    TP4 GND
    TP9 13MHz to DA9030
    TP14 PWR EN
    TP15 SYS EN

Board Images

    Top of the iMote2
    Bottom of the iMote2

Overview Images

    Top of the iMote2
    Bottom of the iMote2