What a Junior } should know

Understands O-notation and basic algorithms in embedded context: sorting, searching considering MCU memory constraints. Selects appropriate algorithms.

Understands async model in embedded: interrupts, callbacks, event-driven architecture. Implements simple ISR handlers on STM32.

Follows coding standards: variable naming, formatting, commenting in embedded C/C++. Uses clang-format for consistency.

Knows basic data structures for embedded: arrays, linked lists, queues. Understands dynamic memory limitations on MCU.

Understands MCU memory model: Flash, RAM, stack, heap. Knows linker script sections (.text, .data, .bss). Monitors memory usage.

Understands basic multithreading for embedded systems: RTOS task creation and scheduling, basic semaphore and mutex usage for resource protection, interrupt service routines and thread interaction. Follows team conventions for concurrent firmware design patterns.

Understands CI/CD concepts for embedded development: build, test, deploy for firmware. Uses existing workflows for cross-compilation and hardware-in-the-loop tests. Can add a step for firmware validation. Reads failed build logs for toolchain issues.

Understands basic unit testing for embedded code: CUnit/Unity test framework basics, hardware abstraction layer mocking, simple register value assertions. Follows team patterns for testing firmware modules on host before flashing to target.

Participates in code review: checks formatting, naming. Learns to give constructive feedback on embedded code.

Uses Git for embedded: commit, push, pull, basic branching. Understands .gitignore for build artifacts and IDE files.

Understands bare-metal development: startup code, linker script, interrupt vector table. Writes simple programs without OS on STM32.

Understands the fundamentals of BLE & Wireless: Zigbee, LoRa, WiFi. Applies basic practices in daily work. Follows recommendations from the team and documentation.

Knows C basics for embedded systems: data types, pointers, register operations. Writes simple drivers under mentor guidance on STM32/ESP32.

Understands C++ memory management basics for microcontrollers. Writes simple drivers and peripheral access code. Follows coding standards for embedded safety-critical systems.

Uses basic debugging tools: JTAG/SWD through ST-Link, breakpoints in IDE, printf debugging through UART. Analyzes simple bugs.

Understands GPIO, ADC, DAC operation on MCU. Configures pins through HAL, reads analog values. Uses multimeter for signal verification.

Understands the fundamentals of MQTT Protocol. Applies basic practices in daily work. Follows recommendations from the team and documentation.

Understands the difference between hard/soft real-time. Knows task scheduling basics, deadlines and jitter. Measures latency with oscilloscope.

Understands RTOS concepts: tasks, priorities, semaphores, queues. Creates simple multi-task applications on FreeRTOS under mentor guidance.

Understands the fundamentals of SPI / I2C / UART Protocols. Applies basic practices in daily work. Follows recommendations from the team and documentation.

Uses basic CPU profiling: DWT cycle counter, GPIO toggle + oscilloscope for measuring function execution time on MCU.

Understands latency sources in embedded: interrupt latency, context switch, bus wait states. Measures response time with oscilloscope.

Understands MCU resource constraints: Flash, RAM, CPU cycles, power. Optimizes binary size through compiler flags (-Os, LTO).