Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
2012
Page 1
2012
1. BeagleBone Overview
The BeagleBone is the latest addition to the BeagleBoard.org family and like its predecessors, is designed to address the Open Source Community, early adopters, and anyone interested in a low cost ARM Cortex A8 based processor. It has been equipped with a minimum set of features to allow the user to experience the power of the processor and is not intended as a full development platform as many of the features and interfaces supplied by the processor are not accessible from the BeagleBone via onboard support of some interfaces.
Figure 1.
BeagleBone Features
Page 2
2012
Figure 2.
Page 3
2012
Figure 3.
NOTE: Design information can be found on the SD card that ships with board. We can also download the files from http://circuitco.com/support/index.php?title=BeagleBone
Page 4
2012
2. Board Setup
1) Insert the SD card into the SD card connector 2) Plug the USB cable into the BeagleBone 3) Plug the other end of the USB cable into the PC USB port. 4) The power LED D1 should be on 5) After a few seconds, USER0 and USER1 LED should start flashing 6) After 10 seconds or so, the board should show up as a mass storage device on your PC 7) Open the new drive and click on the Readme.html file. 8) The file should open in your browser. 9) Follow the instructions on the HTML page.
Page 5
2012
NOTE: If you are trying to reuse an SD card that has already been used under the above process, you will need to reformat the card to erase the second partition. Otherwise Windows will only see the FAT32 partition.
Figure 4.
Page 6
2012
NOTE: You must source the environment-setup script to run commands below correctly. This is as simple as:
$ sudo source linux-devkit/environment-setup
To know if the environment setup script has been sourced in your current shell, the shell prompt will be changed to contain the [linux-devkit]: prefix in the command prompt.
Cleaning the Sources If you did not use a separate object directory:
$ make CROSS_COMPILE=arm-arago-linux-gnueabi- ARCH=arm distclean
Page 7
2012
Where <sdk install dir> should be replaced with the directory where the SDK was installed.
It is important that when using the GCC toolchain provided with the SDK or stand alone from TI that you do NOT source the environment-setup file included with the toolchain when building the kernel. Doing so will cause the compilation of host side components within the kernel tree to fail.
The following commands are intended to be run from the root of the kernel tree unless otherwise specified. The root of the kernel tree is the top-level directory and can be identified by looking for the "MAINTAINERS" file. 3.4.2 Cleaning the Kernel Sources The command to clean the kernel is:
make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- mrproper
For user's who are building the kernel from within the AMSDK you can also use the Makefile at the root of the SDK installation at <sdk install dir>/Makefile to clean the kernel by doing:
cd <sdk install dir> make linux_clean
3.4.3 Configuring the Kernel Before compiling the Linux kernel it needs to be configured to select what components will become part of the kernel image, which components will be built as dynamic modules, and which components will be left out all together. This is done using the Linux kernel configuration system.
Using Default Configurations It is often easiest to start with a base default configuration and then customize it for you use case if needed. In the Linux kernel a command of the form:
make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- <config>
Page 8
2012
will look in the arch/arm/configs directory for the configuration file (<config> in the line above) use that file to set default configuration options. The table below shows the default configuration files for various platforms.
NOTE: The configuration file used to build the pre-built binaries found in the SDK can be found in the arch/arm/configs directory as tisdk_<device>_config and can be used in place of the config file given below to reproduce the SDK Linux kernel configuration settings. The differences between these files generally revolve around enabing/disabling additional modules for expected SDK use cases.
Device
SDK config
PSP config
For example, to build the default PSP configuration for the AM335x the command would be:
make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- am335x_evm_defconfig
To build the SDK configuration for the AM335x the command would be:
After the configuration step has run the full configuration file is saved to the root of the kernel tree as .config. Any further configuration changes are based on this file until it is cleanup up by doing a kernel clean as mentioned above.
Customizing the Configuration When you want to customize the kernel configuration the easiest way is to use the built in kernel configuration systems. Two of the most popular configuration systems are: menuconfig: an ncurses based configuration utility xconfig: a Qt based graphical configuration utility.
Page 9
2012
NOTE: On some systems in order to use xconfig you may need to install the libqt3-mt-dev package. For example on Ubuntu 10.04 this can be done using the command sudo apt-get install libqt3-mt-dev
Once the configuration window is open you can then select which kernel components should be included in the build. Exiting the configuration will save your selections to a file in the root of the kernel tree called .config.
3.4.4 Compiling the Kernel Once the kernel has been configured it must be compiled to generate the bootable kernel image as well as any dynamic kernel modules that were selected. For u-boot the kernel should be built with a u-boot header that the u-boot program can read. This is easily accomplished by using the uImage build target in the kernel. In order to build the uImage target the command is:
make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- uImage
This will result in a kernel image file being created in the arch/arm/boot/ directory called uImage. This file can be used by u-boot to boot your Sitara device.
If you selected any components of the kernel to be built as dynamic modules you must issue an additional command to compile those modules. The command is:
make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- modules
Page 10
2012
This will result in .ko (kernel object) files being placed in the kernel tree. These .ko files are the dynamic kernel modules. The next section will cover how to install these modules.
NOTE: For user's who are building the kernel from within the AMSDK you can also use the Makefile at the root of the SDK installation at <sdk install dir>/Makefile to configure the kernel with the default SDK configuration and compile the uImage and kernel modules by doing:
cd <sdk install dir> make linux
3.4.5 Installing the Kernel Once the Linux kernel and modules have been compiled they must be installed. In the case of the kernel image this can be installed by copying the uImage file to the location where it is going to be read from. For example when using TFTP boot this may be the /tftpboot directory, whereas when booting from SD card this may be the first partition of the SD card.
To install the kernel modules you use another make command similar to the others, but with an additional parameter which give the base location where the modules should be installed. This command will create a directory tree from that location like lib/modules/<kernel version> which will contain the dynamic modules corresponding to this version of the kernel. The base location should usually be the root of your target file system. The general format of the command is:
make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- INSTALL_MOD_PATH=<path to root of file system> modules_install
For example if you are installing the modules to an NFS share located at /home/user/targetNFS you would do:
make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabiINSTALL_MOD_PATH=/home/user/targetNFS modules_install
NOTE: For user's who are building the kernel from within the AMSDK you can also use the Makefile at the root of the SDK installation at <sdk install dir>/Makefile to install the kernel modules into the location pointed to by DESTDIR in your Rules.make file by doing:
cd <sdk install dir> make linux_install
Page 11