Atmel AVR32 Dev Kit

Atmel's AVR line now spans the 8-bit to 32-bit continuum with the addition of the AVR32 (A New Player In The 32-Bit Procesor Field, ED Online ID 11939). There is no lack of 32-bit microcontrollers and Atmel already has ARM7 and ARM9 processors but the AVR32 is designed to handle multimedia applications more efficiently. It incorporates advanced features such as DSP and SIMD (single instruction multiple data) instructions, Java bytecode support and uses a compact instruction set that uses 16- or 32-bit instructions without switching modes. Most instructions fall into the former category thereby reducing code size and effectively increasing the cache performance since more instructions can fit into the cache. This is one reason the ARM Thumb and Thumb2 instruction sets are so popular but the AVR32 does not have the mode switch overhead when 32-bit instructions are required.

AVR32 Architecture
The AVR32 has a seven stage pipeline (Fig. 1). A short pipeline reduces overhead due to stalls and allows more aggressive run time code analysis because timing constraints are not as critical as with some other system architectures. The short pipeline allows dynamic branch prediction to essentially implement a zero cycle loop instructions to attain DSP performance.

The AVR32 has 16-register register file with minimal number of mirrored registers for hardware context switching. It has a flexible interrupt structure and it has instructions for moving and saving blocks of registers. The AVR32 is a big endian architecture but it implements a host of pack and extract operations with a 32-bit barrel shifter that make little endian support easy. The processor can also manipulate 64-bit values. The chip has DSP and SIMD support. SIMD support addresses common multimedia algorithms such as MPEG-4 motion compensation.

The chip has 16Kbyte data and code caches. It has a paged and segmented memory management unit (MMU) so Linux and Windows CE and other high end embedded operating systems can target the AVR32.

The AVR32 has a pair of 10/100 Ethernet interfaces, an image sensor interface suitable for camera support, and LCD controller interface, USB 2.0 HS port, four serial ports, two SPI ports, three synchronous serial controllers, an I²C interface, and a PS/2 port. There is 32Kbytes of RAM on-chip and an SDRAM (up to 64Mbytes), SRAM and NAND flash controller for off-chip memory. There is a separate multimedia card interface. The chip has a 4-channel PWM and counter timer support as well as an AC97 audio subsystem and a pair of DAC outputs.

Getting Started With The STK1000
Developers jumping on the AVR32 bandwagon have a solid development platform, the STK1000. I have been able to take a look at the development kit and it is definitely a polished package that can get you up and running with or without a JTAG emulator.

The kit consists of two boards (Fig. 2). The carrier board has the connectors, interface chips, IrDA interface, a PCI expansion socket and a 320 by 240 color TFT LCD display. There are plenty of buttons, LEDs and headers but not patch area. Still, most multimedia applications will likely need only those features already on the board such as a range of USB connectors including OTG (On-the-Go) support. The processor board has the JTAG connector and trace connector along with a handful of configuration jumpers.

The board has 8Mbytes of flash and 8Mbytes of SDRAM. The latter tends to be the only limitation as there are Compact Flash and SDI/MMC card sockets. The latter is used with the default Linux installation.

AVR32 Development Tools
Atmel includes a copy of IAR's EWAVR32 KickStart development kit including its IAR Workbench. I especially like this toolset when doing non-Linux work. It can handle a range of JTAG controllers although none are included with the kit. It can also work with the U-Boot bootloader so you don't need the JTAG controller to take this approach either.

The other piece to the software package is the open source tools found on the BSP CDw. This includes the gcc C/C++ compiler tool chain and a Linux 2.6 kernel with BusyBox support. All source code for the OS is included along with binaries for the toolchain.

Getting started is relatively easy. The kit comes with a 128Mbyte SD card that is almost empty. It contains a compact copy of Linux and the on-board flash memory has the U-Boot bootloader. By default, Linux powers up, displays the logo on the LCD and presents a command line interface on the serial port. An Ethernet channel is enabled and I was able to do basic things like ping my server to make sure the network was operational.

Creating application was now a relatively easy task. Running applications over the network is a trivial exercise as using the debugger remotely. Of course, this works only for applications that run on top of Linux. The only qualm is a special program is needed to load the SD card from Windows. It is easy to use and I even include it in my makefile so it is not really too much hassle.

The only major item I could not test was the Java support. That requires a JVM that handles functions not supported in hardware and other tools not included with the kit.

Documentation is good and there are plenty of application notes that cover the various interfaces. Obviously source code for the protocol stacks are part of the Linux package.

The two things I didn't get to check out were the camera and PCI support. The latter looks relatively easy because of the socket although the drivers for any attached hardware is problematic. The camera interfacing may be a little more difficult since wiring up the camera does not appear to be as easy as plugging in a module as with some packages like National Instrument's Blackfin multimedia kit I recently reviewed. Still, it is possible and cameras are not used in most applications.

Overall, the STK1000 is a nice package that can get you up and running with Linux in less than an hour and only a little longer for standalone development. Developers needing closer debugging support will need to purchase a JTAG emulator separately.