(http://cultofubuntu.

com)

Hawkboard Review
Submitted by Abhijit Paul Chou... on Sat, 2010-07-17 04:00

Ads by Google Ubuntu Linux Linux OS U Boot JBA Headers Linux Kernel

Like 388 The Hawkboard is an open community board for ARM development. The OMAP-L138 processor provides support for
various interfaces—and it sells at an affordable price.

I found that reviewing a board is not as easy as reviewing a smartphone or a netbook. Reviewing those does not take too much time, since
all you need to do is use the device and document your experiences. In the case of the Hawkboard, things are quite different—a lot more
complicated, in fact.

All you have is a board with open source software embedded, a boot loader, various libraries, and the Linux kernel. No outercase, great
looks, or fancy buttons. I began by reading the specs to learn more about the board, and then proceeded to connect it to my laptop and
power it on to check out its behaviour. Turns out that the Hawkboard has quite a bit to offer, and you can do a lot with it.

Figure: Hawkboard
The device
The Hawkboard is an open community board mainly for developers. Almost square in shape, its dimensions are around 9 x 10 cm. It's
based on a Texas Instruments OMAP-L138 Low-Power Applications Processor with an integrated 300 MHz ARM926EJ-S RISC MPU,
and a floating-point C674xVLIW DSP. This gives developers a good platform for digital media and storage applications. Moreover, having
a floating-point DSP around will enable developers to write various DSP algorithms and also port algorithms running on ARM and x86.
Further, the board requires only a 5-volt power supply, and does not need cooling devices like a heat sink or fan—an ideal ‘green’
computing device.

The OMAP L138 processor can support the following interfaces—the RS232 serial port, Ethernet, USB, SATA, VGA, audio in/out and
composite in (RCA jack). The USB ports available on the board are USB 1.1 and a USB 2.0 (OTG). Since the board runs at 5 volts, it can
be powered using the USB OTG. The board's Ethernet port supports both 10base-T and 100base-TX in either half- or fullduplex mode.

The board has a Texas Instruments TLV320AIC3106 stereo codec (just behind the audio in/out port) for input and output audio
analogue/digital conversion. The composite Video In interface is incorporated by a TVP5147M1 high-quality video decoder, which is used
to convert baseband analogue video formats (NTSC, PAL and SECAM composite are supported) into digital component video. Further,
the board contains a THS8135 DAC, which is an interface between the VGA interface and the Hawkboard.

The Hawkboard also comes with a JTAG interface, making it possible for the developer to debug the application being developed on the
board. The JTAG interface provided in the board is a 2x7 double-row male header. On the other side of the board is an SD/MMC
connector, which can be used to read SD and MMC cards. The board also contains a total of six LEDs, of which four are for status
indications, and the other two are for general usage. LED1 is placed near the RESET button, LED 2 besides the power; LED3 and LED 4
are for UART2 transmission and reception, respectively. The board also has a ‘boot mode selection switch’, which can be used for multiple
boot options (though currently the Hawkboard only supports two boot method selections). The Hawkboard also contains 128 MB DDR2
RAM (memory addresses 0xC0000000 - 0xC7F00000) and 128 MB NAND flash (0x00000000 - 0x07F00000).

Basic requirements

Before testing the board, here's what I found I needed:

5V DC adaptor (comes with the board)

Serial Null Modem cable (comes with the board)
Serial Adapter, to convert serial null modem to USB
GTKTerm—terminal emulator to communicate with the serial port Monitor

Getting started

I used Ubuntu 9.10 on my host machine, and neither GTKTerm nor Minicom terminal emulators were installed by default. Install it by
issuing the following command:

apt-get install gtkterm

Next, making sure that the powered-off Hawkboard was connected to the laptop/PC via the serial cable, I configured GTKTerm as follows:
under Configuration I chose the port as /dev/ttyUSB0 and speed as 115200. (If you have a serial port on your computer and don't use the
USB/serial converter, the device node may differ.) I left the other settings unchanged, and powered on the Hawkboard. GTKTerm shows
bootloader messages (see Figure 1). The U-Boot boot loader does a countdown, during which you can hit any key to stop the auto-boot. If
allowed to auto-boot, you wind up with a [@Hawkboard /] prompt in GTKTerm.
Figure 1: U-Boot messages in GTKTerm

If you interrupt auto-boot, then you see a hawkboard.org> prompt where you can type help to get a list of available commands, including
those to boot the Hawkboard from a TFTP server or via USB. Figure 2 shows the manual boot option. I went on to do an auto-boot so I
could test some of the interfaces.

Figure 2: Hawkboard boot options

Testing the interfaces

I began with the USB port. I connected a USB 2.0 pen-drive to a USB port (Figure 3 shows the messages in GTKTerm). Judging by the
messages, the USB port is v1.1. Well, that's not an issue, since we're just testing the port. I mounted the drive with mount /dev/sda
/media/usb and could list the files on the drive—so the USB port works fine. Satisfied, I unmounted the drive with umount /dev/sda. Next, I
tried the SD/MMC slot with a microSD card from my mobile phone (inserted in an adapter). Yes, on inserting the card in the MMC slot,
GTKTerm showed that it was recognised:

mmc0: new high speed mmc card at address 0001

mmcblk0: mmc0:0001 000000 980 MiB
mmcblk0: p1
Figure 3: Kernel messages on inserting USB pen drive

I mounted the single mmcblk0p1 partition on the MMC card with mount /dev/mmcblk0p1 /media/sdcard and found that the contents of the
card could be read. Moving to the audio in/out port, I tried playing a few songs on the Hawkboard. The available codecs support only a few
formats—voc, wav, raw and au, but you can install your favourite codecs. I used the aplay command to play a WAV file on my SD card:

aplay -c 2 -t wav -r 44100 -f filename.wav

(‘c’ is the number of channels—mono or stereo; ‘t’ is the type of file and ‘r’ stands for the rate in hertz.) I plugged in an Ethernet cable to the
Ethernet port and manually set the IP address of the board to 10.0.0.100 using the command ifconfig eth0 10.0.0.100 netmask
255.255.255.0 broadcast 10.0.0.101 up. From a terminal window on my laptop, I successfully pinged the Hawkboard. Well, I had now
checked the main interfaces, and they worked fine. My next mission was to boot my own kernel image on the Hawkboard. That involved
compiling the new kernel image, setting up a TFTP server on my laptop, and downloading the image to the Hawkboard using U-Boot's
TFTP client.

Compiling the kernel

The website http://code.google.com/p/hawkboard/downloads/list (http://code.google.com/p/hawkboard/downloads/list) contains some pre-compiled

kernel images—or you can compile your own kernel image, which I chose to do. The pre-requisites for compilation are:

ARM Cross Compiler for Linux/U-boot—lets you compile source code on your x86 PC, for the ARM architecture.
Kernel Source

Download the ARM Cross-Compiler mentioned at http://elinux.org/Hawkboard (http://elinux.org/Hawkboard) and extract the archive, creating
the arm-2009q3 folder. Download the kernel source from the link on the same page, and extract that to a separate folder. Before you can
start the compile, you need to add the path of the extracted cross-compiler's binaries folder to your PATH environment variable. In your
GNOME-terminal (or other favourite terminal), run the following:

export PATH="${PATH}:/home/abhijit/Desktop/arm-2009q3/bin"

Note: /home/abhijit/Desktop/arm-2009q3 is where the compiler was extracted on my system; adjust the path accordingly, for your system.
Next, change the working directory to the directory containing the kernel source (most likely called linux-omapl1). Then issue the following
commands to compile the kernel:

$ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- distclean

$ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- omapl138_hawkboard_defconfig
$ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- uImage

Figure 4: Kernel cross-compilation successful

When the compilation is complete, the generated kernel image is at arch/arm/boot/uImage (see Figure 4). Next, we need to transfer the
image onto the board using TFTP. Setting up the TFTP server With Ubuntu, to install the TFTP server, I just need to run sudo apt-get
install atftpd. Once done, we need to modify the configuration a bit to get atftpd to run as a service directly, not through inetd. Edit the
/etc/default/atftpd file using the following command and change the line

USE_INETD=true to USE_INETD=false.

Next, create the directory for files that TFTP will serve, and (re)start the service:
sudo mkdir /tftpboot
sudo chmod -R 777 /tftpboot
sudo chown -R nobody /tftpboot
sudo /etc/init.d/atftpd restart

Copy the compiled kernel image (uImage) into the /tftpboot folder.

The kernel requires a root filesystem to provide a working GNU/Linux system. While the root filesystem could be on a hard drive, a USB
drive or in flash memory, we will use a RAMdisk. Download the root filesystem RAMdisk image, ramdisk_v1.gz, from
http://code.google.com/p/hawkboard/ (http://code.google.com/p/hawkboard/) and copy this file into the TFTP server directory (/tftpboot) as well.

Transferring the new images to the Hawkboard

To transfer the files, the Hawkboard has to be at the UBoot prompt (the auto-boot needs to be interrupted). At the prompt, set the TFTP
server IP address and the Hawkboard's IP address. In my case, the TFTP server (my laptop) was 10.0.0.7, and I set the Hawkboard as
10.0.0.100:

$setenv serverip <PC/laptop IP address>

$setenv ipaddr <Hawkboard IP address>

To transfer the two images to the Hawkboard (see Figure 5), use the following code:

$tftp c0700000 uImage

$tftp c1180000 ramdisk_v1.gz
Figure 5: TFTP transfer of kernel and RAMdisk images

Finally, boot the downloaded kernel image (Figure 6 shows it booting):

$bootm c0700000

Fig 6: New kernel image booting on the Hawkboard

Projects on Hawkboard

Since the board was made public just a few months back, there are no full-fledged applications available yet. There are a lot of early
adopters trying to use the Hawkboard for various purposes. There are projects where Android has been ported to the Hawkboard, Linux
device driver support is being added for the Hawkboard, and many others. There are many projects that will try, in particular, to utilise the
DSP capabilities of the board. More information about these and other projects can be found at http://elinux.org/Hawkboard/earlyadopter
(http://elinux.org/Hawkboard/earlyadopter)

There are various ARM boards available in the market, but this one is unique. The most noticeable difference is the cost—the Hawkboard
at Rs 5000 to Rs 6000 is quite cheap. Moreover, when compared with other boards, this one offers faster CPU and RAM. Compared with
the Beagleboard, of course, this one has lower specs, but then the Beagleboard is almost double the price.

Resources and useful links

http://www.hawkboard.org/ (http://www.hawkboard.org/)
http://elinux.org/Hawkboard (http://elinux.org/Hawkboard)
http://code.google.com/p/hawkboard/ (http://code.google.com/p/hawkboard/)
http://groups.google.com/group/hawkboard?pli=1 (http://groups.google.com/group/hawkboard?pli=1)
http://www.angstrom-distribution.org/narcissus/ (http://www.angstrom-distribution.org/narcissus/)
http://focus.ti.com/docs/prod/folders/print/omap-l138.html (http://focus.ti.com/docs/prod/folders/print/omap-l138.html)
http://elinux.org/Hawkboard/earlyadopter (http://elinux.org/Hawkboard/earlyadopter)
Dell.com/Laptops/Inspiron Ads by Google

Ads by Google Debian Linux Linux Boot Blog Headers Embedded ArmWmware Linux