Wednesday, October 31, 2012

BEAgal board

imp
http://www.teslabs.com/wp-content/uploads/2010/02/beagleboard.pdf

beaglebone in hand

BeagleBone Quick-Start Guide

Step-by-step quick-start

Step #1: Plug in BeagleBone via USB

Use the provided USB cable to plug BeagleBone into your computer. This will both power the board and provide a development interface. BeagleBone will boot Linux from the provided microSD card and operates as a flash drive. This provides you with a local copy of the documentation and drivers.
You'll see the PWR LED on steadily. Within 10 seconds, you should see the USR0 LED blinking in a heartbeat pattern. During accesses to the SD card, you should see the USR1 LED turning on.
Insert picture here -- ideally an animated .gif

Step #2: Install drivers

Install the drivers for your operating system.
Operating SystemUSB Drivers [FTDI] [Network]Comments
Windows (32-bit)BONE_DRV.exe
Windows (64-bit)BONE_D64.exe
Mac OS XFTDI_Ser.dmgNote: Driver installation is not required for rev A5 boards or newer. Check sticker on Ethernet port for revision.
Linuxmkudevrule.shNote: Driver installation is not required for rev A5 boards or newer. Check sticker on Ethernet port for revision.

Step #3: Eject BEAGLE_BONE

The EJECT operation tells your BeagleBone to switch from "storage mode" to "network mode", enabling you to access the networking features over your USB cable.
  • Note #1: "Safely remove hardware" is not the same as EJECT.
  • Note #2: On Windows, it may take a couple of minutes for the driver to load after EJECT.
  • Note #3: On Windows, you may be prompted to locate the 'linux.inf' file. If the driver was installed properly, you should be able to find it under c:\windows\system32\drvstore\linux_...
  • Note #4: OS X Mountain Lion no longer issues the EJECT operation upon using EJECT. You'll need to access the serial console (as described further below) and input the following commands into the console:
       systemctl stop storage-gadget-init.service
   systemctl start network-gadget-init.service

Step #4: Explore Cloud9 IDE

Cloud9 IDE can be used to develop software on your BeagleBone without the need to download any development software. Cloud9 IDE runs directly on your BeagleBone and is accessible through either Chrome or Firefox (Internet Explorer will NOT work).
As a simple exercise to become familiar with Cloud9 IDE and the Bonescript JavaScript library, creating a simple application to blink one of the 4 user programmable LEDs on the BeagleBone is a good start.
  • Step A: Close any open file tabs.


  • Step B: Click the "+" in the top-right to create a new file.




  • Step C: Cut and paste the following code into the new tab:
    require('bonescript');

setup = function () {
    pinMode(bone.USR3, OUTPUT);
}

loop = function () {
    digitalWrite(bone.USR3, HIGH);
    delay(100);
    digitalWrite(bone.USR3, LOW);
    delay(100);
}
  • Step D: Save the file by clicking the disk icon and giving the file a name with the .js extension.








  • Step E: Run the code by selecting the arrow to the right of "run" (or "debug") in the toolbar to pull down the list of files to run and select your new file.


  • Step F: Observe the BeagleBone USR3 LED blinking steadily about 5 times a second.

    Note: By default, Linux has programmed USR0 to provide a "heartbeat" pattern and USR1 to turn on during microSD card access.


  • Step G: Stop the code by clicking "stop" in the toolbar.


Additional information about the Bonescript library is available in the presentation viewed in the next step and on-line at http://github.com/jadonk/bonescript.

Step #5: Browse to your board

Using either Chrome or Firefox (Internet Explorer will NOT work), browse to the web server running on your board. It will load a presentation showing you the capabilities of the board. Use the arrow keys on your keyboard to navigate the presentation.

Program an SD card with latest or alternative software

Other currently available starting images

Step #1: Download one of the above images

The Angstrom Distribution is what ships with the boards. Some of the above starting points involve multiple steps to produce an SD card image or otherwise change some of the steps below, so be sure to read all the instructions on their pages. Chose the starting point you want, download or produce the SD card image and continue to the next step.

Step #2: Install compression utility

Download and install 7-zip.

Step #3: Decompress the image

Use 7-zip to decompress the SD card .img file

Step #4: Install SD card programming utility

Instructions for programming SD cards can be found on the Ubuntu Image Writer page. Here are the Image Writer for Windows download page.

Step #5: Connect SD card to your computer

Use the provided microSD card to SD adapter or a USB adapter to connect the SD card to your computer.

Step #6: Write the image to your SD card

Use either the Ubuntu Image Writer or instructions on its page to write the decompressed image to your SD card.

Step #7: Eject the SD card

Eject the newly programmed SD card, insert it into your (powered-down) board and apply power, either by the USB cable or 5V adapter.

Troubleshooting and reference

Top resources

Connect to your BeagleBone's serial console

Under Windows, it is recommended to follow the Adafruit tutorial.
For Mac or Linux, it is recommended simply to invoke 'screen':
screen `ls /dev/{tty.usb*B,beaglebone-serial}` 115200
Type 'CTRL-a k' to exit screen.
The username is 'root' and the password is blank, so you may simply press the ENTER key.

Powering options

To power the board with connected USB peripherals, a 2A 5V power adapter is recommended.
Note: Some software images limit the clock speed of the BeagleBone by determining if the power source is USB or the 5V adapter to avoid excess use of current.

JTAG debug

Code Composer Studio v5 (CCSv5) is available for free for BealgeBone users and is a TI-provided Eclipse-based integrated development environment that enables you to debug and develop C/C++ applications. Please visit the CCSv5 Frequently Asked Questions page.
Note: The CCS installer on Linux may fail on 64-bit operating systems if 32-bit libraries are not installed. For Ubuntu, 'sudo apt-get install ia32-libs' before running the installer.

OpenOCD is an application that provides JTAG-based debugging on all three operating systems, but currently only Linux is verified. Please visit Matt Massey's blog post describing installation in Ubuntu.

Next steps to try

Matt Richardson's getting started video

Derek Molloy's tutorial series on YouTube

Jan Axelson's BeagleBone getting started guide

Mark Yoder's ECE497 materials

Hardware

Design materials

Revisions

CircuitCo.com's BeagleBone page documents all of the known hardware issues.

A3

This is the original version of the board. Main issue was issues with the reset switch where the reset line was being pulled low which could cause random dropping of the Ethernet port. This issue has not be seen broadly.

A4

This version of the board was mainly to provide a new SD connector due to supply issues. Also added was R219 in an attempt to make the Yellow LED on the RJ45 turn on when at 100M operation. This caused the Ethernet not to work on power up but did work after a board reboot.

A5

This version of the board returns the functionality of the board to that of the Rev A3 via the removal of R219. There have been no PCB changes for this revision. It uses the same PCB revision as the A4. It also ships with an updated version of the Angstrom image providing out of the box support for the DVI-D and 7" LCD Capes.
There will be three possible versions of the Rev A5. One will be the new production version that is built from the ground up as an A5. The second version will be a reworked Revision A4 that has R219 removed at the factory and retested. The third version will be a revision A3, that just has the updated SW added. All reworked versions will have the reset switches double checked as well. All reworked boards will be retested using the full production test process.
You will be able to identify these versions via the serial number. They all will be labeled as revision A5. The two digits after the BB in the serial number, S/N: 5111BB000023, will indicate the board. A fresh revision A5, will be 00, A4 reworked will be 01, and a recertified A3 will be 02. There is no functional or operational difference between any of these boards. They are all revision A5 and will ship with the same SW.

A6

This version of the board has several updates, but none should impact execution of existing software.
  • Yellow LED to turns on during 100M operation
  • Two additional PRU signals overlaid with existing signals to the expansion header
  • Moved resistors away from the standoff
  • Removed connection to VPP pin from the layout
  • Removed R163 to avoid spurious JTAG reset issues
  • Removed incorrect and ignored configuration resistor for LAN8710

Software updates

Known issues and to-do list

  • System
    • Mount time for USB-to-Ethernet may take a couple of minutes under Windows
  • Kernel
    • Need completed CAN drivers
    • Need improved PWM support
    • Need device tree support and run-time configuration with daughterboards
    • Need improved USB and USB DMA support
    • Need improved SD performance
  • SD card image
    • Add Java
    • Need simplified IP discovery
    • Need improved GateOne performance and resolve 'redirect loop' issue
    • Need to consider ConnMan tethering for USB-based IP
    • 'top' refresh rate can sometimes be crazy fast
    • Restore automounting of hotplugged media
    • Restore Matrix and add application entries for GateOne and Cloud9 IDE
  • Documentation
    • Need daughterboard building guide
    • Add graphics and/or videos where appropriate
    • Need full description of /sys entries
    • Basic information on apps for each major interface type, ie. I2C, SPI, etc.
    • Need to highlight daughterboard ("cape") EEPROM spec
  • Cloud9 IDE and BoneScript
    • Update the git data to match the checked out repository
    • Update version of Bone101 included to one that runs
    • Inclusion of node-fibers such that delays don't hog the CPU
    • Arduino-like automatic execution of installed apps
    • Dynamic web conent example with board status and streaming data
    • Optimal utilization of the PRU and performance improvements
    • Extensive improvements to the BoneScript API
    • Need examples on programming in C and Python through the Cloud9 IDE interface
    • Include npm and several node modules

Last updated by blog.hangerhead.com on Mon Oct 15 2012 14:24:27 GMT-0500 (CDT).
################################################


Getting Started Guide for TI BeagleBoard

Contents


Introduction

This document will describe in detail the procedures for booting a Linux kernel image and mounting a root file system from an SD Card on the TI BeagleBoard.

Prerequisites

Host Requirements

To properly boot the TI BeagleBoard using software from Timesys, your host machine must meet the following requirements:
  • Modern GNU/Linux Distribution. Timesys recommends one of the following distributions:
    • Ubuntu (Most recent release or LTS)
    • Fedora (Most recent release)
  • Root or sudo permission on the Development Host.
  • A copy of the Linux Kernel ( uImage-2.6.32-ts-armv7l) and Root File System (rootfs.tar.gz) for the Target Board downloaded from Factory. These are found in the output directory of your online build, or in the directory build_armv7l-timesys-linux-<libc>/images/ on the command line.
  • An available serial port on your Development Host.
  • A SD card slot or adapter on your Development Host.

Target Requirements

To boot the TI BeagleBoard, you will need the following items:

  • TI BeagleBoard
  • BeagleBoard Serial Cable
  • SD Card
Once you have all of the necessary components, you should perform the following steps:

  1. Connect the BeagleBoard to the serial port of your workstation using the serial cable.
  2. Connect the power supply to your board.
  3. Set aside the SD card, you will need to intialize it from the Development Host before booting the board.

Preparing the Target

Configuring Serial Communication

The beagleboard uses a serial debug port to communicate with the host machine.
The commands discussed in this section are meant to be performed by a privileged user account. This requires the root login or prepending each command with sudo.

Using Minicom


  1. Start minicom on your host machine in configuration mode. As root:
    # minicom -o -s -w 
  2. A menu of configuration should appear. Use the Down-arrow key to scroll down and select the Serial port setup option, and press Enter.
  3. Verify that the listed serial port is the same one that is connected to the target board. If it is not, press A, and enter the correct device. This is /dev/ttyS0 on most Linux distributions.
  4. Set the Bps/Par/Bits option by pressing the letter E and using the next menu to set the appropriate values. You press the key that corresponds to the value 115200, then press Enter.
  5. Set Hardware flow control to No using the F key.
  6. Set Software flow control to No using the G key.
  7. Press Enter to return to the main configuration menu, and then press Esc to exit this menu.
  8. Reset the board, and wait for a moment. If you do not see output from the board, press Enter several times until you see the prompt. If you do not see any output from the board, and have verified that the serial terminal connection is setup correctly, contact your board vendor.
TIP: If you experience an error similar to Device /dev/ttyS0 is locked when starting minicom, it usually means that another process is using the serial port (which is usually another instance of minicom). You can find the process that is currently using the serial port by executing the following:

# fuser /dev/ttyS0
/dev/ttyS0:         28358 

# ps 28358
  PID TTY      STAT  TIME COMMAND
  28923 pts/0    S+    0:00 minicom 
This process can also be killed directly with fuser as root. Please use this command with caution:

# fuser -k /dev/ttyS0 

Using GNU Screen

To quickly connect to a board using Gnu Screen, execute the following:

# screen /dev/ttyS0 115200 
For more information about using screen, please consult the man page, or view the manual online athttp://www.gnu.org/software/screen/manual/screen.html

Preparing the Secure Digital Card

Most SD cards contain a Windows FAT partition by default. Unfortunately, since FAT16 does not support UNIX-style permissions or device nodes, it is not possible to use this file system as the root partition. You must use the fdisk tool to add a Linux partition, then format it using a standard Linux filesystem such as EXT2.

Creating a Linux Partition

You will use the fdisk tool to create two partitions on your SD card. Please note that all data on the card will be lost upon completion of these steps.

  1. Connect the SD card to your host system. Many modern systems have SD card slots on the case, or you can purchase a USB SD Card Reader for around $15 US.
  2. Determine the device name of the SD Card. This can be done using dmesg. In the following example, the device is/dev/sdb, which contains one partition sdb1.
    $ dmesg | tail
    [88050.184080] sd 4:0:0:0: [sdb] 1990656 512-byte hardware sectors: (1.01 GB/972 MiB)
    [88050.184821] sd 4:0:0:0: [sdb] Write Protect is off
    [88050.184824] sd 4:0:0:0: [sdb] Mode Sense: 03 00 00 00
    [88050.184827] sd 4:0:0:0: [sdb] Assuming drive cache: write through
    [88050.185575] sd 4:0:0:0: [sdb] 1990656 512-byte hardware sectors: (1.01 GB/972 MiB)
    [88050.186323] sd 4:0:0:0: [sdb] Write Protect is off
    [88050.186325] sd 4:0:0:0: [sdb] Mode Sense: 03 00 00 00
    [88050.186327] sd 4:0:0:0: [sdb] Assuming drive cache: write through
    [88050.186330]  sdb: sdb1 
  3. Unmount the partition if it was automounted by using the umount command.
    $ umount /dev/sdb1 
  4. As root, run the fdisk utility on the drive.
    $ sudo fdisk /dev/sdb 
  5. In fdisk, Delete the existing partition table and create a new one using the o command.
    Command (m for help): o
    Building a new DOS disklabel with disk identifier 0x8b025602.
    Changes will remain in memory only, until you decide to write them.
    After that, of course, the previous content won't be recoverable. 
  6. Create a new primary partition using the n command. The first partition will be a FAT partition for storing the kernel image. It need only be big enough to store the kernel image.
    Command (m for help): n
    Command action
       e   extended
       p   primary partition (1-4)
    p
    Partition number (1-4): 1
    First cylinder (1-123, default 1): 1
    Last cylinder, +cylinders or +sizeK,M,G (1-10, default 10): +10M

    Command (m for help): t
    Selected partition 1
    Hex code (type L to list codes): c 
  7. Create a second primary partiion using the n command. This partition will be a linux partition for storing the root filesystem. It will fill the rest of the SD card.
    Command (m for help): n
    Command action
       e   extended
       p   primary partition (1-4)
    p
    Partition number (1-4): 2
    First cylinder (3-123, default 3):
    Using default value 3
    Last cylinder, +cylinders or +sizeK,M,G (3-123, default 123):
    Using default value 123 
  8. Verify that the partition table is correct by using the p command. It should look similar to the following:
    Command (m for help): p                                                         
                                                                                    
    Disk /dev/mmcblk0: 1019 MB, 1019215872 bytes                                    
    255 heads, 63 sectors/track, 123 cylinders                                      
    Units = cylinders of 16065 * 512 = 8225280 bytes                                
    Disk identifier: 0xe4d1d93f                                                     
                                                                                    
        Device Boot     Start         End      Blocks   Id  System             
    /dev/sdb1               1           2       16033+   c  W95 FAT32 (LBA)
    /dev/sdb2               3         123      971932+  83  Linux 
  9. This step will destroy all data on the SD Card - Write the partition table to the card using the w command.
    Command (m for help): w
    The partition table has been altered!

    Calling ioctl() to re-read partition table.

    WARNING: If you have created or modified any DOS 6.x
    partitions, please see the fdisk manual page for additional
    information.
    Syncing disks. 

Writing the Kernel and RFS to the Card


  1. Format the first partition of the SD card with a FAT filesystem using the mkfs.vfat tool.
    $ sudo /sbin/mkfs.vfat /dev/sdb1 
  2. Format the second partition using an ext2 filesystem using the mkfs.ext2 tool.
    $ sudo /sbin/mkfs.ext2 /dev/sdb2 
  3. Mount the partitions. You can remove and reinsert the card to trigger the automount, or you can use the mountcommand to mount the partition to an arbitrary location.
    $ sudo mount /dev/sdb1 /media/vfat
    $ sudo mount /dev/sdb2 /media/rfs 
  4. Copy the kernel image from factory into the vfat partition. This file is located at build_armv7l-timesys-linux-<libc>/images/uImage-2.6.32-ts-armv7l on Desktop Factory builds.
    $ sudo cp  ~/factory/build_armv7l-timesys-linux-<libc>/images/uImage-2.6.32-ts-armv7l /media/vfat/ 
  5. As root, extract the rootfs.tar.gz archive to the ext2 partition. This archive is located at build_armv7l-timesys-linux-<libc>/images/rfs/ on Desktop Factory builds.
    $ sudo tar xzf ~/factory/build_armv7l-timesys-linux-<libc>/images/rfs/rootfs.tar.gz -C /media/rfs 
  6. Unmount both partitions before removing the card from the Development Host. Then place the card in the SD slot on the beagleboard.
    $ sudo umount /dev/sdb1
    $ sudo umount /dev/sdb2 

Preparing the Host

No additional host setup is required to boot from SD.

Booting the Board

Set Environment Variables

You must set a few environment variables in order to boot the board from the SD card. This is done with the setenv andsaveenv commands in U-Boot.
On the target, set the following environment variables:


VariableValue
bootargsconsole=ttyS2,115200 root=/dev/mmcblk0p2 rw rootwait
bootcmdmmc init\; fatload mmc 0 80300000 uImage-2.6.32-ts-armv7l\; bootm 80300000
Note: On some versions of U-Boot bootcmd must start with "mmcinit" instead of "mmc init".
Example

> setenv bootargs console=ttyS2,115200 root=/dev/mmcblk0p2 rw rootwait
> setenv bootcmd mmc init\; fatload mmc 0 80300000 uImage-2.6.32-ts-armv7l\; bootm 80300000
> saveenv 

Load The Kernel

You can use the mmc subsystem to load the kernel from the SD card.
Example

> mmcinit
> fatload mmc 0 80300000  uImage-2.6.32-ts-armv7l
reading  uImage-2.6.32-ts-armv7l

3008612 bytes read 

Boot the Kernel

The bootm command is used to boot the kernel. It loads the file that was previously loaded using the fatload command.
Example

> bootm 80300000
bootm 80300000                                          
## Booting kernel from Legacy Image at 80300000 ..
   Image Name:   Linux-2.6.32
   Image Type:   ARM Linux Kernel Image (uncompressed)
   Data Size:    3008548 Bytes =  2.9 MB
   Load Address: 80008000
   Entry Point:  80008000
   Verifying Checksum ... OK
   Loading Kernel Image ... OK 

Additional Information

Video Output

The TI BeagleBoard has multiple options for displaying video output. To configure the video output, you can pass additional bootargs to the system. These arguments use the following pattern: omapfb.mode=display:resolutionMR-bpp@refreshomapdss.def_disp=display with the following substitions.

displayOutput display to use, either tv or dvi.
resolutionResolution of display, e.g. 1024x768.
bppColor depth in bits per pixel, e.g. 16
refreshRefresh rate of the display, e.g. 60
Example

> setenv bootargs console=ttyS2,115200 root=/dev/mmcblk0p2 rw rootwait omapfb.mode=tv:1024x768MR-16@60 omapdss.def_disp=tv 

Factory Documentation



##################################################

The BeagleBoard-xM uses a Texas Instruments DaVinci Digital Media Processor, the DM3730-1000. The main processing core is an ARM Cortex-A8 processor which is based on the ARMv7 architecture.
You can read more about Beagle-xM here.

Wiring up BeagleBoard-xM

Wire the beagle-xM as shown in figure below:
Beagle-xM Wiring.png

[edit]SD Card Setup

The BeagleBoard-xM uses an SD Card to store all files. Use the steps below to setup the card. Two partitions are created. The first is used to store the boot loader, kernel and root filing system. The second partition can be used for general file storage. Note: These steps will erase everything that is already on the card.

[edit]Procedure - 1

This tutorial will show you how to set up Angstrom Embedded Linux on the BeagleBoard-xM.
I have used Ubuntu 10.4 as my development machine and BeagleBoard-xM as the target. Most of this should apply to other Linux Distributions and the original BeagleBoard. First, we need to find out where your sd-card is mounted. Plug in a sd-card into your computer wait for it to mount. Then run the following command.
 df -h
You should see something like this:
/dev/sda5              98G   56G   38G  61% / 
none                  1.5G  316K  1.5G   1% /dev 
none                  1.5G  724K  1.5G   1% /dev/shm 
none                  1.5G  336K  1.5G   1% /var/run 
none                  1.5G     0  1.5G   0% /var/lock 
none                  1.5G     0  1.5G   0% /lib/init/rw 
none                   98G   56G   38G  61% /var/lib/ureadahead/debugfs 
/dev/sdb1              15G  8.0K   15G   1% /media/FAE3-DCE5
Look for a line that starts with /dev/sdXX in it; generally it will be mounted to the /media directory (on Ubuntu anyway). Make sure the size of the sd-card is right to verify. On my system, my sd-card is /dev/sdb. [/dev/sdb1 is the first partition of the /dev/sdb drive]. You will need this device directory further in this exercise. For Angstrom to run you will need to have a sd-card with two partitions; one fat partition to hold the boot files and then a ext3 partition with the root file system on it. Thanks to Graeme Gregory there is a nice script to set up you sd-card. Execute the following commands which will make a working directory, download Graeme's script and execute it. Be sure to substitue your sd-card device directory (from above) for /dev/sdX below.
mkdir ~/angstrom-wrk
cd ~/angstrom-wrk
wget http://cgit.openembedded.org/cgit.cgi/openembedded/plain/contrib/angstrom/omap3-mkcard.sh
chmod +x omap3-mkcard.sh
sudo ./omap3-mkcard.sh /dev/sdX 
sync
If you are unable to fetch the script, you can find the same in R:\Department\08_COC\04_COC_Media_Processing\Projects\BeagleBoard-xM.
Remove the card, wait two/three seconds, plug it back in. Wait a few seconds and verify the sd-card is mounted by executing:
 df -h
You should have two new mounted partitions:
/media/boot
/media/Angstrom

[edit]Procedure - 2

Use the command below (as root) to clear a section at the start of the card, this removes the partition table. In this case, /dev/sdb refers to the SD Card.
dd if=/dev/zero of=/dev/sdb bs=1024 count=1024
Now create the first partition, this will use the FAT32 filing system. The partition will be 64M in size, which should provide plenty of room.
fdisk /dev/sdb
Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-1020, default 1):  (Press Enter)
Using default value 1
Last cylinder, +cylinders or +size{K,M,G} (1-1020, default 1020): +64M
Command (m for help): t
Hex code (type L to list codes): c
Command (m for help): a
Partition number (1-4): 1
Next, create the second partition. This will be formatted with EXT2 and fills the rest of the SD Card.
Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 2
First cylinder (18-1020, default 18):  (Press Enter)
Using default value 18
Last cylinder, +cylinders or +size{K,M,G} (18-1020, default 1020):  (Press Enter)
Command (m for help): t
Partition number (1-4): 2
Hex code (type L to list codes): 83
Check that the partitions have been created correctly, then write the changes to the disk.
Command (m for help):  p

Disk /dev/sdb: 3951 MB, 3951034368 bytes
122 heads, 62 sectors/track, 1020 cylinders
Units = cylinders of 7564 * 512 = 3872768 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x6c04288f

   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1   *           1          18       67051+   c  W95 FAT32 (LBA)
/dev/sdb2              18        1020     3789564+  83  Linux

Command (m for help): w
The next step is to create the filing systems in the partitions.
mkfs.vfat -F 32 -n "boot" /dev/sdb1
mke2fs -L "files" /dev/sdb2

mount /dev/sdb1 /media/boot
mount /dev/sdb2 /media/Angstrom

The card is now ready. You only need to do this process once for the life of the card.

[edit]Booting

[edit]Set Up Boot Partition

There are only three files that are mandatory for boot partition. The following lines will extract the files from the download build and copy those to the boot partition on the sd-card.
You can either build the Image through Narcissus or take a demo image from here R:\Department\08_COC\04_COC_Media_Processing\Projects\BeagleBoard-xM\Angstrom
# extract the files to the ./boot directory
tar --wildcards -xjvf [YOUR-DOWNLOAD-FILE].tar.bz2 ./boot/*

# copy the files to sc-card boot partition.
cp boot/MLO* /media/boot/MLO
cp boot/uImage* /media/boot/uImage
cp boot/u-boot*.bin /media/boot/u-boot.bin
cp boot/boot*.scr /media/boot/boot.scr
sync
Last thing to do is to copy the root filesystem over.
sudo tar -xvj -C /media/Angstrom -f [YOUR-DOWNLOAD-FILE].tar.bz2
sync
Note: u-boot.bin, uImage, boot.scr and MLO can be found at R:\Department\08_COC\04_COC_Media_Processing\Projects\BeagleBoard-xM\Angstrom
Now make it safe to remove your sd-card.
sync 
umount /media/boot
umount /media/Angstrom
Your done; remove the sd-card and plug it into your BeagleBoard-xM and apply power to the board.
Posted by at No comments:
Subscribe to: Posts (Atom)