Glossary

A bus that carries data (and optionally power) on one wire, with each device having a unique 64-bit ID.

A 3.3 V pin that is rated to accept 5 V on its input without damage.

A digit made of seven LED bars that light in patterns to show 0 to 9.

The common UART format: 8 data bits, no parity, 1 stop bit.

A limit that must never be exceeded, even briefly, or the part may be damaged.

Alternating current: current that reverses direction many times a second, as from a wall socket.

A sensor that measures acceleration, including gravity.

The evidence that shows a requirement is met.

How close a reading is to the true value.

The bit after each I²C byte where the receiver pulls SDA low to say "got it"; NACK is leaving it high.

An active buzzer beeps at a fixed tone when powered; a passive one needs a square wave and can play notes.

A signal that means "on" or "asserted" when it is LOW.

A number that names one location in memory.

The & operator, which gives a variable's memory address.

An RGB LED with a tiny chip, chained so each LED in a strip can be set individually.

Pinning a task to one particular CPU core.

Sampling too slowly, so a fast signal looks like a slower, false one.

The rule that a value must start at an address that is a multiple of its size.

The unit of current; one coulomb per second.

A signal that can take any value in a range, like a voltage from 0 to 3.3 V.

The peripheral that measures a voltage and turns it into a number.

The positive side of a diode or LED, where conventional current goes in.

Deciding which of several transmitters gets the bus.

A company, and the ecosystem of boards, software and libraries it started.

Arduino's editor and build program for writing, compiling and uploading sketches.

Arduino's Uno board with a Renesas RA4M1 chip, one of the course's two boards.

Arduino's command-line tool for compiling and uploading.

The actual value passed to a function when it is called.

Arm's family of processor cores for microcontrollers.

A fixed number of values of one type stored side by side, numbered from 0.

The rule letting the compiler change your code however it likes, as long as the observable behaviour is the same.

Storing a new value in an existing variable with =.

Done as one indivisible step, so nothing can see it half-done.

A seller that buys parts directly from the manufacturer, so the parts are genuine.

Total charge per cycle divided by cycle time.

A PWM signal's voltage averaged over a period: the duty cycle times the high voltage.

The 8-bit processor family in older Arduinos such as the Uno R3.

Current flowing backwards into a supply that isn't meant to receive it.

The list of function return addresses on the stack at a crash.

How many bits per second a serial link sends; both ends must agree.

An adjustable lab power source with a current limit you can set.

The formula relating an NTC thermistor's resistance to temperature using one constant, β.

Base 2: writing numbers using only the digits 0 and 1.

A transistor in which a small base current controls a larger collector current.

One binary digit, 0 or 1.

Operators that work on each bit: &, |, ^, ~, << and >>.

The first sketch: turning an LED on and off once a second.

Code that makes the program wait, such as delay(), so nothing else can run.

An installable bundle with the core, toolchain and upload tools for one family of boards.

The part of a board package that maps a board's pin names to the chip's real pins.

The Arduino IDE window for installing and updating board packages.

Bill of materials: the list of every part, with quantity and cost.

A switching regulator that steps a voltage up.

A button that, held during reset, makes the chip start its built-in bootloader instead of your program.

Firmware that crashes during start-up, resets, and crashes again forever.

A small program that runs first at reset and can receive new firmware over USB or serial.

A board with spring-clip holes for building circuits without soldering.

A change to a library that makes existing code stop compiling or working.

A small board that carries one part and brings its pins out to easy-to-wire headers.

A marker that stops the program when it reaches a chosen line, so you can inspect it.

A dip in supply voltage that is too low for reliable operation but not a full power cut.

A circuit that holds or resets the chip when its supply voltage is too low.

A switching regulator that steps a voltage down efficiently.

Passing a copy of a value to a function, so the function can't change the caller's variable.

Eight bits.

Measuring a sensor against known values and correcting its readings.

A robust differential bus used in cars and machines.

A known value placed at the end of a stack, checked to detect overflow.

How much charge a capacitor stores per volt, measured in farads.

A part that stores charge between two plates; it lets changing signals through and blocks steady current.

Treating capital and small letters as different, so pinMode and pinmode are different names.

The negative side of a diode or LED, where conventional current comes out; marked with a band or a flat edge.

The standard USB class that makes a device appear as a serial port with no extra driver.

The channel down the middle of a breadboard that separates the two halves.

A display that shows fixed character cells, such as 16×2 text.

A chip that charges a battery with the right current and voltage.

A value computed from data and sent with it, so the receiver can detect corruption.

A line, usually active-low, that tells one SPI device it is being addressed.

To stop a voltage going above (or below) a limit, usually with a diode.

A user-defined type that bundles data with the functions that work on it.

A copy of an open-hardware board, sold by someone other than the original maker.

An unbroken path from a source's positive side, through the circuit, back to its negative side.

A tool that generates build files for a C++ project from a CMakeLists.txt file.

Coasting lets a motor spin down freely; braking shorts its terminals so it stops quickly.

The three legs of a bipolar transistor: the base controls, the collector and emitter carry the load current.

A saved snapshot of a project's files in git, with a message.

A circuit that outputs HIGH or LOW depending on which input voltage is larger.

The program that translates C++ source code into machine code.

A filter that combines a gyro (good short-term) and an accelerometer (good long-term) to estimate tilt.

Water forming on a surface colder than the air's dew point.

A thin protective film painted over a circuit board.

A C++ keyword marking values or functions that can be computed at compile time.

A special function that runs when an object is created.

The rapid on–off flicker of switch contacts for a few milliseconds as they close or open.

Saving one task's registers and restoring another's so it can run.

Whether two points are electrically connected; the meter mode that beeps when they are.

The agreed direction of current, from + to −, even though electrons actually move the other way.

Running several jobs in turns, where each job does a short step and returns voluntarily.

The software that lets Arduino code run on one family of chips.

A saved copy of memory and registers at the moment of a crash.

The unit of electric charge.

A fake part or board falsely sold under another maker's brand.

The part of a chip that carries out instructions one after another.

An exception the CPU raises when something illegal happens.

A check value computed by polynomial division of the data bits, catching common corruptions.

A short stretch of code during which interrupts (or other tasks) are kept out.

A compiler that runs on one kind of computer and produces code for another.

How much charge flows past a point each second, measured in amperes.

A maximum current a supply will deliver, set so a wiring mistake can't push large current through parts.

A peripheral that turns a number into an output voltage.

A separate flash area meant for storing settings.

What kind of value a variable holds, such as int, float or bool, which sets its size and operations.

The manufacturer's document that specifies a part: pins, limits, guaranteed numbers and behaviour.

How many days a battery must run the device with no charging.

Direct current: current that flows in one direction at a steady voltage, as from a battery.

How many times larger the collector current is than the base current, in the active region.

A short gap when both switches in a bridge leg are off, to prevent shoot-through.

The latest time by which a job must finish.

Two or more tasks each waiting for a lock the other holds, so none can continue.

To ignore the brief flicker of a switch's contacts so one press counts once.

A hardware adapter that connects a debugger on your computer to the chip's debug port.

A line that introduces a name and its type to the compiler.

A small capacitor right beside a chip's power pins that supplies sudden bursts of current.

Low-power modes: light sleep pauses the CPU keeping RAM; deep sleep powers almost everything off and restarts on wake.

The part of the code that actually creates a function or variable.

Something a project or library needs in order to build.

Reducing a rating to allow for real-world losses.

Following a pointer to the value it points to, with *.

Data a USB device sends to describe itself.

A special function that runs automatically when an object is destroyed.

A ready-made board with a microcontroller, USB, power parts and header pins, for learning and prototyping.

The temperature at which air's water vapour starts condensing.

A standard USB mode for loading new firmware onto a device.

Sending a signal as the difference between two wires, so noise affecting both cancels.

A signal treated as one of a few values, usually just HIGH or LOW.

A part that lets current flow one way and blocks it the other.

Hardware that copies data between peripherals and memory without the CPU.

On CAN, a dominant bit (0) overrides a recessive bit (1).

Using two buffers: one fills while the other is processed, then they swap.

An ESP32 boot mode where the ROM bootloader waits for new firmware instead of running yours.

A slow error that builds up over time.

Software that lets an operating system, or your firmware, talk to one particular piece of hardware.

The smallest gap between input and output at which a linear regulator still regulates.

The fraction of each period a signal is HIGH, often given as a percentage.

Waking briefly to work, then sleeping most of the time.

The standard set of twelve resistor values per decade: 10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82.

Non-volatile memory that can be written a byte at a time; often emulated in flash.

How much time has passed since a saved moment: now minus then.

The property of electrons and protons that makes them push and pull on each other; measured in coulombs.

The datasheet tables that give a part's guaranteed voltages, currents and timings.

A high-value, polarized capacitor that must be wired the right way round.

A sudden spark of static electricity, which can damage chips.

The linker's output file: machine code plus addresses and debug information.

A computer built into a device to do one job, rather than a general-purpose computer.

The capacity to do work; power multiplied by time.

Scientific notation with the power of ten always a multiple of three, matching SI prefixes.

A type whose values are a list of named constants.

The process where a USB host asks a new device what it is and loads a driver.

The single resistance that could replace a group of resistors without changing the current drawn.

Espressif's official development framework for ESP32 chips, built on FreeRTOS.

A Wi-Fi and Bluetooth microcontroller from Espressif, one of the course's two boards.

Espressif's development board for the ESP32-S3, one of the course's two boards.

The number a command-line program returns when it finishes: 0 for success, anything else for failure.

A filter that blends each new reading with the previous output: y = y + α(x − y).

A piece of code that produces a value, such as a + b * 2.

A stand-in implementation of an interface for testing.

When a switch case without break runs on into the next case.

The unit of capacitance.

A group of bits inside a register that together hold one setting.

The region of code where a name can be used.

A design where the program is always in one of a few named states and events move it between them.

The program stored in a device's flash memory and run by its microcontroller.

Integer types with an exact size, such as uint8_t and int32_t.

Memory that keeps its contents without power; it holds the program.

An input pin connected to nothing that drives it, so it reads randomly.

A number type that stores a value with a fractional part, with limited precision.

Hardware that does floating-point arithmetic quickly.

A chemical in solder that cleans metal so the solder wets and bonds.

A diode across a coil that gives its current a safe path when it is switched off.

The roughly fixed voltage across a diode or LED while it conducts.

Free memory broken into small scattered holes, so a large request fails.

One character as a UART sends it: a start bit, the data bits, an optional parity bit and a stop bit.

A block of RAM holding one bit or value per pixel, drawn into and then sent to the display.

A widely used open-source RTOS, built into the ESP32's software.

How many cycles a repeating signal completes each second, measured in hertz.

The exact name a tool needs to choose a board, in the form packager:architecture:board.

A named block of code that does one job and can be called from elsewhere.

A part that breaks the circuit when too much current flows.

The three legs of a MOSFET: the gate controls, the drain and source carry the load current.

The gate voltage at which a MOSFET just begins to conduct, not where it is fully on.

The GNU debugger.

A key that reads as pressed when it isn't, caused by three keys pressed in a rectangle in a matrix.

A version-control program that records snapshots of a project's files.

A variable declared outside every function, visible to all of them and alive the whole time.

General-purpose input/output: a pin firmware can set high or low, or read.

The reference point in a circuit, defined as 0 V, that other voltages are measured from.

A sensor that measures rotation rate.

Four switches around a motor that let firmware drive it in either direction.

A sensor that detects a magnetic field.

Hard: a missed deadline is a failure. Firm: a late result is useless. Soft: lateness only degrades quality.

Hiding hardware details behind a simple interface.

A file of declarations, usually ending in .h, that other files include to use its code.

Memory handed out at run time with new/malloc and returned with delete/free.

The unit of frequency; one cycle per second.

Base 16: digits 0 to 9 and A to F, a short way to write binary.

The USB device class for keyboards, mice and game controllers.

An output that is effectively disconnected, neither HIGH nor LOW.

The most stack a task has ever used (or the least ever left free).

A switch placed between the supply and the load.

Your own computer, where you write, build and test code.

A unit test compiled for and run on your computer, not the board.

Using two thresholds, a higher one to switch on and a lower one to switch off, so noise near one threshold can't cause chatter.

A serial bus for digital audio.

Behaviour the C++ standard leaves to each compiler to choose and document, such as the size of int.

Connected across the same two points, so the parts share one voltage.

Connected one after another in a single path, so the parts carry the same current.

A current and voltage monitor chip with an I²C interface.

How strongly a coil opposes a change in its current, measured in henries.

A coil of wire that resists changes in its current.

A sensor package with an accelerometer and a gyroscope (sometimes a magnetometer).

Giving a variable its first value when it is created.

A timer feature that records the count when an input edge arrives.

The set of machine instructions a processor family understands.

A text file format for firmware that stores bytes as hex with their addresses.

What a module offers to other code: its functions and types, without the details of how they work.

A hardware signal that pauses the main program to run a handler right away.

The function that runs when an interrupt fires.

A two-digit rating for how well an enclosure keeps out dust and water.

No electrical connection between two circuits, even though one controls the other.

A two-wire bus (SDA and SCL) that connects many chips, each with its own address.

The 7-bit number that picks one chip on an I²C bus.

Variation in timing from one cycle to the next.

A standard debug interface for halting a chip and inspecting it.

A point where three or more wires meet, drawn as a solid dot.

A filter that combines a model and noisy measurements, weighting each by its uncertainty.

The large voltage spike a coil makes when its current is switched off suddenly.

At any junction, the current flowing in equals the current flowing out.

Around any closed loop, the voltage rises and drops add up to zero.

The delay a filter adds between a change and its appearance in the output.

A storage stage that holds outputs steady while new data shifts in, then updates them all at once.

The delay between an event and the response.

A low-dropout linear regulator, which works with the input only slightly above the output.

A diode that gives off light when current flows through it the right way.

The ESP32's PWM peripheral, originally for LED control.

A circuit that translates signals between two logic voltages, such as 3.3 V and 5 V.

Rechargeable lithium cells.

Reusable code for a task or a chip that you add to a project instead of writing it yourself.

The Arduino IDE tool for finding and installing libraries.

The time during which a variable exists in memory.

A part whose current is proportional to its voltage, like a resistor; non-linear parts such as LEDs are not.

A regulator that drops excess voltage across a transistor, turning it into heat.

The program that joins object files and libraries into one finished program.

The file that tells the linker where flash and RAM are and which sections go where.

Storing a multi-byte number with its lowest byte first.

A tool that records many digital signals over time so you can see and decode them.

The voltage ranges a digital input counts as HIGH or LOW.

A MOSFET that turns fully on from a 3.3 V or 5 V pin.

&& (and), || (or) and ! (not), which combine true/false conditions.

A switch placed between the load and ground.

The smallest step an ADC can tell apart; also the lowest bit in a number.

The unit of illuminance: how much light falls on a surface.

A fixed value at the start of a record that marks where it begins.

A report from the linker showing where every function and variable was placed and how big it is.

A value whose 1 bits select which bits of another value an operation touches.

Code built permanently into the chip during manufacturing, which can't be erased.

Buttons wired in a grid of rows and columns, read by scanning.

Short for microcontroller unit.

A chart of what lives at each address range.

A named region of the program image: .text for code, .data for initialized variables, .bss for zeroed ones.

Controlling hardware by reading and writing special memory addresses.

A sensor with a heated metal-oxide layer whose resistance changes with gases.

When connecting a meter (or a load) changes the very voltage you are measuring.

A whole small computer on one chip: processor, memory and input/output.

A processor chip that needs separate memory and support chips, as in a PC or a Raspberry Pi.

A small version of Python that runs on microcontrollers.

Dividing each full step into smaller ones by partly energizing both coils.

A battery capacity unit: how many milliamps for how many hours.

A small shielded board holding a chip, its flash, crystal and antenna, ready to solder onto a larger board.

A switch that is only on while you press it, like a pushbutton.

A transistor switched by the voltage on its gate, used to switch loads from a pin.

A chip containing H-bridges and protection, controlled by logic pins.

The average of the last N readings, updated with each new one.

A handheld meter that measures voltage, current, resistance and continuity.

Sharing pins by lighting or reading one group at a time, fast enough to seem simultaneous.

A lock that lets only one task use a shared resource at a time.

Minimum viable product: the smallest version that does the core job.

A MOSFET that turns on when its gate is driven above its source; the usual low-side switch.

USB handled directly by the microcontroller itself, with no separate bridge chip.

A set of points that are all wired together, so they share one voltage.

Four bits, half a byte, one hex digit.

A point in a circuit where parts meet; everywhere on a node has the same voltage.

Random, unwanted variation in a signal or reading.

How much noise a digital signal can pick up and still be read correctly.

A battery's typical voltage during discharge.

Memory that keeps its contents without power.

Describes a switch or relay contact's state when it is not pressed or energized.

The common kind of bipolar transistor, switched on by current into its base.

The zero byte that marks the end of a C string.

The ESP32's key-value storage in flash.

Twice the highest frequency in a signal: the minimum sample rate to capture it.

The compiled machine code for one source file, not yet linked.

A loop or index that runs one time too many or too few.

Offset is a constant error added to every reading; gain is a scale error.

The unit of resistance.

For a resistor, voltage equals current times resistance: V = IR.

A display whose pixels each give off their own light.

A fully-on MOSFET's resistance from drain to source.

An output that can only pull LOW; a pull-up resistor makes it HIGH.

Open-source software connecting GDB to a debug probe.

The software that manages a computer's programs, files and hardware, such as Windows or Linux.

An LED and a light sensor in one package, passing a signal across an isolation gap.

An instrument that draws voltage against time, showing a signal's exact shape.

A pointer or reference parameter through which a function hands back a result.

When a result is too big for its type.

New data arriving before old data has been read, so some is lost.

Unused bytes the compiler adds inside a struct to keep members aligned.

A named input in a function's definition.

Powering a 1-Wire device from its data line.

An extra bit that makes the count of 1s even or odd, to catch single-bit errors.

A map that divides an ESP32's flash into areas for the app, settings and other data.

The useful data in a message, as opposed to its header and check value.

Daily solar energy expressed as hours of full 1000 W/m² sun.

The time one full cycle of a repeating signal takes.

A built-in hardware block on a chip that handles one job, such as a timer or a serial port.

A resistor whose resistance falls as light increases.

A ceramic element that flexes with voltage, making sound.

Recording the exact version of a library or board package a project uses, so builds repeat.

A build system and VS Code extension for embedded projects, configured by a platformio.ini file.

A variable that holds a memory address.

Having a + and a − side, so it only works connected one way round.

A switch's poles are separate circuits it switches; throws are the positions each pole can connect to.

Checking repeatedly whether something has happened.

A resettable fuse that goes high-resistance when overloaded and recovers when it cools.

The formal name for voltage between two points.

A knob that is a resistor with a sliding middle contact, used as an adjustable voltage divider.

How fast energy is used or delivered, measured in watts.

A table of each state's current and time, giving the average current.

A long strip along the edge of a breadboard, used to share the supply and ground.

The most power a part can safely turn into heat.

How close repeated readings of the same thing are to each other.

Scheduling where the system can interrupt a running task to run a more urgent one.

A letter in front of a unit that multiplies it by a power of ten, like the k in kΩ.

The first stage of compiling, which handles lines starting with # such as #include and #define.

A line starting with # that gives the preprocessor an instruction, such as #include.

A divider that slows a clock before it reaches a timer.

A number that decides which ready task runs first.

Temporarily raising a low-priority task that holds a mutex to the priority of a higher task waiting for it.

A high-priority task stuck waiting while a medium task runs, because a low task holds its lock.

The time from an input change to the output's response.

A small board on a lithium cell that cuts off over-charge, over-discharge and short circuit.

The agreed rules for how two devices format and exchange messages.

A function's declaration, written before it is used so the compiler knows its signature.

Extra RAM on some ESP32 modules, outside the chip itself.

A resistor to ground that holds a pin or gate low when nothing else drives it.

A resistor to the supply that holds a pin high until something pulls it low.

Switching a pin on and off quickly; the fraction of time on sets the average power or voltage.

Free, open-source software for capturing and decoding logic-analyzer signals.

An output that actively drives both HIGH and LOW.

Two signals a quarter cycle apart, whose order shows direction.

A first-in, first-out channel for passing items between tasks.

The current a regulator uses itself, even with no load.

A bug where the result depends on the exact timing of two tasks or interrupts touching shared data.

Resource Acquisition Is Initialization: an object takes a resource in its constructor and releases it in its destructor.

Fast working memory that is lost when power goes off.

A measurement that uses the same voltage for the sensor and the ADC reference, so supply changes cancel out.

A resistor and a capacitor together, which charge or discharge over a predictable time.

Correct only if the result arrives on time, not just if it is right.

The ranges inside which a part is guaranteed to work as specified.

A small, numbered storage location inside a chip, often wired to hardware.

An electrically operated switch: a coil moves contacts that switch a separate circuit.

A project folder whose full history git tracks.

A testable statement of what the device must do.

Restarting the microcontroller from the start of its firmware; also the button that does it.

The first code that runs after reset: it sets up memory then calls main.

How strongly something opposes current; measured in ohms.

A part made to have a known resistance, used to limit current or set voltages.

The number of bits an ADC uses, which sets how many steps it divides its range into.

How long a filter's or sensor's output takes to settle at a new value after its input changes.

A diode connected so it blocks: the cathode is more positive than the anode.

A fixed-size buffer whose end wraps around to its start, used as a queue.

The small leftover wobble on a voltage that should be steady.

An open instruction set, used by newer chips such as the ESP32-C3.

How long a signal takes to go from LOW to HIGH.

The moment a digital signal changes level: a rising edge goes LOW to HIGH, a falling edge HIGH to LOW.

A sensor that reports rotation as pulses.

A differential serial standard for long cables and many devices.

A small operating system that runs several tasks by priority with predictable timing.

An independent thread of execution with its own stack, run by an RTOS.

The RTOS's regular timer interrupt, which counts time.

The state outputs go to when inputs can't be trusted.

A reduced start-up that disables risky features after repeated crashes.

How many measurements per second an instrument or ADC takes.

A transistor turned fully on, acting like a closed switch with only a small voltage across it.

The code that decides which job or task runs next.

A diagram that shows how parts connect electrically, using standard symbols.

An input or comparator with hysteresis, which turns a slow, noisy edge into one clean switch.

A fast diode with a low forward voltage, about 0.3 V.

Writing a number as a value times a power of ten, like 4.7 × 10⁻⁶.

A place where code can be swapped for a test without changing it.

On an ESP32, the bootloader in flash that the ROM bootloader starts, which then finds and starts your application.

A sensor warming itself with its own current, so it reads high.

A version numbering rule, MAJOR.MINOR.PATCH, where each number says what kind of change was made.

A signalling object: one task or ISR gives it, another takes it.

A counter stored with each record so the newest can be found.

Sending data one bit after another over a single wire, rather than many bits at once.

A window that shows text a board sends over serial and lets you send text back.

A tool that graphs numbers a board prints over serial.

The name the operating system gives a board's serial connection, such as COM6 or /dev/ttyACM0.

A motor with built-in position control, set by the width of a pulse.

Setup time is how long data must be steady before a clock edge; hold time is how long after.

A chip that converts serial bits to parallel outputs, or parallel inputs to serial bits.

Both switches on one side of an H-bridge on at once, shorting the supply.

An accidental low-resistance path, usually straight across a supply, that lets far too much current flow.

A small resistor in series with a supply, whose voltage drop measures current.

One of the standard international units, such as the volt, ampere, ohm and second.

A number type that can hold negative values.

A queue with exactly one writer and one reader, which can be made safe without locks.

A pin sources current when it drives HIGH and current flows out; it sinks current when it drives LOW and current flows in.

Arduino's name for a program.

Running tasks on two or more identical cores that share memory.

A relay with no moving parts, switching a load with semiconductors controlled by light.

A .cpp (or .c) file containing definitions, compiled on its own.

About 343 m/s in air at 20 °C, rising about 0.6 m/s per degree.

A fast four-wire bus with a clock, two data lines and a chip-select per device.

The clock polarity and phase settings both sides of SPI must agree on.

A lock that waits by looping, used between two CPU cores.

Static RAM: the fast working memory inside a microcontroller.

Memory that grows and shrinks as functions are called and return, holding locals and return addresses.

The block of stack one function call uses.

Using more stack than was reserved, so it overwrites other memory.

A CPU register that holds the address of the top of the stack.

The large current a motor draws when it is starting or held still.

The bits that mark the start and end of each byte on a UART line.

A drawing of a state machine: circles for states, arrows for transitions.

One complete instruction in C++, usually ending with a semicolon.

A variable inside a function that keeps its value between calls.

A fixed block of memory set aside at build time and handed out in fixed-size pieces.

A compile-time check that stops the build with a message if a condition is false.

A value a function returns to say whether it worked, and if not, why.

A motor that moves in fixed steps, controlled by energizing its coils in sequence.

A pin whose level at reset chooses a chip's boot mode or settings.

Text written in double quotes in the code, such as "hello".

A type that groups several named values into one.

The ADC method that finds the code one bit at a time, from the top bit down, like a binary search.

The basic firmware structure: set up once, then repeat one loop forever.

Arm's two-wire debug interface (SWDIO and SWCLK).

A regulator that switches rapidly and stores energy in an inductor, wasting little as heat.

A single chip that holds a processor plus radios, memory and peripherals.

The small square four-legged pushbutton used on breadboards.

A name attached to one commit, such as a release version.

The board or chip the firmware is being built for.

Code written with a placeholder type, which the compiler stamps out for each type used.

A row of five connected holes on a breadboard.

How many degrees a part heats up per watt it dissipates.

A resistor whose resistance changes with temperature.

For a resistor and capacitor, τ = RC: the time to cover 63 % of the way to the final voltage.

A sensor that measures distance by timing light.

A peripheral that counts clock ticks and can trigger events or generate PWM.

A recorded time at which something happened.

A drawing of signals against time, showing what changes when.

An open-source USB stack for microcontrollers.

How far a part's real value may be from its marked value, as a percentage.

The set of programs that turn source code into firmware on a board.

Reading a value while it is half-updated, getting a mix of old and new.

A write cut short by power loss, leaving data half old and half new.

A pad that detects a finger by the capacitance it adds.

A table pairing each requirement with the test that proves it.

A chip that converts between a microcontroller's logic signals and a bus's electrical signals.

A semiconductor part that lets a small signal control a larger current; used as a switch or an amplifier.

A table listing, for each state and event, the next state and any action.

A dependency of a dependency.

A condition that tells a scope or logic analyzer when to start showing a capture.

A diode that clamps short voltage spikes, such as static discharges, on a line.

The way computers store negative integers: invert the bits and add one.

A device's transmit and receive pins; one device's TX connects to the other's RX.

The hardware that sends and receives bytes one bit at a time over a TX and an RX wire.

Linux settings that decide who may open a device such as a board's serial port.

A sensor that measures distance by timing an echo of a sound pulse.

Code the C++ standard places no rules on, such as reading past an array; anything may happen.

An automatic check that one small piece of code gives the expected result.

A number type with no negative values, so all its bits count upward from zero.

Copying compiled firmware from your computer into a board's flash memory.

USB On-The-Go: a port that can act as either device or host.

A fixed USB block on the ESP32-S3 that gives both a serial port and a JTAG debug link over one cable.

A small chip that turns USB from the computer into the TX/RX serial a microcontroller understands.

A named piece of memory that holds a value of one type.

A table of addresses at the start of flash: the initial stack pointer, then the address of each handler.

A member function chosen at run time based on the object's actual type.

A C++ keyword telling the compiler every read and write of a variable must really happen.

The unit of voltage.

The electrical push between two points, measured in volts.

Two resistors in series across a supply; the point between them gives a fixed fraction of the supply voltage.

The voltage across a part that current flows through.

The most voltage a part, such as a capacitor, may ever have across it.

A part that turns a varying input voltage into a steady output voltage.

A table of function pointers that virtual calls go through.

An event that wakes the chip from sleep.

A timer that resets the chip unless the firmware keeps resetting it.

A debugger stop that triggers when a memory location is read or written.

The unit of power; one joule per second.

A unit of energy: one watt used for one hour.

Spreading writes across flash so no block wears out early.

The sliding middle contact of a potentiometer.

The longest a loop can take to notice an input.

When a counter passes its maximum and starts again from zero.

Writing new data to a spare slot and only then marking it current, so power loss never leaves nothing valid.

The processor architecture used by the ESP32 and ESP32-S3.

A diode made to conduct backwards at a set voltage, used to clamp a voltage.

A feature that costs nothing extra at run time compared with writing it by hand.