ECE497 Notes on Installing Angstrom via Narcissus

Revision as of 12:27, 21 June 2011 by Yoder (Talk | contribs) (Created page with "Category:ECE497 Here's another precompiled approach that creates a complete disk image, but gives you some control over what is in the image. The first listed creates the i...")

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Here's another precompiled approach that creates a complete disk image, but gives you some control over what is in the image. The first listed creates the image used for the ICASSP 2011 tutorial/workshop. The second one does an older image.

ICASSP 2011 image

This is the image that Daniel Allred at TI created to support c6run.

Make a beagleboard boot image and SDK image from Narcissus. These steps are more or less in line from those taken here.

  • Select beagleboard as the machine
  • Select a unique name (or use the random one provided)
  • Select advanced for options
    • Select stable 2011.03 for base of rootfs
    • Select regular base system
    • Select udev for /dev manager
    • Select sysvinit for init manager
    • Select OMAP SD image for image type
    • Software manifest is no (really it doesn't matter unless you plan to redistribute this stuff)
    • Set SDK type as Full SDK for generated filesystem and select the appropriate 32bit Intel for host (our Ubuntu install is 32-bit)
  • Select X11 for the user environment
  • For the X11 desktop environment, ok to leave it blank
  • For Additional packages:
    • Under Development packages select:
      • Perl
      • Toolchain
      • Native (on-target) SDK
      • Native (on-target) Qt Embedded SDK
      • Native (on-target) Qt X11 SDK Development
    • Under Network related packages select:
      • Dropbear SSH server
      • NTPdate
    • Under Platform specific packages:
      • Texas Instruments OMAP3x/AM3x family select:
        • Matrix GUI for QT/X11
        • PowerVR SGX demos for X11
        • PowerVR SGX gfxdriver plugin for QT/X11
        • TI texture streaming demo for X11
      • Texas Instruments OMAP3x/DaVinci/OMAPL family (using DSP) select:
        • TI DSPLINK Example Applications
        • TI Codec Engine Example Applications
        • Texas Instruments Gstreamer plugins
      • Various demonstration configs select:
        • Beagleboard validation GNOME image

Now click Build Me! This will take some time.

The result of the build will be several files. (MM=month of creation, XXXX=unique name you provided)

  • Angstrom-2011.MM-narcissus-beagleboard-i686-XXXX-image-sdk.tar.gz image with the SDK
  • XXXX-image-beagleboard.tar.gz image with the file system contents.
  • XXXX-image-beagleboard-sd-1GiB.img.gz is a 1GB SD card image.
  • XXXX-image-beagleboard-sd-4GiB.img.gz is a 4GB SD card image.

Now we need to install the SDK image

tar -C ~/toolchains -xzf Angstrom-2011.MM-narcissus-beagleboard-i686-XXXX-image-sdk.tar.gz

(again, MM=month of creation)

This will install the toolchain to ~/toolchains/usr/local/angstrom/arm. This is a little long so let's move it

mv ~/toolchains/usr/local/angstrom/arm ~/toolchains/arm-angstrom
rm -Rf ~/toolchains/usr

So now we have the ARM compiler ready to be used. We will use the SD card image later.

More Setup notes

1. Install VirtualBox
2. Install Ubuntu 10.04.2 from ISO file.
3. We assume you are on a laptop with wired Ethernet port and WiFi capability
4. Setup the Network adapters for connection to both board and the internet
    Setup proxy for getting stuff, accessing the internet, etc.

Part 2 - Get ready for DSP Development
5. Download the latest C6Run release package from

6. Unzip the C6Run package
    tar -xzf ~/Downloads/C6Run_X_YY_ZZ_WW.tar.gz
   This will create a directory C6Run_X_YY_ZZ_WW in the current directory (I just use my home directory)

7. Download the Texas Instruments C6000 Compiler tools (version 7.2.2 or later) from
   Note that this requires you to have a login with  This is a little annoying.

8. Install the DSP compiler to $(HOME)/toolchains
   mkdir -p ~/toolchains
   chmod +x ~/Downloads/ti_cgt_c6000_7.2.2_setup_linux_x86.bin
   ~/Downloads/ti_cgt_c6000_7.2.2_setup_linux_x86.bin --mode silent --installto ~/toolchains 
   This takes a minute and installs silently (you are implicitly agreeing to some EULA when you do this).
   The DSP toolchain will be in ~/toolchains/TI_CGT_C6000_7.2.2.
8. Now we need to get an ARM compiler, and we are actually going to do this as part of getting a boot image for the Beagleboard

These steps are detailed above...

9. Let's setup up C6Run so we can build DSP code.
    A. Edit the Rules.mak to point to the right ARM and DSP toolchains:
      CODEGEN_INSTALL_DIR     ?= $(HOME)/toolchains/TI_CGT_C6000_7.2.2
      ARM_TOOLCHAIN_PATH      ?= $(HOME)/toolchains/arm-angstrom
      ARM_TOOLCHAIN_PREFIX    ?= arm-angstrom-linux-gnueabi-
      It also appears that we need to make sure that the LINUXUTILS_VERSION is set to 2_25_05_11.
      Without this, any application built with C6Run won't work on the current 2011.03 build generated by Narcissus
      since the kernel module inlcuded is based on the older LinuxUtils

    B. Now get all dependent components to build back-end libararies. The fetching and install may take some time
      cd ~/C6Run_X_YY_ZZ_WW
      make get_components
    C. Edit the file plaftorms/beagleboard-xM/platform.mak and get rid of the redefines of the ARM_TOOLCHAIN_PATH and ARM_TOOLCHAIN_PREFIX (since we want
       to use the version we just set above in Rules.mak)
    D. Select beagleboard-xM config
      make beagleboard-xM_config
    E. build the back-end libraries
      make gpp_libs dsp_libs
    F. Source the environment for the C6Run tools
    G. Build all the examples and test cases to make sure things work
      make examples tests

  If that all worked, then C6Run is ready to be used to build DSP code for use with ARM programs
10. Now we can get the Beagle up and running.  We will use the XXXX-image-beagleboard-sd-4GiB.img.gz file generated by Narcissus.

Older 2010 image

  1. Go to here
  2. Under Select the machine you want to build your rootfs image for: select beagleboard

There are many configurations you can try. For starts try

  1. Scroll to almost the bottom and select Platform specific packages:
  2. Again scroll to near the bottom and select Linuxtag 2010 beagleboard demo
  3. Click Build me! and wait
  4. Once the image is created, follow the instructions to download the image. It's big so it will take a while

Once the image is build you will have two files to download. One is a disk image of the CD card and the other is the root file system.

  1. Download both of these
  2. Run host$ sudo zcat XXX | dd of=/dev/of/your/sd bs=8225280. This will partition and format the SD card and install the files needed to boot Linux. It took me about 3 minutes.
  3. run host$ sync</sync> to be sure all the files have been written.
  4. Next, uncompress the root file system image on the CD card. <code>host$ cd /media/rootfs
  5. host$ tar -xvf ~/Documents/....
  6. host$ sync

Eject the SD and plug it in your Beagle and power it up.