← Connected Devices and the Internet of Things

Prerequisites & knowledge map

Everything below is a concept Connected Devices and the Internet of Things leans on that ISN'T taught inside the course itself — not the whole of another course, just the specific skills.

Embedded Systems and the Internet of Things

Applying Kirchhoff's voltage and current laws to check or solve a circuit

required
Choosing a board for a project by voltage, memory, radio, USB, ecosystem, power and price

required
Choosing between polling and interrupts by latency, missed events and power

required
Choosing integer types by width on 8-bit vs 32-bit microcontrollers, and spotting overflow

required
Choosing switch types, reading a potentiometer as a divider, and recognizing contact bounce

required
Compiling a sketch for a chosen board and uploading it over USB

required
Computing an RC time constant and using the 63% and 5τ rules for delays and debouncing

required
Computing and choosing resistors for a voltage divider's output

required
Debouncing a button in firmware with a time window or a state change

required
Deciding when dynamic allocation is safe, and using static pools when it isn't

required
Declaring variables and constants of the basic C++ types

required
Describing current as the flow rate of charge, in conventional-current direction

required
Designing a finite state machine with states, events and transitions, and coding it table-driven

required
Explaining how setup() and loop() run, and the main() the Arduino core supplies

required
Explaining what a capacitor stores, polarity, and why every chip gets a decoupling capacitor

required
Explaining why delay() makes a sketch miss inputs

required
Finding equivalent resistance, and the current and voltage of each part, in series and parallel

required
Following a sketch through preprocessor, compiler and linker to an ELF and a flashable .bin/.hex

required
Grouping data with structs and enums, and choosing fixed-width types for hardware

required
Handling text with char arrays and snprintf, and why String fragments a small heap

required
Installing cores and compiling and uploading from the command line with arduino-cli and an FQBN

required
Installing the Arduino IDE, adding a board package (core), and selecting board and port

required
Naming the parts of a development board: MCU, regulator, USB bridge or native USB, crystal, buttons, headers

required
Passing data from an ISR to a task with a single-producer single-consumer ring buffer

required
Placing parts on a breadboard using its connected rails and strips

required
Reading a chip's memory map: flash, SRAM and peripheral registers

required
Reading a schematic's symbols, nets, supply and ground, and matching it to a breadboard

required
Reading and converting SI prefixes and units: milli, micro, kilo, mega, and component markings like 4k7

required
Reading and writing memory-mapped registers through volatile pointers

required
Reading bits, bytes, and hexadecimal as register values

required
Running several timers and state machines in one loop as a tiny cooperative scheduler

required
Setting, clearing, toggling and testing bits with masks and shifts

required
Telling a microcontroller from a microprocessor and a computer, and firmware from an application

required
Telling an ecosystem (Arduino), a chip family (ESP32), a chip, a module, and a dev board apart

required
Telling stack, heap and static storage apart and detecting stack overflow

required
Timing with millis() and rollover-safe unsigned subtraction

required
Tracing what runs at power-on: reset vector, startup code, .data/.bss setup, then main

required
Treating voltage as a difference between two points, measured against ground

required
Using V = IR to find a missing voltage, current, or resistance

required
Using arithmetic, integer division, comparison, logical and compound-assignment operators

required
Using pointers as memory addresses, and arrays as pointers to their first element

required
Using zero-based arrays safely, and telling local, global and static variables apart

required
Writing and calling C++ functions with parameters and return values

required
Writing if/else, switch, while and for, and breaking out of a loop

required
Writing short, safe interrupt handlers with volatile shared state and critical sections

required