Embedded Systems for Aerospace

Install an ARM GCC cross-compiler toolchain and verify its operation from the command line.

Install and configure hardware debugging tools (e.g., OpenOCD) to connect to a target microcontroller.

Configure an IDE (e.g., VS Code) to compile a bare-metal C project using a custom build task.

Configure the IDE to flash the compiled program and launch a live debugging session on the target hardware.

Use a hardware debugger to step through code, set breakpoints, and inspect the live state of CPU registers and memory.

Demonstrate the effect of the `volatile` keyword by observing compiler optimizations with and without it on hardware-related variables.

Write a bare-metal C program to configure GPIO registers for output mode and blink an LED.

Write a bare-metal C program to configure GPIO registers for input mode and control an LED with a button.

Use C structs to create a register map, providing a structured way to access a peripheral like GPIO.

Calculate timer prescaler and auto-reload values to achieve a desired timing interval based on the system clock frequency.

Configure a hardware timer to generate a periodic interrupt at a specified frequency.

Generate a PWM signal using a hardware timer to control the brightness of an LED or the position of a servo motor.

Implement a non-blocking delay using a hardware timer to replace inefficient busy-wait loops.

Refactor a C-style GPIO driver into a C++ class that encapsulates hardware details and provides a clean interface.

Use C++ namespaces and `enum class` to create type-safe register and bit-field definitions, replacing C preprocessor macros.

Implement the RAII (Resource Acquisition Is Initialization) pattern in a peripheral driver class to manage hardware setup and teardown automatically.

Use `constexpr` to perform register configuration calculations at compile-time instead of runtime.

Explain the memory and performance costs of C++ features like virtual functions (v-tables) in a resource-constrained context.

Explain why exceptions, RTTI, and dynamic memory allocation are typically disabled in safety-critical embedded systems, and configure the compiler accordingly.

Configure a GPIO external interrupt and write an interrupt service routine (ISR) that responds to a button press.

Explain the function of the Nested Vectored Interrupt Controller (NVIC) in prioritizing and dispatching interrupts on an ARM Cortex-M core.

Implement a critical section by temporarily disabling interrupts to safely modify data shared between an ISR and the main application loop.

Demonstrate a race condition by creating a scenario where shared data is corrupted by concurrent access from an ISR and the main loop.

Explain what makes a function non-reentrant and why calling one from an ISR is hazardous.

Implement software debouncing for a mechanical button using a timer interrupt to filter out spurious signals.

Configure a UART peripheral to transmit and receive data between a microcontroller and a PC terminal.

Configure an SPI peripheral in master mode to exchange data with a slave device.

Configure an I2C peripheral to communicate with a sensor and read data from its registers.

Use a logic analyzer with a protocol decoder to capture and verify UART, SPI, or I2C transmissions.

Implement a simple state machine to parse incoming serial data streams into meaningful messages.

Compare the trade-offs of UART, SPI, and I2C in terms of speed, wiring, and typical use cases.

Configure an ADC peripheral to perform a single conversion of an analog voltage from a potentiometer or sensor.

Explain key ADC concepts including resolution, sampling rate, and quantization error.

Apply a simple software moving average filter to reduce noise in ADC readings.

Establish communication with an IMU sensor by reading its device ID register over I2C or SPI.

Configure an IMU to enable its accelerometer and gyroscope, and continuously read the raw measurement data.

Convert raw IMU sensor data into physical units (e.g., m/s², deg/s) using scaling factors from the device datasheet.

Integrate FreeRTOS into a project and create multiple concurrent tasks with different priorities.

Explain the role of the RTOS scheduler and the process of preemptive context switching between tasks.

Use FreeRTOS queues to pass data safely between a producer task and a consumer task.

Use a FreeRTOS mutex to protect a shared resource (e.g., a UART peripheral) from concurrent access by multiple tasks.

Use a FreeRTOS binary semaphore to signal an event from an ISR to a deferred processing task.

Demonstrate priority inversion and show how enabling mutex priority inheritance resolves it.

Configure a hardware watchdog timer to automatically reset the system if the application software hangs.

Explain how a DMA controller can perform memory-to-peripheral or peripheral-to-memory data transfers without CPU intervention.

Configure a DMA channel to continuously transfer ADC conversion results to a memory buffer.

Implement a circular buffer with DMA using half-transfer and transfer-complete interrupts to process streaming data without loss.

Configure a DMA channel to transmit a block of data over a UART or SPI peripheral.

Measure the CPU load reduction achieved by using DMA for a data transfer task compared to a CPU-driven (polling or interrupt) approach.

Explain the concept of a closed-loop control system (setpoint, process variable, error, actuator).

Describe the role of the proportional (P), integral (I), and derivative (D) terms in a PID controller.

Implement the core logic of a PID controller in a C++ class.

Design a multi-task RTOS application for a control system, defining tasks for sensing, control computation, and actuation.

Implement a high-priority, periodic FreeRTOS task that executes a complete PID control loop.

Empirically tune the P, I, and D gains of the controller to achieve a stable response for a simple system (e.g., temperature or motor speed control).

Identify and apply key MISRA C++ guidelines relevant to embedded systems, such as rules against dynamic memory and recursion.

Use a static analysis tool (e.g., Cppcheck, Clang-Tidy) to find potential defects and MISRA violations in embedded C++ code.

Write defensive code using assertions to validate program state and input parameters.

Implement robust error handling for peripheral interactions using error flags and return codes instead of exceptions.

Implement a finite state machine (FSM) in C++ to manage the operational modes of a subsystem.

Describe the purpose of key aerospace/defense safety standards like DO-178C and their impact on software development processes.

Implement a fault management task in an RTOS that monitors system health and can command a safe state transition.

Explain the challenges of unit testing embedded software and the role of hardware abstraction layers (HALs).

Use a mocking framework (e.g., GoogleMock) to isolate a C++ module from its hardware dependencies for testing.

Write unit tests for the isolated C++ module using a testing framework like GoogleTest.

Outline the stages of a typical Continuous Integration (CI) pipeline for embedded firmware.

Set up a basic CI workflow (e.g., using GitHub Actions) that automatically builds the firmware on every code push.

Integrate static analysis and unit tests into the CI workflow to automatically verify code quality on every push.

Explain the difference between unit testing, integration testing, and hardware-in-the-loop (HIL) testing in an embedded context.