View source for ECE497 Notes on Installing Angstrom via Narcissus

[[Category:ECE497Notes |N ]]

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.

== ETC 2011 image ==

The ETC image is pretty  much the same as the FIE image, but with a couple of things cleaned up. I moved to using git for managing the exercises folder. There some gpio and pwm examples.

== FIE 2011 image ==

The FIE image is pretty  much the same as the ICASSP image, but with a couple of things cleaned up.

== 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 [http://narcissus.angstrom-distribution.org/ Narcissus]. These steps are more or less in line from those taken [http://groups.google.com/group/beagleboard/browse_thread/thread/6b57d7dc2dbce7c3 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
<pre>
tar -C ~/toolchains -xzf Angstrom-2011.MM-narcissus-beagleboard-i686-XXXX-image-sdk.tar.gz
</pre>
(again, ''MM''=month of creation)
 
This will install the toolchain to <code>~/toolchains/usr/local/angstrom/arm</code>.  This is a little long so let's move it
<pre>
mv ~/toolchains/usr/local/angstrom/arm ~/toolchains/arm-angstrom
rm -Rf ~/toolchains/usr
</pre>
So now we have the ARM compiler ready to be used.  We will use the SD card image later.

== Get ready for DSP Development ==
    
* Download the latest C6Run release package from [https://gforge.ti.com/gf/project/dspeasy/frs/ here].

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

* Download the Texas Instruments C6000 Compiler tools (version 7.2.2 or later) from [https://www-a.ti.com/downloads/sds_support/TICodegenerationTools/download.htm here].
Note that this requires you to have a login with [http://my.ti.com my.ti.com]. This is a little annoying.

*Install the DSP compiler to $(HOME)/toolchains
<pre>
$ 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 
</pre>
This takes a minute and installs silently (you are implicitly agreeing to some EULA when you do this). The DSP toolchain will be in <code>~/toolchains/TI_CGT_C6000_7.2.2</code>.

== Setup c6run ==
  
* Let's setup up c6Run so we can build DSP code.
** Edit the '''Rules.mak''' to point to the right ARM and DSP toolchains:
<pre>
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-
</pre>

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.

** Now get all dependent components to build back-end libararies. The fetching and install may take some time
<pre>
$ cd ~/C6Run_X_YY_ZZ_WW
$ make get_components
</pre>

** Edit the file '''platforms/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)
    
** Select beagleboard-xM config
<pre>
$ make beagleboard-xM_config
</pre>

** build the back-end libraries
<pre>
$ make gpp_libs dsp_libs
</pre>
      
** Source the environment for the C6Run tools
<pre>
$ source environment.sh
</pre>

** Build all the examples and test cases to make sure things work
<pre>
$ make examples tests
</pre>

If that all worked, then C6Run is ready to be used to build DSP code for use with ARM programs
  
* 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 ===

# Go to [http://narcissus.angstrom-distribution.org/ here]
# Under '''Select the machine you want to build your rootfs image for:''' select '''beagleboard'''

There are many configurations you can try.  For starts try

# Scroll to almost the bottom and select '''Platform specific packages:'''
# Again scroll to near the bottom and select '''Linuxtag 2010 beagleboard demo'''
# Click '''Build me!''' and wait
# 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.

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

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