Short answer: you use a toolchain (compiler + debugger) and a hardware link (JTAG/SWD/ISP/bootloader) to get code into the chip. Here’s the landscape, fast and practical: ![image_2T3rOhXJ7C](https://hackmd.io/_uploads/r1_jgUqpll.png) **1) Languages & SDKs** * C/C++ (most common), sometimes Assembly for low-level bits. * Growing options: Rust, MicroPython, Arduino abstractions. * Vendor HAL/SDK (e.g., [STM32](https://www.ampheo.com/search/STM32) HAL/LL, [NXP](https://www.ampheo.com/manufacturer/nxp-semiconductors) MCUXpresso, [TI](https://www.ampheo.com/manufacturer/texas-instruments) DriverLib) ease peripheral use. **2) Compilers & IDEs** * GCC/Clang cross-compilers (e.g., arm-none-eabi-gcc, riscv-none-elf-gcc). * Commercial: Keil MDK, IAR EWARM, MPLAB X + XC. * Vendor IDEs: STM32CubeIDE, TI CCS, NXP MCUXpresso, [Microchip](https://www.ampheo.com/manufacturer/microchip-technology) Studio. * Editors + build: VS Code + CMake/Make, PlatformIO. **3) Programmers/Debug Probes (hardware)** * ARM (Cortex-M/A, RISC-V): J-Link, ST-Link, CMSIS-DAP/DAPLink, OpenOCD-compatible. * AVR ([ATmega](https://www.ampheo.com/search/ATmega), [ATtiny](https://www.ampheo.com/search/ATtiny)): AVRISP mkII, USBasp, Atmel-ICE. * PIC: PICkit 3/4, MPLAB ICD/Real ICE. * ESP32/ESP8266: built-in UART bootloader (via USB-UART). * Purpose: flash firmware and live debug (breakpoints, step, watch, SWO/ETM trace on some). **4) Physical interfaces/protocols to the chip** * JTAG (4–5 wires) or SWD (2-wire, ARM) for program/debug. * ISP/UART/USB DFU/I²C/SPI bootloaders (ROM or user) for flashing without a probe. * Voltage: match I/O (often 3.3 V); use level shifters if needed. **5) Flashing tools (CLI you’ll actually run)** * OpenOCD, pyOCD, J-Link Commander/JFlash, ST-Link Utility/STM32CubeProg. * avrdude (AVR), esptool.py (ESP), bossac (SAMD), nrfutil (Nordic). * For Linux-MPUs: U-Boot, fastboot, tftp, dd to SD card, or SSH/scp. **6) Debuggers & tracing** * GDB (often via OpenOCD/pyOCD/J-Link GDB server). * SWO/ITM, ETM, RTT for printf-style tracing without UART. * Logic analyzers/oscilloscopes for timing & bus decode (I²C/SPI/UART/CAN). **7) Typical workflows (microcontroller vs. microprocessor)** **[Microcontroller](https://www.ampheo.com/c/microcontrollers) (bare-metal/RTOS):** 1. Write C/C++ using vendor HAL/RTOS → 2. Build with arm-none-eabi-gcc → 3. Flash via ST-Link/J-Link or UART/USB bootloader → 4. Debug with GDB through the probe. **[Microprocessor](https://www.ampheo.com/c/microprocessors) (runs Linux):** 1. Cross-compile (e.g., aarch64-linux-gnu-gcc) → 2. Copy binary via SSH/scp or bake into rootfs/SD image → 3. Debug with gdbserver over network or JTAG if needed → 4. Boot via U-Boot; kernel/rootfs updates via SD/eMMC/TFTP. **8) If you’re picking your first setup** * STM32/ARM Cortex-M: [STM32](https://www.ampheoelec.de/search/STM32) [Nucleo](https://www.onzuu.com/search/Nucleo) + STM32CubeIDE (built-in ST-Link). * AVR/Arduino-style: Arduino IDE/PlatformIO + on-board USB (bootloader) or AVRISP. * ESP32: esptool.py over USB; use ESP-IDF or [Arduino](https://www.ampheo.com/c/development-board-arduino) core. * RISC-V [dev boards](https://www.onzuu.com/category/development-boards-kits-programmers): OpenOCD + GCC toolchain; many ship with CMSIS-DAP/J-Link options.