• Menu
  • Product
  • Email
  • PDF
  • Order now

  • Enabling Android Automotive on Your TI Development Board

    • SPRACO0 August   2019 AM6526 , AM6528 , AM6546 , AM6548

       

  • CONTENTS
  • SEARCH
  • Enabling Android Automotive on Your TI Development Board
  1.   Enabling Android Automotive on Your TI Development Board
    1.     Trademarks
    2. 1  Introduction
    3. 2  Implementation
      1. 2.1 Prerequisites
      2. 2.2 Software Changes
    4. 3  Deploy Instructions
      1. 3.1 Build Instructions
      2. 3.2 Boot Instructions
    5. 4  Testing
      1. 4.1 Prerequisites/Setup for Automotive Testing
        1. 4.1.1 Compatibility Test Suite (CTS)
        2. 4.1.2 Vendor Test Suite (VTS)
      2. 4.2 Automotive Testing
        1. 4.2.1 Compatibility Test Suite (CTS)
        2. 4.2.2 Vendor Test Suite (VTS)
    6. 5  Open Source
    7. 6  Extending to a New Platform
    8. 7  Known Bugs
    9. 8  Future Work
    10. 9  FAQ
    11. 10 References
  2. IMPORTANT NOTICE
search No matches found.
  • Full reading width
    • Full reading width
    • Comfortable reading width
    • Expanded reading width
  • Card for each section
  • Card with all content

 

APPLICATION NOTE

Enabling Android Automotive on Your TI Development Board

Enabling Android Automotive on Your TI Development Board

This application report walks you through the steps necessary to enable Android™ Automotive on your TI development board.

The Android Automotive OS and Human-Machine Interface (HMI) provide users with a simplified interface for accessing applications while on the road. The OS is an Android-based infotainment system that allows for a vehicle-optimized, stand-alone Android device to be placed inside the head unit. In place of the phone apps, users install driver-optimized versions of the app directly onto the console. This streamlined experience enables the driver to perform efficient tasks, such as climate control, maps, phone, audio, and so forth, in the convenience of their vehicle.

Trademarks

Android is a registered trademark of Google LLC.

All other trademarks are the property of their respective owners.

1 Introduction

This document shows the key differences between the standard (tablet) configuration and the Android Automotive interface. The look and feel of the applications will differ in the sense that they will be specially tuned towards an automotive experience. It also shows how to switch between the different target types (tablet and automotive) at build time. The AM57xx BeagleBoard-X15 Sitara platform was used since this is the only currently supported TI platform for development in the Android Open Source Project. The same work accomplished on the AM57xx BeagleBoard-X15 can be extended to a new platform; the AM65x EVM module is used as an example. Finally, the future work involved when enabling these features on a more automotive-tuned platform once it’s available is discussed.

  • By default, the TI development board will launch with a tablet user interface (UI).
    • Tablet_Home.gifFigure 1. Home Screen for Tablet Configuration
  • After creation of the automotive target on the TI development board, the following user interface will be available.
    • Auto_Start_Car.gifFigure 2. Start Screen for Automotive Configuration, Depicting a Car With PSI Information Near Tires
    Auto_Car_Launcher.gifFigure 3. “Let’s Drive” Interface for Automotive Configuration (allowing you to interact with applications by selecting the icon in the middle)
    Auto_Climate_Control.gifFigure 4. Climate Control Interface for Automotive Configuration (allowing you to adjust temperature, fan speed and direction, seat warmers, and so forth)
    Auto_Notifications.gifFigure 5. Notification Pane for Automotive Configuration (presenting you with up-to-date notifications regarding your vehicle)

2 Implementation

2.1 Prerequisites

  1. Check to make sure your setup meets the hardware and software requirements as given by Android.
  2. Environment Setup:
    1. Android Pastry Version: Pie (based on http://git.ti.com/cgit/cgit.cgi/android/manifest.git/log/?h=pie-core-release)
    2. Linux Kernel: ti-android-linux-4.19.y
    3. Toolchain: gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf
  3. Follow the steps provided in the Processor SDK Android 1.1 Getting Started Guide to install the necessary components and 1.3 Building the SDK to prepare for development on the TI microprocessor.
  4. Establish your Build Environment for Android.
  5. Ensure that your device meets the Automotive Requirements defined by the Android Compatibility Definition Document.

2.2 Software Changes

NOTE

Please change directory to your Android File System before continuing.
  1. Changes inside device/ti/beagle_x15/AndroidProducts.mk:
    1. These changes add a new lunch combo called “beagle_x15_auto-userdebug” and it’s path to the relative top-level makefile.
    2. PRODUCT_MAKEFILES += \ - $(LOCAL_DIR)/beagle_x15.mk \ + beagle_x15:$(LOCAL_DIR)/beagle_x15.mk \ + beagle_x15_auto:$(LOCAL_DIR)/auto/beagle_x15.mk \ COMMON_LUNCH_CHOICES := \ beagle_x15-userdebug \ + beagle_x15_auto-userdebug \
  2. Changes inside device/ti/beagle_x15/BoardConfig.mk:
    1. Conditional is needed to differentiate the content that is included depending on the TARGET_PRODUCT (macro set by lunch combo).
    2. DEVICE_MANIFEST_FILE adds the auto-specific manifest file to the build.
    3. BOARD_SEPOLICY_DIRS += \ device/ti/beagle_x15/sepolicy +ifeq ($(TARGET_PRODUCT), beagle_x15_auto) +BOARD_SEPOLICY_DIRS += \ + packages/services/Car/car_product/sepolicy + +DEVICE_MANIFEST_FILE += device/ti/beagle_x15/auto/manifest.xml +endif
  3. Create an auto directory inside of device/ti/beagle_x15.

    4. NOTE

    The following steps will all be completed inside the device/ti/beagle_x15/auto directory.
  4. Create a top-level makefile for the "beagle_x15_auto-userdebug" lunch combo.
    1. The top-level makefiles are inherited to include all necessary components (PRODUCT_PACKAGES, PRODUCT_COPY_FILES, PRODUCT_PROPERTY_OVERRIDES, and so forth) to enable desired features.
      1. auto/device.mk and car.mk are crucial to enabling all automotive-specific features.
      2. The content inside the car.mk, the common makefile for all car builds, can be found here.
      3. car.mk then inherits car_base.mk, the base platform for car builds, whose content can be found here.
      4. Inside car_base.mk, the auto-specific PRODUCT_PROPERTY_OVERLAYS are added to customize the product at build time.
    2. Insert the following content:
      3. $(call inherit-product, device/ti/beagle_x15/device.mk) $(call inherit-product, device/ti/beagle_x15/auto/device.mk) $(call inherit-product, $(SRC_TARGET_DIR)/product/full_base.mk) $(call inherit-product, packages/services/Car/car_product/build/car.mk) PRODUCT_NAME := beagle_x15_auto PRODUCT_DEVICE := beagle_x15 PRODUCT_BRAND := Android PRODUCT_MODEL := AOSP Auto on BeagleBoard X15 PRODUCT_MANUFACTURER := Texas Instruments Inc
  5. Create the device.mk to declare the auto-specific files and modules needed for the device.
    1. The android.hardware.automotive.vehicle@2.0-service PRODUCT_PACKAGE is the Android Automotive hardware abstraction layer (HAL), which is the interface definition between the car and the vehicle network service.
    2. The frameworks/../../../android.hardware.type.automotive.xml PRODUCT_COPY_FILE determines that the Android device implementation is classified as “Automotive”.
    3. Insert the following content:
    6. PRODUCT_PACKAGES += \ android.hardware.automotive.vehicle@2.0-service \ PRODUCT_COPY_FILES += \ frameworks/native/data/etc/android.hardware.type.automotive.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.type.automotive.xml \ frameworks/native/data/etc/android.hardware.screen.landscape.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.screen.landscape.xml \ PRODUCT_PROPERTY_OVERRIDES += \ android.car.drawer.unlimited=true \ android.car.hvac.demo=true \ com.android.car.radio.demo=true \ com.android.car.radio.demo.dual=true \
  6. Create the manifest.xml to provide the HAL(s) specific to automotive.
    1. Beagle_x15 requires the android.hardware.automotive.vehicle inclusion to define the product as automotive.
    2. Insert the following content:
    7. <manifest version="1.0" type="device"> <hal format="hidl"> <name>android.hardware.automotive.vehicle</name> <transport>hwbinder</transport> <version>2.0</version> <interface> <name>IVehicle</name> <instance>default</instance> </interface> </hal> </manifest>

3 Deploy Instructions

3.1 Build Instructions

  1. Change directory to your Android File System.
  2. To setup your build environment, run the following script:
    3. $ . ./build/envsetup.sh
  3. To view the “lunch” menu and select a combo (TARGET_PRODUCT):
    4. $ lunch
  4. Select the desired TARGET_PRODUCT (<board>_auto-userdebug).
  5. Export the path to your Kernel directory:
    6. $ export KERNELDIR=<path_to_kernel_directory>
  6. Build:
    7. $ make -j<number_of_cores>

3.2 Boot Instructions

  1. Once build is complete, prepare your eMMC binaries and images:
    1. Make a copy of the prebuilt-images directory to be used as a working directory for flashing.

    2. NOTE

    Review the <Android_FS>/device/ti/<board>/fastboot.sh for exact images to copy into flashing directory.

    AM5

    cd ~/ti-processor-sdk-android-beagle_x15-<version>/board-support/ cp -rv prebuilt-images emmc_files cp -v ./aosp-<version>/out/target/product/beagle_x15/{boot.img,boot_fit.img,recovery.img,system.img,userdata.img,vendor.img} emmc_files cp -v ./aosp-<version>/device/ti/beagle_x15/fastboot.sh emmc_files cp -v ./aosp-<version>/out/host/linux-x86/bin/{simg2img,mkbootimg,fastboot,adb} emmc_files cp -v ./linux-<version>/arch/arm/boot/zImage emmc_files/zImage-beagle_x15.bin cp -v ./linux-<version>/arch/arm/boot/dts/am57*.dtb emmc_files cp -v ./u-boot-<version>/MLO emmc_files cp -v ./u-boot-<version>/u-boot.img emmc_files

    AM6

    cd ~/ti-processor-sdk-android-am65xx-evm-<version>/board-support/ cp -rv prebuilt-images emmc_files cp -v ./aosp-<version>/out/target/product/am65xevm/{boot_fit.img,system.img,userdata.img,vendor.img} emmc_files cp -v ./aosp-<version>/device/ti/am65xevm/fastboot.sh emmc_files cp -v ./aosp-<version>/out/host/linux-x86/bin/{simg2img,mkbootimg,fastboot,adb} emmc_files cp -v ./aosp-<version>/out/host/linux-x86/lib64/{libc++.so,libcutils.so,liblog.so,libselinux.so,libpcre2.so} emmc_files cp -v ./u-boot_build/a53/u-boot.img emmc_files cp -v ./u-boot_build/a53/tispl.bin emmc_files cp -v ./u-boot_build/r5/tiboot3.bin emmc_files
  2. Ensure the device is plugged in with USB Host and Debug UART/Serial Debug.
  3. Open a terminal debugger to view console output from the device (dmesg: kernel ring buffer, logcat: log of system messages):
    4. $ sudo picocom -b 115200 /dev/ttyUSB0
  4. Enable fastboot on the device through the terminal debugger:
    5. => fastboot 0
  5. In a different terminal, change directory to emmc_files and run the fastboot.sh script:
    6. $ cd ~/ti-processor-sdk-android-<board>-<version>/board-support/emmc_files $ sudo ./fastboot.sh; sudo ./fastboot reboot

 
Texas Instruments

© Copyright 1995-2025 Texas Instruments Incorporated. All rights reserved.
Submit documentation feedback | IMPORTANT NOTICE | Trademarks | Privacy policy | Cookie policy | Terms of use | Terms of sale