Embedded development

In embedded or cross-platform development, the compute architecture of the host development system (i.e. hosts) is different than the the target execution platform (i.e. targets). Thus, the target application(s) (i.e. programs) will not be able to run on the host development system.

The communication channel between the host and target lets the host software (e.g. XploR Studio) program and control the target hardware behavior and program code.

Because of the inherent architural differences between the hosts and targets, XploR Studio is integrated with different embedded compiler toolchains, operating systems, hardware designs, and debug & monitoring tools, packaged as components and delivered by the IDE to provide a unified experience to create, build, deploy, test and debug designs for developers.

mainframe Cross-platform development

state "Host Development System" as hosts 
note left of hosts : where XploR IDE runs
hosts : Linux or Windows on x86 / ia64

state "Target Execution Platforms" as targets 
targets : ARM, RISC-V, or others ISA(s)\nrunning baremetal or with an\nembedded OS
note right of targets : where target applications run

targets -u-> hosts
note left on link
acknowledgement to 
host from target
end note

hosts --> targets 
note left on link
host commands to
program or debug target
end note

Embedded Target

In the post-silicon development flow, the embedded target consists of a CPU and associated peripherals (e.g. USB, Ethernet, I2C, …). The CPU implements and execute code defined by an Instruction Set Architecture (ISA, e.g. x86, ARM, RISC-V). JTAG is commonly the communication channel between the host and target for programming and debugging, as shown below:

mainframe Post-silicon embedded target

state "Host Development System" as hosts 
hosts : Linux or Windows on x86 / ia64

state "Target Platform (ASICs)" as targets {
  state CPU : x86 or ARM
  state Memory : DDR, SRAM, ...
  state Peripherals : USB, Ethernet, ...
}
note bottom of targets : CPU, Memory and Peripherals are\nASIC blocks, not modifable.
state JTAG
note top of JTAG : JTAG used to program target memory\nand control / debug programs on CPU.

hosts -> JTAG 
JTAG -> targets

Host software

Some of the most common software components that run on the host computer.

IDE

XploR Studio has a command line interface as well as a graphical user interface based on the Eclipse IDE. Both are collection of software programs and tools let the developer create programs for the embedded targets.

The Integrated Development Environment (IDE) is a unified graphical user interface that makes it easy and convenient for developers to write and debug code. The IDE typically includes a source code editor, a source-level debugger, and a build automation tool.

The XploR Studio IDE is a flexible and highly configurable software environment that is fully integrated with components to accelerate pre and post silicon software development.

Also see Why do I need an IDE?

Cross toolchain

The cross toolchain is the set of tools that compiles program source code, written in C/C++ or assembly language, into executable instructions that run on the target platforms. The cross toolchain consists of compilers, linker, and associated run-time libraries.

Compiler choices: The GNU compiler (www.gnu.org), and LLVM are two most popular compilers for cross platform development. GNU GCC is compatible with a wider range of existing open source software, CPU architecture, and operating systems.

LLVM is a more modern compiler that, while continuously evolving, provides faster compilation speed, better diagnostic, and is modularly designed, making it the popular choice for new and emerging ISA and architecture.

GDB

GDB is a GNU project command line debugger that allows developers to debug programs written in various languages. It supports many debugging formats and offers many debugging features, including the ability to step through code, set breakpoints, and examine variables. The XploR Studio IDE provides a graphical interface to GDB, making it easier to view different aspects of the running program (e.g. call-stack, variables, registers, and assembly code) from centralized dash-board.

Target software

Bootloader

Program code and data of an embedded operating system must be loaded into the target platform working memory during the device start-up. This task is achieved by the bootloader, which is a program launched immediately after the target starts.

Note: The U-Boot bootloader is a popular bootloader available for embedded microarchitecture such as PowerPC and ARM. Recent ISA such as RISC-V takes a more minimalistic approach, such as that supported by BBL (Berkeley Boot Loader)

Real-time OS (RTOS)

A real-time operating system (RTOS) is an operating system that is designed to provide predictable processing time for critical tasks. An RTOS can respond to an event in a specified time period. This makes it ideal for applications that require high reliability or timing precision.

RTOS(es) provide real-time task scheduling and basic memory management, along with advanced features such as multi-threading, interrupt handling and power management. Some RTOS(es) such as Zephyr OS are scalable and can be configured to support as many or as few features as needed in order to minimize resource and memory footprint.

RTOS awareness: The XploR Studio IDE and related components provide support for building and debugging of several popular RTOS(es) including Amazon FreeRTOS, Zephyr OS, and embedded Linux.