Embedded on the Arduino Uno
One board, twenty pins and a C++ sketch. From a lamp you switch to a game you can play.
Open the courseAll courses
Embedded track
Embedded systems, from your first blink to firmware you can ship
Arduino, ESP32, Raspberry Pi Pico and STM32: pins, timing, buses, motors, WiFi, registers and debugging, every lesson checked on a simulated board.
The track
Zero to expert, one course at a time
Embedded systems are the computers inside things: the thermostat, the drone, the car door, the insulin pump. Learning them means learning two things at once, code and the hardware it controls, and this track teaches both together on boards the simulator runs cycle by cycle.
It starts on an Arduino Uno with no experience needed, then moves to the parts every real product uses: I2C, SPI and UART, motor drivers, WiFi and MQTT, then down to the registers, timers, interrupts and debugger underneath the Arduino functions.
The ladder
Every course, by level
Take them in order, or start on the rung that matches what you already know. Each course page lists every lesson.
Level 1
Start from zero
One board, a few pins and a sketch.
Interactive devices on the Uno
Read people and sensors without blocking, control an output, then finish with two playable builds.
Open the courseLevel 2
Build real devices
Buses, motors, new boards and the network.
Talk to chips: I2C, SPI and UART
The three buses every sensor, screen and radio speaks, on the Uno: serial between two boards, I2C scans and shared buses, SPI screens and an SD card, the logic analyzer, and a weather station that uses them all.
Open the courseMotors and motion
DC motors on a driver, the H bridge inside it, servos, a stepper on an A4988, an encoder that measures what the motor did, and a 2WD robot car with ultrasonic eyes and line sensors.
Open the courseEmbedded on the ESP32-C3
A 32 bit RISC-V board at 160 MHz. Its own peripherals, its own 3.3 V rules, and a console at the end of it.
Open the courseEmbedded on the Raspberry Pi Pico
A dual core Cortex-M0+ at 125 MHz. PWM on every pin, a 64 bit clock, and pins that do not forgive 5 V.
Open the courseMicroPython on the Pico
Real Python on a Raspberry Pi Pico: blink and the REPL, buttons and if, loops and PWM, a knob on the ADC, lists and functions on an LED bar, an OLED on I2C, and a reaction game boss.
Open the courseConnected devices
WiFi, APIs, a web server, MQTT, ESP-NOW and BLE on the ESP32, and a device that keeps going when the network does not.
Open the courseLevel 3
Go under the hood
A professional board, the registers, datasheets and real debugging.
Embedded on the STM32F411
A Cortex-M4 at 84 MHz, where a pin is a port and a number and every peripheral starts with its clock switched off.
Open the courseDebug like an engineer
The multimeter, the oscilloscope, the logic probe and analyzer, Serial done right, and a method that finds any fault. Ends with a boss: three bugs in one circuit.
Open the courseUnder the hood
Take the Arduino wrapper off: DDR, PORT and PIN, Timer 1 by hand, the vector table and interrupts, cycle-counted delays in a .S file, a bug read off a halt in the debugger, and a UART drawn by hand on a pin.
Open the courseRead datasheets and schematics
The skill every hardware job asks for: schematic symbols, a first page, absolute maximum ratings, timing diagrams, register maps and pinouts, each checked on real parts. Ends with a sensor brought up from its datasheet alone.
Open the courseLevel 4
Expert
Control loops, real-time timing, low power and firmware that scales.
Control systems: PID
Feedback control on real physics: open and closed loops, P, I and D one at a time, tuning by the numbers, encoders, a balancing robot, and a motor that holds its speed whatever you throw at it.
Open the courseScheduling and RTOS
From a scheduler written by hand to FreeRTOS on the Uno: tasks and priorities, time slicing on the logic analyzer, queues, mutexes and priority inversion, starvation and the watchdog, and a four-task device.
Open the courseLow power products
Make a battery last years: where an Uno鈥檚 current goes, sleep modes and wake sources, a power budget on a bare chip, measuring with a meter and an INA219, battery life checked against a draining cell, and a coin cell node.
Open the courseFirmware architecture
How a whole device is put together on the Uno: a scheduler and state machines, ISRs that only record, drivers behind interfaces, checked settings in EEPROM, error codes and the watchdog, safe updates, and a layered multi-sensor boss.
Open the courseOutcomes
What you will be able to do
- Read inputs and drive outputs without blocking, using millis() timing and interrupts.
- Wire and code I2C, SPI and UART devices, and read every byte on a logic analyzer.
- Drive DC motors, servos and steppers, and connect a device to WiFi, MQTT and BLE.
- Set up ports and timers by hand, read a datasheet and find faults with a meter and a scope.
Careers
Where this track leads
The jobs these skills are used in every day, with what each one does and how to get there.
Embedded firmware engineer
Write the code that runs inside cars, drones, watches and every smart gadget.
See the careerIoT and connected devices developer
Build devices that sense the world and talk to apps over Wi-Fi.
See the careerRobotics and automation technician
Build, wire, program and fix the robots and machines in real factories.
See the careerTopics
Looking for something specific?
Each of these starts you on the right course and lesson for one subject.
Learn Arduino online, free, on a simulated Uno
Real C++ on a modeled ATmega328P, checked step by step. No board to buy, nothing to install, and the same code runs on a real Uno later.
Start hereAn ESP32 course, from first light to WiFi and BLE
Pins at 3.3 V, interrupts, a screen and NeoPixels on the ESP32-C3, then WiFi, a web server, MQTT, ESP-NOW and Bluetooth on the ESP32.
Start hereA Raspberry Pi Pico course in C++ and MicroPython
The RP2040 two ways: C++ with PWM on any pin and a 64 bit clock, or MicroPython with the REPL. Then a fight stick to finish.
Start hereAn STM32 course for people who already know an Arduino
The STM32F411, a Cortex-M4 at 84 MHz, where a pin is a port and a number and every peripheral starts with its clock off.
Start hereI2C, SPI and UART: talk to chips
The three buses every sensor, screen and radio speaks. Scan a bus, share it, run two screens on one clock, log to SD, then read every byte on a logic analyzer.
Start hereAn IoT course where you build the connected devices
Join WiFi, call an API, serve a page and publish over MQTT on an ESP32, then ESP-NOW, BLE and the devices people put around the house.
Start hereA motor control course: DC, servo, stepper and encoder
Speed and direction on a driver, the H bridge inside it, angles on a servo, STEP and DIR on an A4988, and an encoder that measures what really happened.
Start hereAVR registers: DDR, PORT, PIN and the timers by hand
Take the Arduino wrapper off the Uno: set pins with registers, run Timer 1 yourself, follow the vector table and count cycles in assembly.
Start hereA firmware engineering course, hands-on
The skills firmware jobs ask for: registers, timers and interrupts by hand, C++ structured for testing, a debugger halt and protocols bit-banged from scratch.
Start hereAn advanced Arduino course for after the basics
You can blink, read buttons and use millis(). Next: C++ classes and state machines, ports and timers by hand, and three buses on one board.
Start hereLearn PID control by standing up a balance bot
Read tilt from an IMU, see what the wheels do to it, then write and tune the PID loop that keeps a two-wheel robot upright.
Start hereA MicroPython course on the Raspberry Pi Pico
Real Python on a microcontroller: blink and the REPL, buttons, PWM, the ADC and an I2C screen, ending in a reaction game you write yourself.
Start hereMQTT on an ESP32: publish, subscribe and stay connected
Topics, retained state and PubSubClient on a simulated ESP32, then the reconnect loop every real device needs.
Start hereQuestions
About the embedded track
What is embedded systems programming?
Writing the code that runs on a small computer inside a device, usually a microcontroller, where the program talks straight to pins, timers and buses rather than to an operating system.
Which board should I learn embedded on first?
The Arduino Uno. It is simple enough to understand completely, and everything you learn on it, from pins and timing to buses and registers, carries over to the ESP32, the Pico and STM32 later in the track.
Do I need real hardware?
No. Every lesson runs on a simulated board in your browser, and the same wiring and code work on a real board when you want to build it.
How long does the embedded track take?
Each course takes a few hours to a dozen. Most people can finish the first two rungs in a few weeks of evenings, and the later rungs go as deep as you want to take them.
Tracks
The other tracks
Coding track
Python and C++ from your first print to classes, tests and state machines. Every program runs on a simulated board, so a bug is something you can see.
See the trackElectrical track
Current and voltage you can see, then transistors, op-amps, filters, power and PCBs. Every circuit runs in a real circuit simulator in your browser.
See the trackMaker track
Follow the starter kit you already own, then build a claw machine, a balance bot, a handheld console or an LED cube, each a short course checked by the simulator.
See the trackRobotics track
Motors, servos, sensors and PID control loops, then a rover, a claw machine and a balance bot, every lesson checked on a simulated board.
See the track