Learn Embedded & Single-Board Computers — from newbie to expert

A guided path into the small computers that run the physical world. Learn what embedded systems and single-board computers are, choose and set up a board of your own, run it headless like a pro, connect it to hardware, keep it alive 24/7 — and finish by building the classic GopherTrunk project: a Raspberry Pi scanner appliance that decodes trunked radio around the clock.

Start lesson 1 →Jump to glossary

Most of the computers around you don’t look like computers. They live inside routers, thermostats, cars, and radios — small boards doing one job, all day, with nobody watching. This module is about those machines: what embedded systems and single-board computers are, how to choose one, and how to run one like a tiny, reliable server. The destination is concrete: by the end you’ll know how to build the classic GopherTrunk project — a Raspberry Pi that decodes trunked radio around the clock.

Who this is for. Anyone who has heard of the Raspberry Pi and wondered what people actually do with one — or who has a project (like a radio scanner) that wants a dedicated, always-on home. It assumes no hardware background; a little command-line comfort helps, and the Linux & the Command Line module fills any gaps. It pairs naturally with Computer Hardware (the wider hardware landscape) and RF & SDR (the radio side of the final build).

How the path works. Six units take you from “what even is an embedded system?” to a finished appliance. Unit 1 maps the small-computer landscape — SBCs, microcontrollers, and the ARM chips inside them. Unit 2 covers the buying decisions: boards, storage, power, and cooling. Unit 3 teaches headless Linux — flash a card, SSH in, run services. Unit 4 connects the board to the physical world through GPIO, USB, and the little serial buses. Unit 5 is reliability engineering: heat, SD-card wear, watchdogs, backups, and monitoring. Unit 6 puts it all together as the GopherTrunk appliance — an ARM build of the daemon, an RTL-SDR on USB, and a web console on your LAN. Mark lessons complete as you go — your progress is saved in your browser. New here? Start with lesson 1: What is an embedded system?

Unit 1 — The Small-Computer Landscape

Embedded systems, single-board computers, microcontrollers, and the chips inside them.

  1. What is an embedded system? Computers hidden inside things — what makes a system "embedded," and why most of the computers you own don't look like computers. beginner 8 min
  2. SBC vs microcontroller vs PC Raspberry Pi, Arduino, and a desktop solve different problems — the capability ladder and how to pick the right rung. beginner 8 min
  3. ARM and the system-on-chip One chip carrying CPU, GPU, memory controller, and I/O — why ARM SoCs power nearly every small board. beginner 8 min
  4. Why the Raspberry Pi? Price, community, and software support made the Pi the default SBC — what the ecosystem gives you and where rivals win. beginner 7 min
  5. Operating systems for small boards Most boards run real Linux — what a Pi OS image contains, and how it differs from the Linux on a server or laptop. beginner 7 min

Unit 2 — Choosing Your Hardware

Boards, storage, power, and cooling — the buying decisions that make or break a build.

  1. Picking a board RAM, CPU cores, USB bandwidth, and connectivity — matching a board's spec sheet to the job you're actually giving it. beginner 8 min
  2. Storage & SD cards SD cards, USB drives, and SSDs — speed classes, endurance, and why storage is the most common weak link. beginner 7 min
  3. Power supplies Undervoltage is the classic mystery failure — amps, volts, cable quality, and powering a board that also powers peripherals. beginner 7 min
  4. Cases & cooling Heatsinks, fans, and airflow — keeping a small board cool enough to run at full speed in a closed box. beginner 7 min
  5. When you need more than a Pi Signs your project has outgrown an SBC — and the step up to mini PCs and small servers when it has. beginner 7 min

Unit 3 — Headless Linux on a Board

No monitor, no keyboard — flash it, find it, SSH in, and run services like a server.

  1. Flashing an OS image Write an operating system onto an SD card, preconfigure Wi-Fi and SSH, and boot a board you'll never plug a monitor into. beginner 8 min
  2. First boot & SSH Find the board on your network and log in over SSH — the moment your SBC becomes a tiny server. beginner 8 min
  3. Users, permissions & updates Change default passwords, create your own user, and keep packages patched — basic hygiene for an always-on device. beginner 7 min
  4. Services with systemd Turn a program into a service that starts at boot and restarts on failure — the unit file every appliance is built on. intermediate 9 min
  5. Networking your board Static addresses, hostnames, Wi-Fi vs Ethernet, and reaching a headless board reliably from anywhere on your LAN. intermediate 8 min

Unit 4 — Talking to the Physical World

GPIO, USB, serial buses, and add-on boards — where software meets wires.

  1. GPIO basics General-purpose pins you control from code — inputs, outputs, blinking an LED, and reading a button safely. intermediate 8 min
  2. USB & powered hubs USB is how most real peripherals arrive — bus power budgets, powered hubs, and why flaky USB is usually a power story. beginner 7 min
  3. Serial, I2C & SPI The three little buses that connect chips to computers — what each is for and how to recognize them on a pinout. intermediate 8 min
  4. HATs & add-ons Stackable boards that add radios, screens, relays, and sensors — how HATs identify themselves and share the header. beginner 7 min
  5. Connecting an SDR An RTL-SDR on a Pi is the classic pairing — drivers, USB bandwidth, and testing your dongle from the command line. intermediate 8 min

Unit 5 — Running 24/7

Heat, storage wear, crashes, and remote access — engineering a board you never have to touch.

  1. Thermal throttling A hot board quietly slows itself down — how to see throttling happening and cool your way back to full speed. intermediate 7 min
  2. SD-card wear Flash cells wear out with every write — why logging kills cheap cards, and how to make storage last for years. intermediate 8 min
  3. Watchdogs & recovery Design for the crash you can't prevent — hardware watchdogs, service restarts, and boards that heal themselves. intermediate 8 min
  4. Remote administration Managing a board you can't reach — SSH keys, tmux, remote logs, and safe upgrades over the network. intermediate 8 min
  5. Backups & images An appliance you can re-flash in ten minutes is an appliance you never fear losing — image backups and config exports. intermediate 7 min
  6. Monitoring your board Temperature, load, disk, and service health — lightweight monitoring that tells you about trouble before it becomes an outage. intermediate 8 min

Unit 6 — The GopherTrunk Appliance

Put it all together: a Raspberry Pi that decodes trunked radio around the clock.

  1. Install GopherTrunk on a Pi Get the ARM build running on a Raspberry Pi — install, first config, and your first decoded call on SBC hardware. intermediate 9 min
  2. Tuning for small CPUs Sample rates, channel counts, and decode load — fitting a real-time DSP engine inside an SBC's compute budget. advanced 9 min
  3. USB SDR gotchas Dropped samples, undervoltage resets, and interference from the Pi itself — the SBC-specific SDR failure modes and their fixes. advanced 8 min
  4. Appliance networking & access Reach the web console from any device in the house, keep the daemon private, and expose it safely if you must. intermediate 8 min
  5. A complete appliance build The full recipe end to end — hardware list, OS, service, monitoring, and backups for a scanner that just runs. advanced 10 min
  1. Glossary of embedded & SBC terms Plain-language definitions for every term in the module — embedded system, SBC, microcontroller, SoC, ARM, GPIO, I2C, SPI, HAT, headless, systemd, watchdog, thermal throttling, undervoltage, and more — cross-linked to the lessons.