Embedded Software Development

Linux User Space Internals

Course Overview

This course provides an in-depth understanding of Linux user space programming concepts, including processes, threads, synchronization, and inter-process communication (IPC). Participants will learn how to design and develop multitasking systems that efficiently manage resources in Linux environments, with a strong focus on hands-on application.

---

Course Objectives

• Explore the principles of Linux user space programming.
• Learn process creation, management, and termination in Linux.
• Understand IPC mechanisms and thread lifecycle management.
• Master synchronization techniques using mutexes and semaphores.
• Develop multitasking applications integrating all learned concepts.

---

Learning Outcomes

By the end of this course, participants will:

1. Demonstrate system call usage and trace underlying operations.
2. Create and manage Linux processes and threads.
3. Implement IPC mechanisms like pipes, shared memory, and semaphores.
4. Solve synchronization challenges using mutexes and semaphores.
5. Build multitasking applications with proper resource sharing.

---

Who Should Attend

• Professionals and students aiming to design advanced Linux-based applications in multi-threaded/multi-processing environments.

Target Industries:

• Telecommunications
• Embedded Systems
• Software Development
• Cloud Computing
• FinTech and Financial Services
• Automotive
• Cybersecurity
• Healthcare Devices
• Aerospace and Defense Systems

---

Prerequisites

• Proficiency in C programming.
• Familiarity with Linux operating system and environment.

---

Why Choose This Course?

• 100% HRDC Claimable
• Hands-on labs and real-world projects
• Focus on multitasking, synchronization, and resource management

---

Lab Setup Requirements

• Linux-based system with required development tools (e.g., gcc, gdb).
• Debugging tools: strace, valgrind, or similar.
• Hardware setup (if applicable) for advanced debugging scenarios.

Embedded Software Development

Linux SPI & UART Drivers

Course Overview

This course offers a detailed exploration of Linux device drivers, focusing on SPI (Serial Peripheral Interface) and UART (Universal Asynchronous Receiver-Transmitter) protocols. Participants will learn to design, develop, and implement SPI and UART drivers in Linux kernel environments. Through hands-on labs, attendees will gain practical experience working with hardware interfaces, debugging drivers, and understanding kernel subsystems related to SPI and UART.

---

Course Objectives

• Learn the basics of SPI and UART communication protocols.
• Develop and implement SPI & UART drivers in the Linux kernel.
• Configure device trees for SPI and UART devices.
• Troubleshoot and debug SPI & UART drivers effectively.
• Write and compile Linux kernel modules for SPI & UART devices.

---

Learning Outcomes

By the end of this course, participants will be able to:

1. Understand SPI and UART communication protocols and their real-world use cases.
2. Write and implement SPI and UART drivers in the Linux kernel.
3. Configure and work with device trees for hardware peripherals.
4. Troubleshoot, debug, and optimize SPI & UART drivers.

---

Who Should Attend

• Embedded Software Engineers
• System Developers working with Linux kernel development
• Engineers focusing on SPI and UART communication protocols

Target Industries:

• Embedded Systems and IoT
• Automotive and Aerospace
• Consumer Electronics

---

Prerequisites

• Basic knowledge of C programming.
• Familiarity with Linux command-line tools.
• Prior knowledge of Linux kernel internals and device drivers (recommended).

---

Key Topics

Day 1: Introduction to Linux Device Drivers and Communication Protocols

• Module 1: Overview of Linux Device Drivers
  • Types: Character, block, and network drivers
  • Linux kernel architecture and modules
• Module 2: Introduction to SPI & UART Communication
  • SPI protocol: Master/slave configuration, full-duplex communication
  • UART basics: Asynchronous communication, baud rate, flow control
• Module 3: Setting Up the Development Environment
  • Installing tools: Compiler, kernel source, and cross-compiler
  • Configuring and compiling the Linux kernel
  • Introduction to device tree (DTS) for hardware description

Day 2: SPI Driver Development and Implementation

• Module 4: Developing SPI Drivers in Linux
  • SPI subsystem and device tree integration
  • Writing SPI device drivers and using spi_master and spi_device structures
• Module 5: Implementing SPI Transfers
  • SPI transactions, timing requirements, and read/write functions
  • Lab: Implement SPI communication
• Module 6: Debugging and Testing SPI Drivers
  • Debugging techniques, using spidev for testing
  • Lab: Test SPI drivers with hardware

Day 3: UART Driver Development and Troubleshooting

• Module 7: Developing UART Drivers in Linux
  • UART subsystem and tty layer
  • Writing and registering UART drivers
  • Configuring device trees for UART peripherals
• Module 8: UART Data Handling
  • Read/write functions, baud rate configuration, and interrupt handling
  • Lab: Implement UART communication in the kernel
• Module 9: Debugging and Troubleshooting UART Drivers
  • Tools: Minicom, cu, kernel logging techniques
  • Lab: Debug and test UART drivers

---

Why Choose This Course?

• 100% HRDC Claimable
• Hands-on labs with real-world hardware setups
• Focus on debugging and troubleshooting SPI and UART drivers

---

Lab Setup Requirements

• Hardware:
  • Development board (e.g., Raspberry Pi, BeagleBone) with SPI and UART peripherals
  • Necessary cables and modules for SPI and UART communication
• Software:
  • Linux development machine or virtual environment
  • Cross-compiler for ARM/embedded architectures

Embedded Software Development

Linux Kernel Debugging

Course Overview

This course provides in-depth training on Linux kernel debugging techniques, tools, and methodologies. Participants will gain the skills to diagnose and resolve kernel crashes, deadlocks, race conditions, performance bottlenecks, and more. Real-world scenarios and hands-on labs ensure proficiency in Linux kernel debugging.

---

Course Objectives

• Understand Linux kernel architecture and debugging challenges.
• Use tools like GDB, KGDB, ftrace, and perf for kernel debugging.
• Analyze kernel crashes, stack traces, and logs effectively.
• Debug kernel synchronization and memory management issues.
• Apply debugging techniques to real-world scenarios.

---

Learning Outcomes

By the end of this course, participants will be able to:

1. Debug kernel crashes and analyze crash dumps.
2. Resolve kernel deadlocks and race conditions.
3. Profile and optimize kernel performance using tools like perf and ftrace.
4. Debug memory management and I/O subsystem issues.

---

Who Should Attend

• Linux Kernel Developers
• System Programmers
• Linux System Administrators
• Software Engineers in Embedded Systems

Target Industries:

• IT and Software Development
• Embedded Systems and Hardware Development
• Cloud Computing and Infrastructure Management

---

Prerequisites

• Basic knowledge of Linux OS and command-line tools.
• Experience with C programming.
• Familiarity with Linux kernel development or system programming is recommended.

---

Key Topics

Day 1: Introduction to Linux Kernel Debugging

• Session 1: Linux Kernel Architecture and Debugging Basics
  • Key components and subsystems
  • Debugging in user space vs. kernel space
• Session 2: Kernel Debugging Tools
  • Overview of tools: GDB, KGDB, kdump, etc.
  • Hands-On: Configuring and using KGDB for remote debugging

Day 2: Advanced Kernel Debugging Techniques

• Session 1: Crash Analysis with kdump
  • Analyzing crash dumps and resolving crashes
  • Hands-On: Trigger and analyze kernel crashes
• Session 2: Tracing and Logging
  • Using dmesg, syslog, and ftrace for tracing kernel functions
  • Hands-On: Analyze kernel logs and trace kernel functions
• Session 3: Debugging Performance Issues
  • Using perf for performance profiling
  • Hands-On: Debugging performance bottlenecks

Day 3: Real-World Kernel Debugging Scenarios

• Session 1: Debugging Synchronization Issues
  • Handling race conditions and deadlocks
  • Hands-On: Detect and resolve kernel synchronization issues
• Session 2: Debugging Memory and I/O Issues
  • Using kmemleak and tools for memory management debugging
  • Hands-On: Debug memory leaks and I/O subsystem problems
• Session 3: Case Studies and Best Practices
  • Real-world scenarios and complex kernel debugging challenges
  • Group Exercise: Solve a kernel bug based on case studies

---

Why Choose This Course?

• 100% HRDC Claimable
• Hands-on labs and real-world case studies
• Focus on advanced kernel debugging tools and techniques

---

Lab Setup Requirements

• Hardware: Physical systems or virtual machines for kernel debugging experiments
• Software:
  • Linux system with debugging tools (GDB, KGDB, ftrace, kdump)
  • Linux kernel source code for hands-on exercises

Embedded Software Development

Linux Inter-Integrated Circuit (I2C) Drivers

Course Overview

This course offers a deep dive into Linux Inter-Integrated Circuit (I2C) drivers, covering their development and integration into the Linux kernel. Participants will learn the I2C protocol's architecture, Linux I2C subsystem APIs, and debugging techniques. Hands-on labs provide practical experience in writing and troubleshooting I2C drivers for embedded systems.

---

Course Objectives

• Understand the architecture and principles of the I2C protocol.
• Develop and integrate I2C drivers into the Linux kernel.
• Use Linux I2C subsystem APIs for device communication.
• Debug and troubleshoot I2C driver-related issues.
• Implement best practices in I2C driver development.

---

Learning Outcomes

By the end of this course, participants will be able to:

1. Explain the architecture of the I2C protocol.
2. Write and integrate I2C drivers in the Linux kernel.
3. Use tools like dmesg, i2cdetect, and i2cget for debugging.
4. Optimize I2C driver performance for embedded systems.

---

Who Should Attend

• Embedded Systems Engineers
• Linux Kernel Developers
• Device Driver Engineers
• System Architects

Target Industries:

• Consumer Electronics
• Automotive
• Industrial Automation
• IoT Device Manufacturing

---

Prerequisites

• Basic understanding of C programming.
• Familiarity with Linux kernel internals.
• Experience in embedded systems and device driver development is recommended.

---

Key Topics

Day 1: Introduction to I2C and Linux I2C Subsystem

• Module 1: Overview of I2C Protocol
  • I2C communication basics, arbitration, addressing modes, and use cases.
• Module 2: Linux I2C Subsystem
  • Introduction to Linux kernel architecture and I2C subsystem APIs.
• Module 3: I2C Driver Model in Linux
  • Registering I2C drivers and writing a basic I2C device driver.
  • Lab 1: Implement a basic I2C driver and perform read/write operations.

Day 2: I2C Driver Development and Communication

• Module 4: Writing I2C Client Drivers
  • Probing, removal functions, and error handling in I2C communication.
  • Lab 2: Develop a client driver for a sensor (e.g., temperature sensor).
• Module 5: I2C Adapter and Controller Drivers
  • Registering I2C adapter drivers and integrating controller hardware.
  • Lab 3: Create and test an I2C controller driver.
• Module 6: I2C Device Tree and Platform Drivers
  • Using device trees for I2C configuration.
  • Lab 4: Configure and test I2C devices with device tree integration.

Day 3: Advanced I2C Driver Topics and Debugging

• Module 7: Advanced I2C Driver Features
  • Multi-master communication, bus recovery mechanisms, and SMBus extensions.
• Module 8: Debugging and Testing I2C Drivers
  • Debugging tools, analyzing I2C traffic, and resolving issues.
  • Lab 5: Debug and troubleshoot a faulty I2C driver.
• Module 9: Best Practices and Optimization
  • Coding best practices and performance tuning for I2C drivers.
  • Lab 6: Optimize an I2C driver for performance.

---

Why Choose This Course?

• 100% HRDC Claimable
• Real-world hands-on labs and case studies
• Focus on practical skills and debugging techniques

---

Lab Setup Requirements

• Hardware:
  • I2C device (e.g., temperature sensor, EEPROM)
  • Ubuntu/Debian-based Linux distribution on physical machines or virtual environments
  • I2C controller hardware, MicroSD card, USB-to-TTL serial cable
• Software:
  • Linux kernel source code (latest stable version)
  • Cross-compilation toolchain for embedded hardware
  • Debugging tools: GDB, dmesg, and logic analyzers

Embedded Software Development

Embedded Linux System Internals

Course Overview

This comprehensive course provides a detailed exploration of Embedded Linux kernel internals, focusing on hardware-specific applications. It covers Linux kernel subsystems, device and driver models, synchronization mechanisms, and debugging techniques. Participants will gain practical skills to port and manage Linux-based operating systems for embedded applications.

---

Course Objectives

• Understand the fundamental structure of the Embedded Linux kernel.
• Learn porting Linux-based OS to hardware platforms.
• Gain proficiency in Linux device driver frameworks.
• Master synchronization mechanisms and Linux DMA engine.
• Develop expertise in Linux kernel debugging and diagnostics.

---

Learning Outcomes

By the end of the course, participants will be able to:

1. Configure and build the kernel, root file system, and device tree.
2. Understand ARM-based multistage boot initialization.
3. Interconnect device trees with drivers.
4. Manage interrupts, events, and synchronization mechanisms in Linux.
5. Utilize Linux DMA Engine APIs in driver development.
6. Debug and diagnose kernel issues.

---

Who Should Attend

• Embedded Software Engineers
• Linux Kernel Developers
• Professionals integrating hardware and software systems

---

Prerequisites

• Experience in embedded programming (C or C++).
• Basic knowledge of Linux systems.

---

Key Topics

Day 1: Booting Initialization and Buildroot

• Morning Session:
  • Embedded system components and boot stages
  • Booting Beagle Bone Black with default images
  • Exercise: Setting up and booting the board
• Afternoon Session:
  • Linux package configuration and Buildroot basics
  • Exercise: Building rootfs, kernel, and deploying with Buildroot

Day 2: Bootloaders and Kernel Basics

• Morning Session:
  • Bootloader designs and adding custom commands in U-Boot
  • Exercise: Adding a custom command in U-Boot
• Afternoon Session:
  • Kernel tasks, parameters, and building the kernel
  • Exercise: Configuring and booting the kernel with initramfs

Day 3: Drivers and Device Models

• Morning Session:
  • Character drivers and dynamic device file creation
  • Exercise: Writing and modifying a character driver
• Afternoon Session:
  • Device models and platform drivers
  • Exercise: Integrating platform drivers with device trees

Day 4: Synchronization and Interrupts

• Morning Session:
  • Mutex, semaphores, spinlocks, and atomic operations
  • Exercise: Writing drivers demonstrating Mutex and Spinlocks
• Afternoon Session:
  • Interrupt handling and bottom-half processing
  • Exercise: Writing GPIO and UART drivers with interrupt handling

Day 5: DMA Engine and Debugging

• Morning Session:
  • DMA controllers and Linux DMA Engine APIs
  • Exercise: Enhancing UART drivers to use DMA
• Afternoon Session:
  • Debugging techniques with DebugFS and KGDB
  • Exercise: Analyzing and optimizing kernel boot-up time

---

Why Choose This Course?

• 100% HRDC Claimable
• Practical, hands-on exercises with real-world applications
• Advanced techniques for driver and kernel optimization

---

Lab Setup Requirements

• Hardware:
  • Beagle Bone Black board, MicroSD card, USB-to-TTL serial cable
  • SD card reader/writer, power supply
• Software:
  • Linux workstation with GCC, Make, ARM cross-compilation toolchain
  • U-Boot and Linux kernel source code
  • Root filesystem images

Embedded Software Development

Embedded Linux Porting Hacks

Course Overview

This 2-day intensive masterclass focuses on the boot-up processes and customization techniques for Embedded Linux Systems using BeagleBone Black (BBB) platforms. Participants will explore bootloaders, kernel optimizations, and practical recovery techniques for bricked devices. By the end of the course, attendees will acquire hands-on expertise applicable to real-world projects.

---

Course Objectives

• Master the boot-up process from bootloaders to user space.
• Customize U-Boot, kernel, and platform features.
• Recover and restore bricked devices.
• Implement boot-up optimization techniques.

---

Learning Outcomes

By the end of the course, participants will be able to:

1. Analyze and optimize the boot-up sequence of Embedded Linux systems.
2. Customize and configure U-Boot and kernel for specific needs.
3. Recover embedded devices from failures.
4. Optimize system performance and boot-up time.

---

Who Should Attend

• Embedded System Engineers
• Firmware Developers
• System Integrators and Troubleshooters

Target Industries:

• Embedded Systems and IoT
• Consumer Electronics
• Automotive
• Telecommunications
• Healthcare Devices
• Industrial Automation
• Defense and Aerospace
• Educational and Research Institutions

---

Prerequisites

• Intermediate to advanced knowledge of Linux and embedded systems.

---

Key Topics

Day 1: Introduction to Boot-Up and Recovery Techniques

• Session 1 (9:00 AM – 10:30 AM): Getting Comfortable with Embedded Linux Systems
  • Overview of embedded system components and target board features
  • Exercise: Booting up with pre-built images
• Session 2 (10:30 AM – 12:30 PM): Understanding Boot-Up Flow
  • Boot concepts and board-specific boot flows
  • Exercise: Partitioning SD card and populating RootFS
• Session 3 (1:15 PM – 3:15 PM): Recovering Bricked Boards
  • U-Boot environmental variables and backup partitions
  • Exercise: Recovering boards and modifying Bootargs
• Session 4 (3:15 PM – 4:30 PM): Bootloader Customization
  • Bootloader stages and U-Boot customization
  • Exercise: Adding custom commands to U-Boot

Day 2: Kernel Customization and Optimization

• Session 5 (9:00 AM – 10:30 AM): Linux Kernel Overview
  • Kernel configuration options and builds
  • Exercise: Minimizing kernel size
• Session 6 (10:30 AM – 12:30 PM): Kernel Booting with Initramfs
  • NFS parameters and RootFS integration
  • Exercise: Configuring kernel with Initramfs support
• Session 7 (1:15 PM – 3:15 PM): Boot-Up Optimization Techniques
  • Measuring and analyzing boot-up time
  • Exercise: Applying boot-time optimization steps
• Session 8 (3:15 PM – 5:00 PM): Wrap-Up and Q&A
  • Final review and next steps

---

Hands-On Activities

1. Setting Up the Embedded Linux System
   • Preparing the environment and compiling system images
   • Configuring and integrating ramdisk
2. Recovering Bricked Devices
   • Partitioning SD cards and restoring RootFS
   • Booting from backup partitions
3. Kernel and Bootloader Customization
   • Adding custom commands to U-Boot
   • Configuring kernels with Initramfs and NFS RootFS
4. Boot-Time Optimization
   • Applying optimization across bootloader, kernel, and user space

---

Lab Setup Requirements

• Hardware:
  • BeagleBone Black (BBB) board, MicroSD card, USB-to-TTL serial cable
  • SD card reader/writer, power supply
• Software:
  • Linux workstation with GCC, Make, ARM cross-compilation toolchain
  • U-Boot and Linux kernel source code
  • Root filesystem images
• Network Setup:
  • Ethernet connection for BBB

---

Why Choose This Course?

• 100% HRDC Claimable
• Practical, hands-on exercises with real-world applications
• Advanced customization and optimization techniques

Embedded Software Development

Embedded Linux Kernel Programming

Course Overview

This course offers a practical introduction to Linux kernel programming for embedded systems. Participants will learn to develop kernel modules, device drivers, and customize the Linux kernel for embedded platforms. Through hands-on sessions, attendees will gain expertise in debugging and optimizing kernel code for real-world applications.

---

Course Objectives

• Understand Linux kernel architecture and its components.
• Write and compile Linux kernel modules.
• Develop and deploy device drivers for embedded hardware.
• Integrate kernel modules with user-space applications.
• Debug and optimize kernel code for embedded systems.
• Utilize cross-compilation toolchains for embedded Linux development.

---

Learning Outcomes

By the end of this course, participants will be able to:

1. Explain Linux kernel architecture and its key components.
2. Write, compile, and debug Linux kernel modules.
3. Develop device drivers for embedded hardware platforms.
4. Handle interrupts, memory management, and synchronization in the kernel.
5. Interface kernel modules with user-space applications.

---

Who Should Attend

• Embedded Systems Engineers
• Linux Developers working on kernel-level programming
• Professionals developing device drivers for embedded systems

Target Industries:

• Embedded Systems and IoT Development
• Consumer Electronics
• Automotive
• Telecommunications

---

Prerequisites

• Basic knowledge of Linux OS.
• Experience with C programming.
• Familiarity with embedded systems development tools.

---

Key Topics

Day 1: Introduction to Linux Kernel Programming and Module Development

• Module 1: Introduction to the Linux Kernel
  • Overview of kernel architecture and components
  • Kernel space vs. user space
  • Role of kernel modules in embedded systems
  • Duration: 1 hour
• Module 2: Setting Up the Development Environment
  • Cross-compilation tools, Yocto/Buildroot
  • Configuring and compiling the Linux kernel
  • Serial communication and debugging tools
  • Duration: 2 hours (includes lab exercises)
• Module 3: Writing and Compiling Kernel Modules
  • Creating "Hello World" kernel modules
  • Loading/unloading modules with insmod and rmmod
  • Accessing kernel logs (dmesg) for debugging
  • Duration: 2 hours (includes lab exercises)
• Module 4: Kernel Programming Essentials
  • Kernel memory management, character device drivers
  • Using kmalloc and kfree
  • Duration: 2 hours (includes lab exercises)

Day 2: Device Drivers, Interrupts, and Kernel Debugging

• Module 5: Developing Embedded Device Drivers
  • Writing and registering character device drivers
  • Debugging and testing drivers on embedded hardware
  • Duration: 2 hours (includes lab exercises)
• Module 6: Interrupt Handling and Synchronization
  • Handling interrupts, IRQ, tasklets, workqueues
  • Synchronization primitives: spinlocks, semaphores, mutexes
  • Duration: 2 hours (includes lab exercises)
• Module 7: Kernel Debugging and Optimization
  • Debugging tools: GDB, KGDB, ftrace
  • Profiling performance using perf
  • Duration: 2 hours (includes lab exercises)
• Module 8: Integrating Kernel Modules with User-Space
  • Exposing kernel modules via /proc and /sys
  • Interfacing with GPIO and I2C/SPI devices
  • Duration: 1 hour (includes lab exercises)

---

Why Choose This Course?

• 100% HRDC Claimable
• Hands-on labs with real-world applications
• Focus on debugging, optimization, and device driver development

---

Lab Setup Requirements

• Hardware:
  • Embedded Linux development boards (e.g., Raspberry Pi, BeagleBone)
  • Necessary debugging tools (e.g., serial cables, UART interfaces)
• Software:
  • Linux host machine with cross-compilation tools (e.g., GCC for ARM)
  • Debugging tools: GDB, KGDB

Embedded Software Development

Embedded Android Internals

Course Overview

This course delves into the Android operating system's internals, tailored for embedded systems. Participants will explore Android architecture, the Linux kernel, hardware abstraction layers (HAL), drivers, boot processes, and more. Practical, hands-on exercises ensure participants learn to customize Android for diverse hardware platforms effectively.

---

Course Objectives

• Gain an in-depth understanding of Android OS architecture.
• Master Android’s integration with the Linux kernel.
• Develop and customize hardware abstraction layers and drivers.
• Configure Android for custom hardware platforms.
• Debug and troubleshoot embedded Android systems.

---

Learning Outcomes

By the end of this course, participants will be able to:

1. Understand the internal structure and architecture of Android OS.
2. Work with Android hardware abstraction layers and drivers.
3. Develop and modify Android system components for embedded platforms.
4. Boot and configure Android on custom hardware.
5. Debug and optimize embedded Android devices.

---

Who Should Attend

• Embedded software engineers
• Android system developers
• Linux kernel developers focusing on Android internals
• IoT and embedded device professionals

Target Industries:

• Consumer electronics
• Automotive
• Industrial control
• Mobile and telecommunication devices

---

Prerequisites

• Basic knowledge of Android development
• Familiarity with Linux systems (command-line proficiency)
• Experience with embedded systems and hardware
• Basic understanding of C/C++ and Java

---

Why Choose This Course?

• 100% HRDC Claimable
• Hands-on lab exercises for practical experience
• Industry-relevant case studies and real-world examples

---

Key Topics

Day 1: Introduction and Android Architecture

• Overview of Android OS and applications in embedded systems
• Android architecture layers (Applications, Frameworks, Libraries, Kernel)
• Hands-on: Setting up the Android development environment

Day 2: Boot Process and Device Drivers

• Android boot process (U-Boot, fastboot, init system)
• Customizing bootloaders and device drivers
• Hands-on: Adding custom device drivers

Day 3: Hardware Abstraction Layer (HAL)

• Understanding HAL in Android systems
• Building and integrating custom HAL components
• Hands-on: Adapting Android to ARM-based platforms

Day 4: Android Frameworks and System Services

• Android framework and critical system services
• Modifying system services for embedded systems
• Hands-on: Implementing security measures with SELinux

Day 5: Debugging, Performance Tuning, and Real-World Applications

• Debugging Android internals with logcat and adb
• Performance tuning for embedded systems
• Final project: Customizing Android for an embedded hardware platform

---

Lab Setup Requirements

• Linux-based development machine (Ubuntu preferred)
• Embedded development board (e.g., Raspberry Pi, BeagleBone)
• Android source code environment with AOSP
• Relevant hardware interfaces: Serial cables, JTAG debugger