Week 4 Embedded Programming - Adults¶
This week’s group assignment was to demonstrate and compare the toolchains and development workflows for available embedded architectures. Our group focused on the Xiao RP2040, Pico H RP2040, ESP32-C6, ATmega328, ATTiny412.
| Angela Board | Camille Board | Dorian Board | Kim Board | Kim2 Board | |
|---|---|---|---|---|---|
| MCU (Board type) | ESP32C6 | Atmel ATmega328P(Elegoo R3 Uno) | RP2040 (XIAO-RP2040) | Raspberry Pi Pico H(It is a RP2040 based microcontroller) | ATtiny412 (tinyAVR 1-series) |
| Architecture (way data is stored and used, Harvard Architecture: ARV & PIC) | dual 32-bit RISC-V | RISC Architecture | Dual ARM Cortex-M0+ | ARM Cortex-M0+ dual-core | 8-bit AVR (Harvard Architecture) |
| Processors | 2: 32-bit RISC-V | 1 8-bit AVR | M0+ | 2:32bit M0+ | 1: 8-bit AVR with hardware multiplier |
| # of Pins | 14 pins | 28 Pins (19 pins on the Elegoo Board - programming pins) | (56) 14 | 40 | 8 Pins (6 I/O pins + VCC + GND) |
| MHz | 20 MHz | 16 Mhz | 133 | 133 | 20 MHz |
| Flash/SRAM | HP SRAM: 512 KB Flash: 4MB | 32KB Flash Memory/ 2KB SRAM | ( 0 Flash / 264KB SRAM) 2MB Flash | 2MB/264KB SRAM | 4KB Flash / 256B SRAM / 128B EEPROM |
| GPIO | 22 GPIOs | 23 programmable I/O lines | (29) 11 | 26 | 6 I/Os |
| Packages | QFN32 32pin quad flat no-lead package | PDIP (28-pin DIP package)Other packages available are 32-lead TQFP, and 32-pad QFN/MLF | (QFN-56) | QFN-56 56pin quad flat no-lead package | SOIC-8 (8-pin small outline IC) |
| IDE | VS Code + ESP-IDF (official development framework) Arduino IDE VS Code + Platform IO | VS code or Arduino | (the RP2040 can not run on its own as it has not flash memory) Thony, VS Code, Arduino C++ | Thonny (MicroPython), Arduino IDE (Philhower core), VS Code + Pico SDK (C/C++), VS Code + PlatformIO | Arduino IDE (with megaTinyCore), Microchip Studio (Atmel Studio), VS Code + PlatformIO; programmed via UPDI |
| Use Case/Notable Features | 2.4 GHz Wifi 6, Bluetooth 5.3, Zigbee, Thread | Is used to make boards similar to an arduino along with many other things. | Small size, USB-C, 14 accessible pins are not too overwhelming, relatively inexpensive | Programmable I/O (PIO) — 8 state machines for custom protocols; UF2 drag-and-drop bootloader; pre-soldered headers (H variant); no wireless | Ultra-small 8-pin package; Core Independent Peripherals (configurable custom logic, event system); SleepWalking low-power features; 10-bit ADC (6 channels), 8-bit DAC; UPDI single-pin programming |
| Coding Language | Arduino (C/C++), MicroPython/Python | Can be programmed in python, C/Arduino, AVR assembly language. Comes with AVR instructions built into silicon & bootloader written in C or assy language. | microPython, C++ | MicroPython, CircuitPython, C/C++, Arduino (C/C++) | Arduino (C/C++), C, AVR Assembly |
| Cost | $5.38 on DigitKey | $2.63 at Digikey | $4.68 at digikey | $5 at Digikey - the h in Pico H means presoldered headers | ~$0.58 at Digikey (bare chip — requires custom PCB, no USB/headers) |
ESP32C6¶
There are three different datasheets from three from different resources: - ESP32C6 espressif - ESP32C6 seeeduino - ESP32C6 wiki
See example code at Angela’s Page.
Atmel ATmega328P(Elegoo R3 Uno)¶
See example code at Camille’s Page.
RP2040 (XIAO-RP2040)¶
Picture of board
Link to RP2040 data sheet
See example code at Dorian’s Page.
Raspberry Pi Pico H¶
See example code at Kim’s Page.
ATTiny¶
See example code at Kim’s Page
Key Terms/Definitions¶
These definitions were obtained from the internet AI/Gemini/Googling the terms.
Embedded toolchains¶
Embedded toolchains are specialized sets of software—compilers (e.g., GCC, Clang), linkers, and debuggers—configured to translate high-level code (C/C++) into machine code for specific target microcontrollers, which differ from the development machine’s architecture.
MCU development boards¶
MCU development boards (e.g., Arduino, STM32 Nucleo, ESP32) are single-board computers, generally categorized by bit-width (8-bit to 64-bit), architecture (ARM RISC, AVR, PIC), and memory. They are designed for embedded systems, featuring on-chip flash memory and GPIO for interfacing with sensors and motors.
Microcontroller (MCU) architecture¶
MCU architecture defines the internal structure, organization, and interaction of hardware components—CPU, memory (RAM/ROM), and peripherals—integrated onto a single chip to control specific, dedicated tasks. It typically follows Harvard or Von Neumann models, utilizing RISC or CISC instruction sets to manage embedded systems efficiently.
Megahertz (MHz)¶
Mhz is a unit of frequency equal to one million cycles per second. It measures the speed of electromagnetic waves (like radio) or, more commonly in computing, the clock speed of processors and RAM, where a higher MHz value generally indicates faster processing of instructions.
Flash memory¶
Flash memory is a non-volatile, rewritable storage medium that retains data without power, commonly used for code storage (firmware) in devices like SSDs and microcontrollers. SRAM (Static Random Access Memory) is a volatile, high-speed, and expensive memory used for temporary data, such as CPU cache and active variables, losing data when power is lost. This size limits your code size.
SRAM (Static Random Access Memory - Volatile)¶
SRAM - stores your variables, arrays.. anything your program uses while running. It clears when the power turns off.
GPIO (General-Purpose Input/Output) pins¶
GPIO pins are uncommitted, programmable digital pins on a microcontroller (MCU) that act as an interface to the outside world. They can be individually configured via software as inputs (reading sensor data/switches) or outputs (controlling LEDs/relays). These pins represent the fundamental way a microcontroller communicates with peripheral devices. Look for the programmable I/O lines in the description.
Package¶
How the chip can be delivered. DIP pin package, surface mount.
An Integrated Development Environment(IDE)¶
An IDE for microcontrollers is a software application that provides a comprehensive, all-in-one suite of tools for designing, writing, compiling, debugging, and flashing code onto a microcontroller unit (MCU). It acts as the central hub for embedded system development, combining an editor, compiler, and debugger to make the process of programming hardware more efficient.