Difference between revisions of "ECE497 Notes on Installing Angstrom via Narcissus"

From eLinux.org
Jump to: navigation, search
m (Update link to Narcissus.)
m (Added Notes tag)
(One intermediate revision by the same user not shown)
Line 1: Line 1:
[[Category:ECE497]]
+
[[Category:ECE497 |Notes]]
  
 
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.
 
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 ==
 
== FIE 2011 image ==

Revision as of 14:26, 18 July 2012


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 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.

Get ready for DSP Development

  • Download the latest C6Run release package from here.
  • 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).

  • Download the Texas Instruments C6000 Compiler tools (version 7.2.2 or later) from here.

Note that this requires you to have a login with my.ti.com. This is a little annoying.

  • 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.

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:
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.

    • 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
    • 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
$ make beagleboard-xM_config
    • build the back-end libraries
$ make gpp_libs dsp_libs
    • Source the environment for the C6Run tools
$ source environment.sh
    • 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

  • 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.