TI-Android-GingerBread-2.3.4-DevKit-2.1 DeveloperGuide

From Texas Instruments Embedded Processors Wiki

Jump to: navigation, search
Translate this page to   

TIBanner.png

Contents

TI Android GingerBread 2.3.4 DevKit 2.1 Developer Guide

The objective of this document is to guide Android developers to get access to Android sources for TI devices, setting up host environment for compilation and enabling debug environment to ease the app development, debugging and deployment.

Host (PC) setup requirements

The host development environment for Android is based on ubuntu, please install ubuntu version 10.04 or later http://www.ubuntu.com/desktop/get-ubuntu/download. The host installation would need few more Android specific dependencies, these can be installed dynamically over network using below commands.

For Ubuntu on 32-bit machines 

  $ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"
  $ sudo add-apt-repository "deb-src http://archive.canonical.com/ubuntu lucid partner"
  $ sudo apt-get update
  $ sudo apt-get install git-core gnupg sun-java6-jdk flex bison gperf libsdl-dev libesd0-dev libwxgtk2.6-dev build-essential zip curl libncurses5-dev zlib1g-dev minicom tftpd uboot-mkimage expect
  $ sudo update-java-alternatives -s java-6-sun

NOTE:

  1. Android Gingerbread (2.3.4) needs Java 6 on ubuntu, whereas the previous version FroYo (2.2) was using Java 5.
  2. Please refer to the AOSP for latest information http://source.android.com/source/initializing.html

Source locations

TI provides Android sources for all the supported devices in multiple locations, developers can download the sources from the gitorious.org/rowboat repository or use the pre-packaged repo in the DevKit.

Using gitorious.org/rowboat

A tool called 'Repo' helps to fetch the android sources from gitorious.org/rowboat. Repo is a tool that makes it easier to work with Git in the context of Android.
For more information about Repo, see the link http://source.android.com/source/version-control.html.
To install, initialize, and configure Repo, follow these steps:
Make sure you have a bin/ directory in your home directory, and that it is included in your path: 

  $ mkdir ~/bin
  $ PATH=~/bin:$PATH

Download the Repo script and ensure it is executable: 

  $ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/rep
  $ chmod a+x ~/bin/repo

The following commands help developers to clone sources from Gitorious.org/rowboat repository 

  $ mkdir rowboat-android
  $ cd rowboat-android
  $ repo init -u git://gitorious.org/rowboat/manifest.git -m TI-Android-GingerBread-2.3.4-DevKit-2.1.xml
  $ repo sync

Using pre-packaged repo

The above method is ideal but is time consuming, so developers can use the pre-packaged Android sources in DevKit package.

NOTE: Once the sources are generated developers can do a “repo sync” to pull latest updates (if any) from gitorious.org/rowboat 

  $ mkdir rowboat-android
  $ cd rowboat-android
  $ Download the pre-packaged repo from http://software-dl.ti.com/dsps/dsps_public_sw/sdo_tii/TI_Android_DevKit/TI_Android_GingerBread_2_3_4_DevKit_2_1/index_FDS.html
  $ tar -xvzf 	TI_Android_GingerBread_2_3_4Sources.tar.gz
  $ cd 	TI_Android_GingerBread_2_3_4Sources
  $ ./.repo/repo/repo sync --local-only

This will generate the sources for

Tool chain setup

Setup the tool-chain path to point to arm-eabi- tools in prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin 

  $ export PATH=<PATH_TO_ROWBOAT>/rowboat-android/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin:$PATH

Compilation procedure

To build x-loader 

  $ cd x-loader

Execute the following commands 

$ make CROSS_COMPILE=arm-eabi- distclean
$ make CROSS_COMPILE=arm-eabi- <config>
$ make CROSS_COMPILE=arm-eabi-

This command will build the x-loader Image "x-load.bin"

To create the MLO file used for booting from a MMC/SD card, sign the x-loader image using the signGP tool found in the Tools/signGP directory of the Devkit.\ 

  Note: you will need to copy the signGP tool from the Tools/signGP directory to the directory that contains the x-load.bin file

  $ ./signGP ./x-load.bin

The signGP tool will create a .ift file, rename the x-load.bin.ift to MLO 

  $ mv x-load.bin.ift MLO

To build boot loader (u-boot) 

  $ cd u-boot

  $ make CROSS_COMPILE=arm-eabi- distclean
  $ make ARCH=arm CROSS_COMPILE=arm-eabi- <config>
  $ make ARCH=arm CROSS_COMPILE=arm-eabi-

This command will generate the u-boot Image "u-boot.bin"

NOTE: Copy the "mkimage" from "tools" folder to /usr/bin folder on your host machine, this is needed for kernel uImage generation

To build Linux kernel 

  $ cd kernel

  $ make ARCH=arm CROSS_COMPILE=arm-eabi- distclean
  $ make ARCH=arm CROSS_COMPILE=arm-eabi- <config>
  $ make ARCH=arm CROSS_COMPILE=arm-eabi- uImage

This will generate uImage (kernel image) in kernel/arch/arm/boot folder

To build Android filesystem

Filesystem with SGX

To Build the root file system for AM37x (or Beagle XM, AM35x EVM, AM37x REV G EVM) 

  $ cd <PATH_TO_ANDROID_SOURCES> (i.e. ~/rowboat-android or ~/rowboat-android/TI_Android_GingerBread_2_3_4Sources)
  $ make TARGET_PRODUCT= <product name> OMAPES=<ES version> -j<N> 

  NOTE: product name can be beagleboard (For Beagleboard Rev Cx and Beagleboard XM A/B/C)or omap3evm (For AM37x or OMAP35x)or am3517evm(For AM35X)

  OMAPES variable controls the ES version of the device
  For AM35x                = 3.x
  For AM37x                = 5.x
  For OMAP35x              = 3.x
  For Beagleboard Rev Cx   = 3.x
  For Beagleboard XM A/B/C = 5.x

  <N> should be twice the number of processors on your host machine. For example, a dual core machine would use -j4

The above command will build Android FS, kernel, SGX drivers and WLAN drivers (In case of AM37x). After successfull build, the kernel image can be found at kernel/arch/arm/uImage. Android rootfs components (root and system folders) will be located in out/target/ptoduct/omap3evm. SGX drivers and libraries are installed in Android rootfs components. WLAN drivers and firmware are installed in system component of the Android rootfs(For AM37x only).

Filesystem without SGX

To build the root file system for AM37x (or Beagle XM, AM35x EVM, AM37x REV G EVM) without SGX accelerated graphics support 

  $ make TARGET_PRODUCT= <product name> droid -j<N> 

  NOTE: product name can be beagleboard (For Beagleboard Rev Cx and Beagleboard XM A/B/C)or omap3evm (For AM37x)or am3517evm(For AM35X)

  <N> should be twice the number of processors on your host machine. For example, a dual core machine would use -j4

  NOTE: If filesystem is already built with SGX, then the projects need to be cleaned using the following command:
       $ make TARGET_PRODUCT= <product name> clean

Create root filesystem tarball

Prepare the root filesystem as follows: 

  $ cd out/target/product/omap3evm
  $ mkdir android_rootfs
  $ cp -r root/* android_rootfs
  $ cp -r system android_rootfs
  $ sudo ../../../../build/tools/mktarball.sh ../../../host/linux-x86/bin/fs_get_stats android_rootfs . rootfs rootfs.tar.bz2

The rootfs.tar.bz2 is the android filesystem, it can be put on a SD/MMC Card or used our NFS.

RowboPERF Integration 

   #> git clone -b rowboat-gingerbread git://gitorious.org/rowboat/rowboperf.git
   #> cd rowboperf

NOTE: Clone rowboperf sources outside the rowboat-android tree.

Adobe Flash 10 Integration

The Android version of Flash10 that runs on GingerBread is now available for customer download (by registration) at, http://focus.ti.com/docs/toolsw/folders/print/adobeflash-a8.html

The below steps give the procedure to download the Adobe Flash 10 library for Android GingerBread and installing the same in File system. 

  $ ./TI Flash10.3 Android Webkit Plugin-0.80-Linux-x86-Install.bin

Will result in following instruction, press "Y" 

  This will install Flash10.1 Android Webkit Plugin on your computer.  Continue? [n/Y] Y
  Select the source install location
  Where do you want to install Flash10.1 Android Webkit Plugin? 
  [/home/user/flash10_androidplugin] /home/user/flash10_androidplugin

  Installing Flash10.1 Android Webkit Plugin...
  Installing Program
  Files...                                                                                                                                
  Installation complete.
  After Installation the following directory structure is resulted 

  $ cd flash10_androidplugin 
  $ ls
  install_flash_player.apk  uninstall

  $ adb install install_flash_player.apk

To generate SD/MMC card to boot Android

These compiled Images can be copied to a SD / MMC card to boot Android on AM37x EVM The utility mk-bootscr from Tools package can be used to generate a boot script(boot.scr) for the evm to boot automatically.(Provided the NAND environment is empty) 

  $ ./mkbootscr

  $ mkdir image_folder
  $ cp kernel/arch/arm/boot/uImage image_folder
  $ cp u-boot/u-boot.bin image_folder
  $ cp x-loader/MLO image_folder
  $ cp Tools/mk-bootscr/boot.scr image_folder
  $ cp out/target/product/omap3evm/rootfs.tar.bz2 image_folder
  $ cp media_clips image_folder

  $ cp Tools/mk-mmc/mkmmc-android.sh image_folder
  $ ./mkmmc-android <sd card mounted dev folder example:/dev/sdc> MLO u-boot.bin uImage boot.scr rootfs.tar.bz2 Media_Clips

NOTE: mkmmc-android.sh and mk-bootscr are provided in tools folder in DevKit

Hardware Setup and Requirements

This release of TI Android GingerBread 2.3.4 DevKit 2.1 is evaluated on the below given list of platforms. This package should be easily portable on other platforms on similar TI devices.

Requirements

TI Device Platform Supported Version Other Accessories
OMAP35x



OMAP35x EVM Rev G DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)

Beagleboard Rev Cx DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)
AM35x



AM3517 Evaluation Module Rev C DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)
AM37x



AM37x Evaluation Module Rev C DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)

BeagleBoard XM Rev A/B DVI Monitor, USB HUB, USB Keyboard, USB Mouse, Ethernet, UART Cable, Audio Speakers, MMC/SD Card (2GB min)
DM37x



Setup

This section describes the setup and instructions to run TI’s Android DevKit OOB demo on AM37x/DM3730 EVM.

Step 1: Insert SD card into MMC/SD slot on the EVM

Step 2: Set the DIP switch settings to boot from MMC/SD card

AM37x EVM the DIP switch SW4 should be set as shown below

Switch
1
 2
 3
 4
 5
 6
 7
 8
State
OFF
 ON
 ON
 ON
 OFF
 OFF
 OFF
 OFF

AM35x EVM the DIP switch S7 should be set as shown below

Switch
1 2 3 4 5 6 7 8
State
ON OFF OFF ON OFF OFF OFF ON

Step 3: Turn ON the EVM

Refer to UserGuide and RowboPERF user guide from document folder in DevKit release

Step 1: Insert SD card into MMC/SD slot on the Beagleboard

Step 2: Turn ON the Beagleboard

Refer to UserGuide and RowboPERF user guide from document folder in DevKit release

Application Development and Debugging

Using TI's Code Composer Studio V5 (Eclipse based)

Code Composer Studio (CCS) is the integrated development environment for TI's DSPs, microcontrollers and application processors based on the Eclipse open source software framework which includes a suite of tools used to develop and debug embedded applications. Since CCS is based on Eclipse, it is possible to integrate the Android Development Tools (ADT) like Android Debug Bridge (ADB), Dalvik Debug Monitoring System (DDMS) and ndk-gdb in CCS to enable the debugging of Android Applications directly on Android Device (i.e TI EVM) along with the inherent CCS capability of Linux Aware Debug and DSP Debugging.

This wiki walks you through installation of Android Debugging Tools in CCS, connecting CCS with Android Device and illustrates a debugging session of an HelloWorld Application based on android NDK having a mix of Java and Native C Code.

Preparing CCS for Android Development

Note: The steps below are condensed version of steps mentioned on http://developer.android.com/sdk/installing.html

1. Installing the ADT Plugin in CCS Refer http://developer.android.com/sdk/eclipse-adt.html#installing

2. Adding Platforms and Other Components

Android-sdk-manager.png

Setup debugging via ADB over network

Step 1: Upon installing the ADT plugin, DDMS should have been setup. DDMS configuration should be changed as in below: 

Click on Window->Preferences; Select Android -> DDMS
Change - ADB debugger base port: 8700; Logging Level: Verbose
Click on Apply

Step 2: DDMS perspective can now be opened from the eclipse menu via: 

Window -> Open Perspective -> Other -> DDMS; 
Click on OK

Step 3: Get CCS to attach to your TI EVM:

Things to do on Android Device: Obtain IP of your EVM via the executing following command on your EVM’s Serial Terminal: 

      # netcfg

ADB stub on target defaults to USB. To fix this, execute the following on your EVM’s Serial Terminal : 

# setprop service.adb.tcp.port 5555
# stop adbd
# start adbd

On the Host machine run the following commands from cmd prompt: 

 $ export ADBHOST=<IP_ADDRESS_OF_YOUR_TI_EVM> (Linux)
 $ set ADBHOST=<IP_ADDRESS_OF_YOUR_TI_EVM> (Windows)
 $ cd <ANDROID_SDK_ROOT>\platform-tools
 $ adb kill-server
 $ adb start-server
 $ adb connect <target_ip_address>:5555

Check if you are now connected to the TI EVM device by running the following command on the cmd prompt: 

 $ adb devices

It should output something like: 

 emulator-5554 device

This confirms that EVM is connected. With this setup, you should be able to use ADB, logcat, DDMS and other tools directly from CCS ADT environment for creating your applications for Android.

Note: you can refer the following for more details: http://developer.android.com/guide/developing/device.html http://www.omappedia.org/wiki/Android_Debugging#Debugging_on_Zoom2_with_Eclipse_ADT

Debugging Android with CCS

Hello World Application on Android Virtual Device (AVD)

http://processors.wiki.ti.com/index.php/TI-Android-FroYo-DevKit-V2_CCSv5SetupGuide#Hello_World_Using_CCSv5
http://developer.android.com/resources/tutorials/hello-world.html

Hello-jni of Android NDK on Android Device

  1. Click File > New Android Project...
  2. Select the Create project from existing source radio button.
  3. Select any API level above Android 1.5.
  4. In the Location field, click Browse... and select the <ndk-root>/samples/hello-jni directory.
  5. Click Finish.
  6. Go to C/C++ Perspective. Click File->New->Convert to C/C++ Project 
  cd <ndk-root>/samples/hello-jni
  <ndk_root>/ndk-build

  # $GDBCLIENT -x $GDBSETUP -e $APP_PROCESS




  ndk-gdb –adb=<PATH_TO_android-sdk-windows/platform_tools/adb.exe>

  sample command:
  $ ndk-gdb --adb=/cygdrive/c/PROGRA~1/Android/android-sdk-windows/platform-tools/adb.exe

Using ADB Android Debugger, Downloader

Android Debug Bridge (adb) is a versatile tool lets you manage the state of the Android-powered device. For more information about what is possible with adb, see Android Debug Bridge page at http://developer.android.com/guide/developing/tools/adb.html. The ADB tool can be used to

Downloading "ADB" & Host setup

The adb tool is a part of Android SDK package located at http://developer.android.com/sdk/index.html. For an overview of how to install and set up the Android SDK, follow download & setup instructions from http://developer.android.com/sdk/index.html. Once you install Android SDK, the directory contents look like this. 

  add-ons/
  docs/
  platforms/
    <platform>/
       data/
       images/
       skins/
       templates/
       tools/
       android.jar
  samples/
  tools/
SDK Readme.txt

The adb tool is located in tools/ directory under the Android SDK installation. Export the tools directory path as shown below. 

  $ export PATH=${PATH}:<your_sdk_dir>/tools

Connecting Host machine to board through adb

This release of DevKit has been tested for three different methods of connecting a given board with host machine

The below sections describe each of these methods and provides necessary instructions for the same.

adb over USB 

    For Gusty/Hardy, edit the file to read:
    SUBSYSTEM=="usb", SYSFS{idVendor}=="18d1", MODE="0666"

    For Dapper, edit the file to read:
    SUBSYSTEM=="usb_device", SYSFS{idVendor}=="18d1", MODE="0666"

    $ chmod a+r /etc/udev/rules.d/51-android.rules

    $ adb devices 

    If device is connected, then output on screen should list the device, example:
  
       List of devices attached
       20100720    device

adb over USB Ethernet (Ethernet over USB)

IMPORTANT NOTE: Inventra configuration must occur in two places as shown in non-highlighted lines of the screen shots below. 

    $ make ARCH=arm CROSS_COMPILE=arm-eabi- menuconfig

Device Drivers --- USB Support

Android USB ADB ENABLE.JPG

Device Drivers --- USB Support --- USB Gadget Support

Android USBGadget ADB.JPG

Device Drivers --- USB Support --- USB Gadget Support --- Enable Gadget Ethernet support

Android USBEthernet ADB.JPG


The USB network gadget g_ether is named usb0 (instead of eth0 or other network interface names). The normal set of Ethernet configuration tools should work, such as ifconfig, netstat, and route.

For example, the following commands will assign the network address 192.168.194.2 to the target. Run this on the target: 

    $ ifconfig usb0 192.168.194.2 netmask 255.255.255.224 up

On Host machine, run the following commands to establish the connection to the target: 

    $ sudo ifconfig usb0 192.168.194.1 netmask 255.255.255.224 up
    $ sudo route add 192.168.194.2 dev usb0

The target and the host machine should be connected, run ping command to test the same: 

    $ ping -c 3 192.168.194.2
    PING 192.168.194.2 (192.168.194.2) 56(84) bytes of data.
    64 bytes from 192.168.194.2: icmp_seq=1 ttl=64 time=6.08 ms
    64 bytes from 192.168.194.2: icmp_seq=2 ttl=64 time=0.511 ms
    64 bytes from 192.168.194.2: icmp_seq=3 ttl=64 time=0.485 ms
    --- 192.168.194.2 ping statistics ---
    3 packets transmitted, 3 received, 0% packet loss, time 2000ms
    rtt min/avg/max/mdev = 0.485/2.361/6.089/2.636 ms

On the host machine execute following commands to establish adb connection 

    $ export ADBHOST=<target's ip address>
    $ adb kill-server
    $ adb start-server
    $ adb connect <target_ip_address>:5555

Verify the connection by executing 

    $ adb devices

If connected, device name should be listed as a "emulator" 

    $ adb devices
    List of devices attached
    emulator-5554    device
    $ adb shell

adb over Ethernet 

    target #> netcfg                                                                        
       lo       UP    127.0.0.1       255.0.0.0       0x00000049                       
       eth0     UP    172.24.190.59   255.255.252.0   0x00001043                       

    target #> netcfg eth0 dhcp

    target #> setprop service.adb.tcp.port 5555



    target #> stop adbd
    target #> start adbd

    $> export ADBHOST=<target's ip address>
    $> adb kill-server
    $> adb start-server
    $> adb connect <target_ip_address>:5555

    $> adb devices If connected, you'll see the device name listed as a "emulator"

    $> adb devices

    If connected, find the device name listed as a "emulator"

    List of devices attached
    emulator-5554    device
    $ adb shell

For more information about adb commands, see Android Debug Bridge page at http://developer.android.com/guide/developing/tools/adb.html

adb over USB on Windows Machine

Follow the below instructions to get ADB over USB work on a Windows PC

(http://developer.android.com/sdk/index.html) and uncompress it in a local folder (i.e. c:\android_sdk).

(https://dl-ssl.google.com/android/repository/usb_driver_r03-windows.zip) and uncompress it in a local folder (i.e. c:\android_sdk\usb_driver)

"%USERPROFILE%\.android\adb_usb.ini": 

  echo 0x18D1 > "%USERPROFILE%\.android\adb_usb.ini"

Under [Google.NTx86] section add: 

  ;TI EVM
  %SingleAdbInterface%        = USB_Install, USB\VID_18D1&PID_9018
  %CompositeAdbInterface%     = USB_Install, USB\VID_18D1&PID_9018&MI_01

Note: Be careful to add it under Google.NTx86 and not under Google.NTamd64 unless your machine is AMD 64 bits. If you skip this step you won't be able to later install the driver as windows will reject it.

Answer "No, not this time" to the question about running Windows Update to search for software. 

  adb kill-server
  adb start-server

Running Applications

The root File System provided in this DevKit releases contains only standard Android components and applications. User might be interested to download & run android applications (.apk) available in the market. The below procedure gives the steps to be followed to download any .apk file to the board and run it on the platform.

Installing (.apk files) application on Target Platform 

    $> adb install <package>.apk.

NOTE: Use -s option with the adb tool, to install the package on external storage.

On successful installation adb tool will report SUCCESS on host terminal, and the application would be listed on the android main menu.

Un-installing applications (.apk) using adb 

    $> adb uninstall <package>.apk

    Main menu -> Menu -> Settings -> Applications -> Manage applications -> Find the package 
    Tap on it -> Uninstall -> OK -> OK

    $ adb shell
    #rm /system/app/app.apk

On successful removal, the application would have been removed from the android main menu.

Setup ADB for application Debugging

ADB and Eclipse, with ADT( Android Development Tools plug-in) allow users to create and debug Android applications. Follow Developing In Eclipse, with ADT at http://developer.android.com/guide/developing/eclipse-adt.html

Steps to connect Eclipse to the board. 

    Verify the connectivity by executing 
    $ adb devices

For more detailed and complete information on the above follow Developing In Eclipse, with ADT at http://developer.android.com/guide/developing/eclipse-adt.html 

    Window -> Open Perspective -> Other -> DDMS; 
    Click on OK

Copy any files to and from the board over ADB 

    adb pull <remote> <local>

    adb push <local> <remote>

In the commands, <local> and <remote> refer to the paths to the file or directory on your development host (local) and on the target instance (remote). 

    Here's an example: 
    adb push foo.txt /sdcard/foo.txt

Acronyms

Quick References

Content Link Ref#
User Guide http://processors.wiki.ti.com/index.php/TI-Android-GingerBread-2.3.4-DevKit-2.1_UserGuide
Release Notes http://processors.wiki.ti.com/index.php/TI-Android-GingerBread-2.3.4-DevKit-2.1_ReleaseNotes
Porting Guides http://processors.wiki.ti.com/index.php/TI-Android-GingerBread-2.3.4-DevKit-2.1_PortingGuides
Downloads http://focus.ti.com/docs/toolsw/folders/print/androidsdk-sitara.html

Support

For further information or to report any problems, contact http://e2e.ti.com/android or http://support.ti.com.
For community support join http://groups.google.com/group/rowboat
For IRC #rowboat on irc.freenode.net

E2e.jpg For technical support please post your questions at http://e2e.ti.com. Please post only comments about the article TI-Android-GingerBread-2.3.4-DevKit-2.1 DeveloperGuide here.
Hyperlink blue.png Links
ARM Microcontroller MCU ARM Processor Digital Media Processor Digital Signal Processing Microcontroller MCU Multi Core Processor
Ultra Low Power DSP 8 bit Microcontroller MCU 16 bit Microcontroller MCU 32 bit Microcontroller MCU

Retrieved from "http://processors.wiki.ti.com/index.php/TI-Android-GingerBread-2.3.4-DevKit-2.1_DeveloperGuide"
Leave a Comment
Personal tools
Namespaces
Variants
Actions
Navigation
Print/export
Toolbox