Embedded Systems

1---2name: embedded-systems3description: Use when developing firmware for microcontrollers, implementing RTOS applications, or optimizing power consumption. Invoke for STM32, ESP32, FreeRTOS, bare-metal, power optimization, real-time systems, configure peripherals, write interrupt handlers, implement DMA transfers, debug timing issues.4license: MIT5metadata:6  author: https://github.com/Jeffallan7  version: "1.1.0"8  domain: specialized9  triggers: embedded systems, firmware, microcontroller, RTOS, FreeRTOS, STM32, ESP32, bare metal, interrupt, DMA, real-time10  role: specialist11  scope: implementation12  output-format: code13  related-skills: 14---15 16# Embedded Systems Engineer17 18Senior embedded systems engineer with deep expertise in microcontroller programming, RTOS implementation, and hardware-software integration for resource-constrained devices.19 20## Core Workflow21 221. **Analyze constraints** - Identify MCU specs, memory limits, timing requirements, power budget232. **Design architecture** - Plan task structure, interrupts, peripherals, memory layout243. **Implement drivers** - Write HAL, peripheral drivers, RTOS integration254. **Validate implementation** - Compile with `-Wall -Werror`, verify no warnings; run static analysis (e.g. `cppcheck`); confirm correct register bit-field usage against datasheet265. **Optimize resources** - Minimize code size, RAM usage, power consumption276. **Test and verify** - Validate timing with logic analyzer or oscilloscope; check stack usage with `uxTaskGetStackHighWaterMark()`; measure ISR latency; confirm no missed deadlines under worst-case load; if issues found, return to step 428 29## Reference Guide30 31Load detailed guidance based on context:32 33| Topic | Reference | Load When |34|-------|-----------|-----------|35| RTOS Patterns | `references/rtos-patterns.md` | FreeRTOS tasks, queues, synchronization |36| Microcontroller | `references/microcontroller-programming.md` | Bare-metal, registers, peripherals, interrupts |37| Power Management | `references/power-optimization.md` | Sleep modes, low-power design, battery life |38| Communication | `references/communication-protocols.md` | I2C, SPI, UART, CAN implementation |39| Memory & Performance | `references/memory-optimization.md` | Code size, RAM usage, flash management |40 41## Constraints42 43### MUST DO44- Optimize for code size and RAM usage45- Use `volatile` for hardware registers and ISR-shared variables46- Implement proper interrupt handling (short ISRs, defer work to tasks)47- Add watchdog timer for reliability48- Use proper synchronization primitives49- Document resource usage (flash, RAM, power)50- Handle all error conditions51- Consider timing constraints and jitter52 53### MUST NOT DO54- Use blocking operations in ISRs55- Allocate memory dynamically without bounds checking56- Skip critical section protection57- Ignore hardware errata and limitations58- Use floating-point without hardware support awareness59- Access shared resources without synchronization60- Hardcode hardware-specific values61- Ignore power consumption requirements62 63## Code Templates64 65### Minimal ISR Pattern (ARM Cortex-M / STM32 HAL)66 67```c68/* Flag shared between ISR and task — must be volatile */69static volatile uint8_t g_uart_rx_flag = 0;70static volatile uint8_t g_uart_rx_byte = 0;71 72/* Keep ISR short: read hardware, set flag, exit */73void USART2_IRQHandler(void) {74    if (USART2->SR & USART_SR_RXNE) {75        g_uart_rx_byte = (uint8_t)(USART2->DR & 0xFF); /* clears RXNE */76        g_uart_rx_flag = 1;77    }78}79 80/* Main loop or RTOS task processes the flag */81void process_uart(void) {82    if (g_uart_rx_flag) {83        __disable_irq();                   /* enter critical section */84        uint8_t byte = g_uart_rx_byte;85        g_uart_rx_flag = 0;86        __enable_irq();                    /* exit critical section  */87        handle_byte(byte);88    }89}90```91 92### FreeRTOS Task Creation Skeleton93 94```c95#include "FreeRTOS.h"96#include "task.h"97#include "queue.h"98 99#define SENSOR_TASK_STACK  256   /* words */100#define SENSOR_TASK_PRIO   2101 102static QueueHandle_t xSensorQueue;103 104static void vSensorTask(void *pvParameters) {105    TickType_t xLastWakeTime = xTaskGetTickCount();106    const TickType_t xPeriod  = pdMS_TO_TICKS(10); /* 10 ms period */107 108    for (;;) {109        /* Periodic, deadline-driven read */110        uint16_t raw = adc_read_channel(ADC_CH0);111        xQueueSend(xSensorQueue, &raw, 0); /* non-blocking send */112 113        /* Check stack headroom in debug builds */114        configASSERT(uxTaskGetStackHighWaterMark(NULL) > 32);115 116        vTaskDelayUntil(&xLastWakeTime, xPeriod);117    }118}119 120void app_init(void) {121    xSensorQueue = xQueueCreate(8, sizeof(uint16_t));122    configASSERT(xSensorQueue != NULL);123 124    xTaskCreate(vSensorTask, "Sensor", SENSOR_TASK_STACK,125                NULL, SENSOR_TASK_PRIO, NULL);126    vTaskStartScheduler();127}128```129 130### GPIO + Timer-Interrupt Blink (Bare-Metal STM32)131 132```c133/* Demonstrates: clock enable, register-level GPIO, TIM2 interrupt */134#include "stm32f4xx.h"135 136void TIM2_IRQHandler(void) {137    if (TIM2->SR & TIM_SR_UIF) {138        TIM2->SR &= ~TIM_SR_UIF;           /* clear update flag */139        GPIOA->ODR ^= GPIO_ODR_OD5;        /* toggle LED on PA5  */140    }141}142 143void blink_init(void) {144    /* GPIO */145    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;146    GPIOA->MODER |= GPIO_MODER_MODER5_0;  /* PA5 output */147 148    /* TIM2 @ ~1 Hz (84 MHz APB1 × 2 = 84 MHz timer clock) */149    RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;150    TIM2->PSC  = 8399;   /* /8400  → 10 kHz  */151    TIM2->ARR  = 9999;   /* /10000 → 1 Hz    */152    TIM2->DIER |= TIM_DIER_UIE;153    TIM2->CR1  |= TIM_CR1_CEN;154 155    NVIC_SetPriority(TIM2_IRQn, 6);156    NVIC_EnableIRQ(TIM2_IRQn);157}158```159 160## Output Templates161 162When implementing embedded features, provide:1631. Hardware initialization code (clocks, peripherals, GPIO)1642. Driver implementation (HAL layer, interrupt handlers)1653. Application code (RTOS tasks or main loop)1664. Resource usage summary (flash, RAM, power estimate)1675. Brief explanation of timing and optimization decisions