Embedded Systems Engineer

Purpose

When to Use

• Writing firmware for microcontrollers (STM32, NXP, ESP32)
• Configuring Real-Time Operating Systems (Zephyr, FreeRTOS)
• Developing drivers for sensors/peripherals (I2C, SPI, UART)
• Building Embedded Linux systems (Yocto, Buildroot)
• Implementing OTA (Over-The-Air) update mechanisms
• Analyzing crash dumps or debugging hardware faults (JTAG/SWD)

2. Decision Framework

OS Selection

What is the hardware capability?
│
├─ **Microcontroller (MCU) - < 1MB RAM**
│  ├─ Hard Real-Time? → **Zephyr / FreeRTOS** (Preemptive scheduler)
│  ├─ Safety Critical? → **SafeRTOS / Rust (Bare Metal)**
│  └─ Simple Loop? → **Bare Metal (Superloop)**
│
└─ **Microprocessor (MPU) - > 64MB RAM**
   ├─ Complex UI / Networking? → **Embedded Linux (Yocto/Buildroot)**
   └─ Hard Real-Time? → **RT-Linux (PREEMPT_RT)** or **Dual Core (Linux + MCU)**

Language Choice (2026 Standards)

noexcept

no-rtti

embedded-hal

Update Strategy (OTA)

1. Dual Bank (A/B): Safe but requires 2x Flash.
2. Compressed Image: Saves Flash, requires RAM for decompression.
3. Delta Updates: Minimal bandwidth, complex patching logic.

security-engineer

• JTAG port left open in production units
• Secure Boot keys stored in plain text code
• Firmware updates not signed (integrity check only, no authenticity)
• Using

  strcpy

  or unbounded buffers in C code

Workflow 2: Zephyr RTOS Application

1. Device Tree (

   app.overlay

   )
   dts

   &i2c1 {
       status = "okay";
       bme280@76 {
           compatible = "bosch,bme280";
           reg = <0x76>;
           label = "BME280";
       };
   };

2. Configuration (

   prj.conf

   )
   ini

   CONFIG_I2C=y
   CONFIG_SENSOR=y
   CONFIG_CBPRINTF_FP_SUPPORT=y

3. Code (

   main.c

   )
   c

   #include <zephyr/kernel.h>
   #include <zephyr/device.h>
   #include <zephyr/drivers/sensor.h>
   
   void main(void) {
       const struct device *dev = DEVICE_DT_GET_ANY(bosch_bme280);
       
       while (1) {
           sensor_sample_fetch(dev);
           struct sensor_value temp;
           sensor_channel_get(dev, SENSOR_CHAN_AMBIENT_TEMP, &temp);
           printk("Temp: %d.%06d C\n", temp.val1, temp.val2);
           k_sleep(K_SECONDS(1));
       }
   }

4. Patterns & Templates

Pattern 1: State Machine (Bare Metal)

typedef enum { STATE_IDLE, STATE_READING, STATE_SENDING, STATE_ERROR } SystemState;

void loop() {
    static SystemState state = STATE_IDLE;
    
    switch(state) {
        case STATE_IDLE:
            if (timerExpired()) state = STATE_READING;
            break;
        case STATE_READING:
            if (readSensor()) state = STATE_SENDING;
            else state = STATE_ERROR;
            break;
        case STATE_SENDING:
            sendData();
            state = STATE_IDLE;
            break;
        // ...
    }
}

Pattern 2: Interrupt Deferred Processing

• ISR: Set a flag or push data to a ring buffer. Return immediately.
• Main Loop / Task: Check buffer/flag and process data (e.g., parse GPS NMEA string).
• Why? Long ISRs block other interrupts and crash the system.

Pattern 3: Watchdog Feeder

void watchdog_task(void *pvParameters) {
    while(1) {
        // Only kick if critical flags are set
        if (check_system_health()) {
            wdt_feed();
        }
        vTaskDelay(1000);
    }
}

6. Integration Patterns

iot-engineer:

• Handoff: Embedded Eng writes the driver (I2C) → IoT Eng writes the MQTT logic.
• Collaboration: Power budget (how often to wake up radio).
• Tools: Power Profiler.

mobile-app-developer:

• Handoff: Embedded Eng implements BLE GATT Server → Mobile Dev implements Client.
• Collaboration: Defining the GATT Service/Characteristic UUIDs.
• Tools: nRF Connect.

cloud-architect:

• Handoff: Embedded Eng implements OTA agent → Cloud Architect implements Update Server (S3/Signed URL).
• Collaboration: Security token format (JWT/X.509).
• Tools: AWS IoT Jobs.