Quite a number of us have worked with the Arduino board, the OG Goat, to get started with robotics. Tinkering with DC motors, LED bulbs, and breadboards was what got us interested in engineering. But that was in the past. Now, there's a whole new class of computers we can mess around with, tools that can be used for anything from building drones to industrial robots. These are called Single Board Computers, or SBCs. These compact powerhouses have carved out a unique space between hobby electronics and full-fledged PCs, offering just enough horsepower and flexibility to tackle a wide range of real-world challenges.

This blog is the first in a series about SBCs, where we will look under the hood to understand what makes these boards tick, their hardware and architecture, how to program them and why they've become such a popular choice in embedded systems.

By the end of this series, you'll not only understand how SBCs work — you'll be building firmware by yourself.

We will be writing our own bootloader for Raspberry Pi.

That sounds cool, doesn't it?

Well, you need to stick around till the end for that.

We will start with an introduction to SBCs, then discuss hardware and firmware components, do a case study to learn about it in detail, and finally, do our little project.

So let's get started.

What are these 'SBCs'?

Single Board Computer - Embedded | Hartmann Electronic

Imagine having the brain of a whole computer — processor, memory, storage, and input/output ports — all squeezed onto a board no bigger than your hand. That's what a Single Board Computer (SBC) is. It's a compact, self-contained computer that can run operating systems like Linux or Android and power everything from smart doorbells to autonomous robots.

Wait, why does that sound similar to an Arduino board? It can also be used to run toy cars, and doorbells and what not.

Well, not quite. SBCs are much more capable than a microcontroller board like Arduino. They integrate core computing components (CPU, GPU, RAM, I/O) onto a single circuit board, essentially serving as a bare-bone microprocessor connected to essential peripherals.

Microcontroller? Microprocessor? Peripherals?

Let me explain.

Microcontroller vs Microprocessor

Difference Between Microprocessor and Microcontroller

When you're first exploring embedded systems, the terms microcontroller and microprocessor can sound confusing — almost interchangeable. But once you start working with them, the distinction becomes clear.

Microcontrollers (MCUs): The All-in-One Workhorses

A microcontroller is like a complete kitchen appliance — a compact, self-contained unit that has everything it needs to do a specific job. It comes with:

A CPU to run instructions
A small amount of RAM for temporary data
Flash memory to store the code
Built-in I/O interfaces like digital pins, UART, SPI, I2C, and timers

Microcontrollers are built for deterministic, real-time control. That means they're great at doing things like blinking LEDs, reading sensor values, or driving motors with precise timing. They usually run without an operating system (bare-metal) and you'll find them in everything from washing machines to wearable fitness trackers.

Think Arduino, STM32, or ESP32 — simple, robust, reliable. These are the development boards made using the microcontroller chip which is present in them. Eg- THe Atmega 328P is the microcontroller which is used in the Arduino Devkit.

A thing to note - The Atmega chip in itself is a complete programmable unit. We can remove it from the arduino board, and program it seperately on a breadboard, and use it for a new function. This is because this chip is a microcontroller - it has everything it needs to work independently.

Microprocessors (MPUs): The Brains Behind Full Systems

A microprocessor, by contrast, is like the chef in a professional kitchen — incredibly capable, but totally dependent on external tools and ingredients.

An MPU only contains the CPU core. To function, it needs:

External RAM and flash/storage
A power management unit (PMU)
Peripheral controllers (i.e. device which extends its capabilities, eg: input device like a keyboard)
A motherboard or PCB that connects all these parts together.

Microprocessors are designed for high-level computing. They support complex operating systems like Linux or Windows and can handle multitasking, memory management, and networking. That's why they're used in smartphones, desktops, and tablets — anywhere you need serious processing power.

The intel core chip in your laptop - that's a microprocessor. It cannot function independently without the RAM, flash, oscillators, hardware modules, etc.

Now, enter the Single Board Computer — the all-in-one toolkit.

An SBC is essentially a complete computer system (a development board) built around a microprocessor. It includes:

A powerful MPU (usually an ARM-based SoC)
RAM soldered directly onto the board
Flash storage (microSD card)
Built-in networking, USB, HDMI, and audio ports, along with GPIO headers.
A power supply circuit, crystal oscillator, and other supporting chips

All of this is integrated onto a single PCB, hence the name "single board."

This setup allows SBCs to run whole operating systems like Ubuntu while still being small and power-efficient enough to fit into drones, robots, or smart devices.

Key Characteristics of Single-Board Computers

Now that we have covered the 'what', let's move on to the 'how'.

Let's dive deep into the technical architecture and engineering principles behind SBCs. We'll examine how their design impacts performance, energy efficiency, and versatility.

Compact Form Factor

Form factor (design) - Wikipedia

SBCs are designed to pack an entire computer into a tight, efficient layout.

Surface-Mount Devices (SMDs) such as 0402 resistors keep the board flat and compact.
Most modern SBCs use 4 to 8-layer PCBs, where multiple copper layers allow routing high-speed signals lwith minimal interference (crosstalk) and consistent impedance.
For instance, the Raspberry Pi 5 uses a 6-layer PCB with impedance-controlled traces, which is essential for high-speed interfaces like HDMI 2.0 that run up to 18 Gbps.
Microcontrollers use simple 2–4 layer PCBs with low-speed signals, so they can't support high transfer speeds without more stacking, which would increase the device size.

System-on-Chip (SoC) Integration

The heart of an SBC is its System-on-Chip (SoC) — a highly integrated chip that combines many functions that would otherwise be spread across multiple components in a desktop PC. They integrate CPU, GPU, memory controllers, and peripherals (e.g., Broadcom BCM2712 in Raspberry Pi). This reduces board complexity and power consumption.

Microcontrollers integrate CPU, flash memory, SRAM, and basic peripherals (ADC, PWM) but lack advanced interfaces like HDMI/USB (e.g., STM32, Arduino Uno).

We will look more into the hardware aspects of SBC and SoC in the upcoming blogs.

Software Flexibility

SBC runs full-featured operating systems, typically Linux. An OS provides Process scheduling (multitasking), Virtual memory (address isolation), File systems (ext4, FAT32, etc.), Device drivers (for USB, Wi-Fi, GPIO, camera, etc.), Networking stacks (TCP/IP, HTTP). Its main memory is also relatively large (>4GB).

All these features mean that it can perform tasks far beyond that of an Arduino.

Let's look at it with an example.

OpenCV (Open Source Computer Vision Library) is a powerful open-source library for real-time image and video processing. It's used in Object detection and tracking, Facial recognition, Image filtering and transformation, etc.

Let's say you're using a Raspberry Pi 4. It supports:

A full Linux OS complete. Raspberry Pi OS, Ubuntu)
Python and C++ compilers/interpreters
Camera interfaces (CSI, USB)
Enough RAM (1–8 GB) to handle large image matrices
Virtual Memory and Memory Management Unit
Multithreading and Multiprocessing
Large enough CPU cache

These are the requirements that need to be fulfilled to use OpenCV.

Arduino (Uno, Mega, Due) is based on AVR or Cortex-M microcontrollers that:

Have no OS — just a loop-based firmware model
Lack MMUs - no virtual memory or multitasking
Have severely limited RAM (2 KB – 96 KB)
Have no file system or dynamic memory allocation support
Cannot run Python or C++ standard libraries
No USB host or camera drivers

Even the smallest image OpenCV might process (e.g., 320×240 grayscale) requires:

76,800 bytes of RAM = far more than Arduino has
Floating-point and matrix operations = not supported in hardware
USB webcam or CSI input = requires Linux drivers and V4L2 stack

So, running OpenCV on Arduino isn't just "difficult" — it's architecturally impossible.

Power Management

When it comes to embedded design, power isn't just a spec — it's a constraint. Understanding how power is managed can make or break your system.

Microprocessors like the ARM Cortex-A76 or Intel Core i5 are just the CPU core — they don't manage their own power. In a typical PC or custom embedded board, power regulation and state control are handled externally by:

Power Management ICs (PMICs) are designed into the motherboard.
Custom firmware/BIOS configurations that trigger sleep states (S-states).

This makes microprocessors highly flexible — but it also means you're on your own when it comes to managing energy. Want your system to sleep? You'll need to configure deep sleep states through ACPI or custom PMIC logic. Need voltage scaling? That's another driver you'll write.

SBCs prioritize energy efficiency and integration for always-on, low-power applications with inbuilt hardware and firmware:

Integrated PMIC (e.g., Raspberry Pi uses a Dialog DA9091) controls core (1.2V), I/O (3.3V), and USB (5V) rails.
Dynamic Voltage and Frequency Scaling (DVFS):
- Adjusts CPU/GPU frequency based on workload.
- Example: Cortex-A72 in Raspberry Pi scales from 600 MHz to 1.5 GHz.
Clock Gating: Unused cores and peripherals (USB, HDMI) are clock-gated or shut off completely.
Thermal Throttling: If temps go beyond the threshold (e.g., 80°C), clock speeds are reduced to protect the SoC.
Idle & Sleep States: Pi boards enter low-power idle (~0.5W) when the CPU load drops

Why It Matters

SBCs excel in battery-powered or embedded systems where energy efficiency is critical (e.g., solar-powered IoT).
Microprocessors dominate high-performance tasks but require complex power delivery and cooling.

I hope this section has given you a comprehensive understanding of what architectural and design decisions give SBCs their capabilities.

Examples

Let's look at a few common SCBs before we wrap it up.

Raspberry pi

The Raspberry Pi series is arguably the most well-known SBC globally, thanks to its accessibility and vast community support. Developed by the Raspberry Pi Foundation, it was initially designed to teach basic computer science. Today, it's used in various applications, from IoT projects to home automation and even AI-driven solutions. The latest models, such as the Raspberry Pi 4 and Raspberry Pi 5, come equipped with multicore ARM CPUs, support up to 8GB of RAM, and provide extensive GPIO and I/O options. This versatility makes them popular for both hobbyists and professionals.

Nvidia Jetson Nano

The NVIDIA Jetson Nano is a standout SBC for AI and machine learning projects. With an integrated GPU designed for AI processing, the Jetson Nano allows developers to work on edge computing tasks such as real-time image recognition, autonomous robots, and deep learning applications. As AI and machine learning applications become more prevalent in fields like security and healthcare, the Jetson Nano offers a compact and powerful platform for deploying AI systems at the edge.

ASUS TinkerBoard

ASUS introduced the Tinker Board to compete directly with the Raspberry Pi, and it has made a name for itself, especially in multimedia and high-performance computing. The Tinker Board provides superior graphics performance, making it ideal for media centres, desktop computing, and home automation systems. It supports Linux and Android, offering flexibility for developers working in different environments. With 4K video output and high-definition audio support, it is an excellent platform for entertainment systems.

So What's next?

I hope that through this blog, I have been able to give a fairly detailed introduction to what a Single Board Computer is.

Whether you're building a self-driving robot, an edge AI camera, or a home automation controller, understanding the architecture and capabilities of SBCs gives you the best of both worlds: hardware-level control with software-level flexibility.

In the following article, we'll break down the hardware components of SBCs — from architecture, SoCs and memory to GPIOs and expansion buses — and explore how to evaluate them when choosing the right board for your project.