1.1. Getting Started Guide¶

Welcome to the Android Getting Started Guide

Thank you for your involvement in learning more about the Android Software Development Kit (SDK). The SDK as we affectionately call information technology is our attempt to provide a neat starting point to develop an embedded system on a TI Processor running Android. Given this goal, nosotros wanted to provide something that is more than just a typical Lath Support Package (BSP) containing a bootloader, Linux kernel, and Android filesystem. While these are certainly necessary elements, nosotros feel they are just a starting point, specially for those that aren't experts in developing with Android. So, the SDK also contains tools for developing on TI Processors (a validated cantankerous-compiling toolchain, for instance), pre-built libraries that yous can utilize without having to rebuild them yourself, and some documentation to help explicate how all of these pieces work together. We bundle all of this together with a working Android Embedded System that has been built with all of the things mentioned above.

What it really serves as is a "known adept" starting bespeak. One of the big challenges with starting development on a new platform (not to mention, a new Operating System (Os) for many), is getting an environment ready upwards where you can build and debug code on hardware. The SDK attacks this problem with providing everything you need to practice development, and it is validated on standard TI hardware platforms (EVMs). It wraps all of this up into one simple installer that helps get everything you need in the correct place to do development. For example, you lot can start off with just re-building the Android Embedded Organization that we provide to validate that everything is working on your arrangement. This uncomplicated stride gives you confidence that you can move forward from a skillful baseline.

As you become along your development journey and accept questions, there is documentation and back up available to you lot. Make sure to save a pointer to the Android SDK Software Programmer'due south Guide (SDG). If you don't find what you need, have a await at the active E2E Processor Support Forum and come across if the topic has been covered before. If not, mail service a new thread and we'll exercise our best to provide some guidance.

What would you like to do with the SDK?

As described in a higher place, the SDK has a lot to it. Let's interruption it down to two pieces to simplify things a bit:

  • The example embedded Android organisation. Substantially, a working bootloader (U-Boot), Linux kernel, and Android filesystem that can exist put on an SD card and ran on a TI AM57xx EVM.
  • Everything needed to create the above embedded organisation from "scratch":
    • U-Kicking sources and configuration files
    • Kernel sources and configuration files
    • An Android cantankerous-compiling toolchain as well every bit other host binaries and components
    • The Android Open Source Project (AOSP) filesystem and sources for example applications (later on syncing using the repo tool)
    • A variety of scripts and Makefiles to automate certain tasks
    • Other components needed to build an embedded Android system that don't fit neatly into i of the in a higher place buckets

With these two pieces more clearly divers, we can now get back to that all important question, "What would you like to do with the SDK?". If the respond is clearly "I desire to build something and I'k set to start developing now!", so go ahead and skip down to the "I want to Develop!" (or, Developing with the SDK) department below for instructions on installing the SDK on a Linux Host System. This is a somewhat involved process focusing on the second of the two parts of the SDK listed above and may be more some people want to kickoff with. Still, information technology provides access to the full spectrum of evolution from rebuilding the SDK from sources to fully adapting it with new device drivers and applications.

So, if you're not quite there yet, let'south hash out some other options. Maybe y'all'd similar to evaluate the SDK a scrap to see if it is how you'd like to get started.

If this is not adept enough and you lot really desire to get your easily on something, cheque out the next department which shares how to play with the embedded Android system. All y'all'll need is access to a Windows/Linux computer, an SD card, an SD card reader, some gratis, open-source software, and a supported Hardware platform.

Evaluating the SDK Embedded Android Organization

If you're a hands on person, reading documentation and looking at presentations gets sometime fast. Then, if you want to meet an example of what you can build with the SDK and actually concord information technology in your easily and play with it (or show information technology to someone else that needs aid agreement what you want to exercise with it), with minimal effort, y'all tin simply run the SDK Embedded Android System on a supported Hardware platform. This will let you to poke and prod and collaborate. It'due south a powerful way to get the imagination active and engaged.

If you've recently purchased a TI AM572x GP EVM or an AM57xx IDK, move on to the next step to install the SDK and boot your board using the provided prebuilt images.

Start your Android Development

OK, you're all in. Either yous've known this is what you wanted to do, or you've gone through the above steps and you want to exercise more. It'due south time to develop! Here'due south a high level overview:

  • Get a Linux host up and running if you don't already have one
  • Install the SDK and run some scripts to become everything set upwards
  • Put the SDK Embedded Android Organization on an Evaluation Module to play with
  • Build something to validate prepare up – the SDK for example
  • Add something to the SDK, like a simple Hello World app

Later on completing these steps, you'll accept a known good baseline from which you can start development.

  1. Configure a Linux Host - If you already take a Linux host automobile, get to Step 2. To do Android development with the SDK, y'all'll need a host PC running Linux. The Linux host is mostly much faster and has a lot more memory (both RAM and hard disk infinite) than the typical embedded system. While it is certainly possible to exercise all development natively, we experience the advantages of using a host provide a improve mode to go and what is supported out of the box with the SDK. In that location are many, many ways to get access to a Linux host. Nosotros simply can't validate all possibilities and iterations, therefore nosotros focus on validating using Ubuntu as the host Linux distribution, running natively. Nosotros validate the Long-term Support (LTS) versions of Ubuntu at the time of a SDK release (Ubuntu xvi.04 and Ubuntu 18.04 are the currently supported LTS version). Tin you use other versions of Ubuntu or even other distributions? Theoretically, yeah, equally long as you can get it to work and at that place may be more "associates" required. If you tin can use the Ubuntu version validated against the SDK, it will be the smoothest path and we volition be able to help you more if you do run into trouble. Too, we would strongly recommend getting a native 64-bit Ubuntu LTS machine gear up for development. For the cost of a little bit of hard drive infinite, Ubuntu can have directly access to the host's hardware. Virtual Machines (VMs) have come a long way over the years, and many people utilize them daily without problems. However, when you are working with a target embedded system (that may be a paradigm board), whether it be a TI lath or somewhen your own, removing the complexity of a VM from the get go can avert a lot of frustration (i.due east. wasted time). When using a VM while connecting and disconnecting hardware components, you lot take to be very diligent well-nigh making sure what is continued to what. You lot might prefer using an hour to go more work done than debugging a perceived problem acquired by the fact the virtual host grabbed a USB port when you weren't watching. When you lot're ready to continue, Ubuntu provides a great overview for how to install natively. If y'all eventually desire to rebuild the Android filesystem from source, you'll also need to follow the instructions from the official Android page here for setting upward the packages required for building Android.

  2. Install the SDK - Within your Linux host machine, Install the Android SDK Processor SDK Installer is 64-bit, and installs only on 64-bit host machine. Back up for 32-bit host is dropped as of the Gingerbread Android release At to the lowest degree 70 GB of gratis space is required on the host machine in society to pull then rebuild the full AOSP filesystem

  3. Create an SD Carte using the SDK Create SD Card Script You volition need a >4GB SD Card and the adequacy to connect that card to your Linux Host automobile (using a USB SD Card reader, for example). If using a virtual auto as your Linux host, yous may demand to import the SD Carte reader into your virtual motorcar (disconnect it from the host and connect information technology to the VM so that the Linux VM tin run into information technology).

  4. Configure your evolution surround At that place are many ways to connect the host development platform and the target lath. These connections will vary depending on how you lot like to develop and what y'all are trying to practice. Here is an example of a mutual set up with a serial connection for console, an Ethernet for networking, and a USB connectedness for flashing and ADB:

    ../_images/Android_Dev_Environment_Cropped.png

  5. Run the Setup Script - Once the SDK has been installed and the SD carte du jour has been created and placed into the device, run the setup.sh Script on your host to guide you through the process of flashing the bootloader, kernel, and Android filesystem to the onboard eMMC.

Notation

The eMMC flashing process utilizes the fastboot utility of U-Boot in order to place the bootloader (U-Boot), kernel, and Android filesystem into non-volatile eMMC memory. For this reason, U-Kick running on the SD bill of fare is merely needed for the initial flashing procedure, subsequently this, the bootloader can exist run from the eMMC in order to wink updated bootloaders, kernels, or filesystems.

Note

Booting Android solely from the SD carte du jour is not supported on the Processor SDK Android v4.ii release. The SD menu should just be used to run U-Kick in society to flash the onboard eMMC.

  1. Rebuild sources using the acme-level makefile in the SDK root directory. For example:
  • make all rebuilds all components in the SDK
  • make linux configures and builds the kernel
  • make u-kicking-spl builds u-boot and u-boot-spl

The Android filesystem can exist rebuilt, and then flashed to the onboard eMMC, past following these instructions.

What Would You Like to practise Next?

At present that you have a solid baseline gear up, yous can choose what you'd like to do adjacent based on what yous demand to do. Here are some of the many possibilities:

Link Summary
AM57X Download the SDK
Processor SDK Android Software Developer's Guide The SDK'southward Homepage, a must accept link for SDK users.
Processor SDK Android How-To Guides The SDK How-To pages. The Easily On with the SDK has some great information for developing your commencement Android awarding.

ane.1.1. Install the Android SDK¶

1.1.one.one. Overview¶

The Processor SDK Installer (ti-processor-sdk-android-am57xx-evm-xx.xx.20.xx-Linux-x86-Install.bin) will install the necessary components to start your development on the TI microprocessor. The SDK consists of source for the universal bootloader (u-kicking), the Linux kernel, toolchain and board support packet, ease of utilise scripts and documentation. The Android file system sources can also be cloned to the SDK using the provided repo tool and manifest file. The Processor SDK was built and tested against a specific Linux Distribution proper noun and version. Notation this does not prevent the user from installing the SDK on other Linux distributions.

1.1.one.ii. How to Become the SDK Installer¶

Download from the Android SDK download page. This will always host the latest version of SDK.

1.1.1.3. How to Run the SDK Installer¶

Make sure that the execute permissions are ready. Bring up a last window and change directories to the where the installer is located (probably the Downloads directory if downloaded) and run the following commands:

chmod +x ./ti-processor-sdk-android-am57xx-evm-xx.xx.twenty.20-Linux-x86-Install.bin**

Alternatively, you tin give execute permissions and run the SDK Installer by double clicking on it within your Linux host PC.

Annotation

If naught seems to happen, you lot are probably running a 32-chip version of Linux. The installer is 64-scrap, and will not execute properly.

1.1.1.four. Boosted Installer Options¶

Invoking the installer with argument –help will list available options for the installer (e.1000. text installer, etc.):

./ti-processor-sdk-linux-[platformName]-evm-xx.twenty.20.xx-Linux-x86-Install.bin --aid

one.1.1.5. SDK Installer Execution Steps¶

  1. Environment Support Message User is to acknowledge the host operating system recommendations.
  2. GPLv3 Components Notice User is to admit the utilise of GPLv3 components in the SDK.
  3. Directory Install Location The user will be prompted for a location on where to put the Processor SDK. An instance is given below.
  4. Review and Confirm User is to confirm if loading the Processor SDK is ok. This is of import to annotation if the user is trying to over-install on an existing directory and has made changes to the directory.
  5. Installation of software The software is installed.

Where to install the Processor SDK package

The default selection of where to install is the user's domicile directory. In this particular example the name of the user is 'sitara'.

../_images/Processor_sdk_android_select_directory.png

one.1.2. SD Card Cosmos¶

The Android SDK includes a script in the <ANDROID SDK INSTALL DIR>/bin directory named create-sdcard.sh. The purpose of this script is to create SD cards using the boot files from the Processor SDK for Android.

The script volition give yous information about each step, simply the following sections will go over the details and walk you through how to apply the script.

one.1.2.ane. Invoking the Script¶

The create-sdcard.sh script can be run from any location but must exist run with root permissions. This usually means using the sudo command to start execution of the script. For case:

sudo <ANDROID SDK INSTALL DIR>/bin/create-sdcard.sh

If you neglect to execute the script without root permissions y'all will receive a message that root permissions are required and the script will go out.

1.i.ii.2. Select the SD Menu Device¶

The first step of the script will inquire you to select the drive representing the SD carte that y'all want to format. In nearly cases your host root file organisation drive has been masked off to prevent damage to the host system. When prompted enter the device number corresponding to the SD card. For example if the output looks like:

Availible Drives to write images to:  #  major   pocket-size    size   proper noun ane:   8       16    7761920 sdb  Enter Device Number:

You would enter 1 to select the sdb device

Note

For most common installations, this script works fine. However, if you are using more avant-garde disk slicing and volume management, the presented list of device nodes are off by one; in the all-time case (picking the last detail) it volition flag a range mistake, and in the worst case (anything in the centre) the incorrect DASD tin can exist destroyed. The problem originates when it attempts to determine the $ROOTDRIVE to "mask" the volume where "/" is mounted from the selection list using a "grep -v $ROOTDRIVE" For the naive sectionalization instance, its heuristic is fine, yielding something similar "sda" — but for LVM, it grabs some clamper of the device proper name, e.g. "mapp" (out of "/dev/mapper/kubuntu–vg-root on / type ...")

one.1.ii.iii. Re-Partitioning the SD Card¶

Whatever partitions of the device that are already mounted will be un-mounted and then that the device is ready for sectionalization.

The SD card will be re-partitioned to create a single boot sectionalisation with the boot files copied later. The message below will testify and you will be prompted whether you want to continue segmentation the SD card:

################################################################################  Division will format the drive with boot partition  ################################################################################   ################################################################################       ****WARNING**** continuing will erase all data on sdd  ################################################################################  Would you like to continue? [y/due north] :

Select y to continue with the partitioning. Select n if re-division is non desired.

one.1.two.4. Installing SD Card Content¶

After the SD card is partitioned, you will exist prompted whether y'all want to keep copying the boot files or safely exit the script.

  • Options:
    • y - Selecting yes here volition begin the procedure of installing the SD card contents. This operation WILL ERASE any existing information on the SD carte du jour.
    • north - Selecting no here will permit you to have partitioned your card but will leave the partitions empty.

If yous have selected y, yous should at present encounter a prompt like:

now installing:  ti-processor-sdk-android-am57xx-evm-06.00.00.05  0. BOOTFILEPATH = ....00.00.05//lath-support/prebuilt-images ane. MLO          = GP_MLO 2. BOOTIMG      = u-boot-am57xx-evm.img 3. BOOTUENV     = uEnv.txt   Would you like to continue? [y/due north] :

You should choose option y to create an SD bill of fare using the pre-built boot files from the SDK. If you choose northward and so the script will exit.

Yous should execute this script from inside the SDK so the script can decide the SDK path automatically. The script will outset copying the contents to the SD card. Once the files are copied the script will exit.

i.i.3. Run Setup Scripts¶

1.ane.three.ane. Overview¶

After installation of the SDK on the Linux host, the setup script tin can exist run to flash the prebuilt images to the onboard eMMC. Some of the tasks crave ambassador privileges. The script will prompt you when these administrator privileges are required. The setup script does the following things:

  • Minicom setup (to create a series connection to the board)
  • u-boot setup (to configure the environment variables for the fastboot procedure)
  • Flashes the prebuilt images to the onboard eMMC (to allow yous to boot the board from the eMMC)

ane.1.3.2. Prerequisites¶

To run the SDK's setup script the following steps should be taken first:

  1. Install Minicom on your Linux host car and add the current user to the dialout grouping. A Minicom script is used to configure the u-boot surround variables as well every bit put the device into fastboot way.

    sudo apt-go install minicom sudo usermod -a -Chiliad dialout $username

  2. Run the create-sdcard.sh script provided in the SDK's bin/ directory This volition create an SD carte using the prebuilt kicking files, including a fastboot enabled u-boot.

  3. Put the newly created SD card into your EVM

  4. Connect a serial cable from your Linux host automobile (the i from which you will run the setup.sh script) to your EVMs serial port. The AM572x GP EVM will require a vi-pin USB-to-serial cable. The 6-pin connexion is on the underside of the board. FTDI Series cablevision The AM57xx IDK boards take an onboard USB to serial IC and then simply a micro USB cable is required. The silkscreen next to the correct micro USB port will say 'USB JTAG' (both JTAG and series connection are on the same port) and will be on the corner of the board that is opposite from the RJ-45 connectors.

  5. Connect a micro USB cable (used for fastboot and ADB connections) from your Linux host car to your EVMs (other) micro USB port. The AM572x GP EVM only has ane micro USB port and it is located next to the SD card slot The AM57xx IDK has two micro USB ports. The second port is located underneath the RJ-45 jacks.

  6. Connect the provided power cable to the barrel jack.

  7. Ability up your lath and apply ls /dev/ | grep ttyUSB on your Linux host machine to find your serial port connection to your lath The AM572x GP EVM will show up equally a single connection (e.g. /dev/ttyUSB0) The AM57xx IDK boards will have two connections, one for serial communication and one for JTAG (e.g. /dev/ttyUSB0 and /dev/ttyUSB1). The higher numbered port is the serial connexion that we are looking for.

  8. Note downward the series connectedness device path, for example /dev/ttyUSB1

1.1.3.3. How to run the setup script¶

The Setup Script is located in the Processor SDK Android installation directory. By default, this directory has a name that has the course ti-processor-sdk-android-am57xx-<Version>. Navigate to that ti-processor-sdk-android install directory. Then run the script:

Detailed description of what the script is doing is provided in the subsections below.

Minicom Setup

This step let's the rest of the process now which series port the lath connection is on. You should respond to the following question with the device found in pace #7 above.

Which serial port practise y'all want to use with minicom? [ /dev/ttyUSB0 ]
  • A minicom configuration will be saved for y'all at /habitation/user/.minirc.dfl
  • The old configuration if there was one will be saved at /home/user/.minirc.dfl.old

uboot Setup

This section volition create a Minicom script to generate the necessary u-kick environment variables and commands to put your lath into fastboot fashion.

Would yous like to create a minicom script to configure the board (y/n)? [ y ]

If you answer 'n' to this question the script volition exit.

Run the Setup Script

This section will run the remainder of the setup script and will create a series of action between the board and your Linux host that will configure the u-boot environment variables, put the EVM into fastboot fashion, and then flash the prebuilt images to the eMMC on the device. Yous must select 'y' at the following question and so power cycle or reboot your board to kickoff the procedure.

Would you like to run the setup script now (y/n)? [ y ]

If you answer 'n' to this question the script volition go out.

Boot Android

At the completion of the this process you will have a board that can boot Android through the newly flashed eMMC device. For AM57x IDKs, keep the SD carte du jour plugged in, power cycle the board to employ MLO and u-boot.img from the SD card and the residue from the eMMC. For AM57x GP EVM, SD card can be removed before the power bicycle to boot Android with everything from the eMMC.