Part 2: Prototyping & Proof of Concept

From Theory to Wires

In Part 1, you learned the electrical theory. Now it’s time to touch actual hardware. Prototyping is where you validate ideas before committing to a PCB design that costs money and takes weeks to manufacture. A $5 breadboard prototype can save you $500 in PCB revisions.

Three Stages of Prototyping

flowchart LR
    BB["Stage 1
Breadboard
Quick & disposable"] --> PB["Stage 2
Perfboard / Protoboard
Semi-permanent"]
    PB --> DEV["Stage 3
Dev Board Shield
Close to final form"]
    BB -.->|"Validate concept"| PB
    PB -.->|"Validate integration"| DEV
    DEV -.->|"Ready for PCB"| PCB["Custom PCB
(Part 4+)"]
                            

Breadboarding Fundamentals

Breadboard Anatomy

A solderless breadboard has a grid of holes connected internally by metal clips. Understanding the connection pattern is essential:

flowchart TD
    subgraph Power["Power Rails (horizontal)"]
        P1["+V ━━━━━━━━━━━━━━━━━━━━"]
        P2["GND ━━━━━━━━━━━━━━━━━━━━"]
    end
    subgraph Top["Terminal Strips (vertical, 5-hole groups)"]
        T1["a b c d e — connected vertically"]
    end
    subgraph Gap["Centre Gap (DIP IC straddler)"]
        G1["═══════════════════"]
    end
    subgraph Bottom["Terminal Strips (vertical, 5-hole groups)"]
        B1["f g h i j — connected vertically"]
    end
    Power --> Top
    Top --> Gap
    Gap --> Bottom
                            

Wiring Best Practices

Clean wiring isn’t just aesthetic — it prevents intermittent faults, makes debugging faster, and teaches the discipline you’ll need for PCB routing later.

Common Breadboard Mistakes

Development Boards

Development boards provide a complete MCU system with power regulation, programming interface, and broken-out GPIO pins. They let you focus on your application rather than the basic MCU support circuit.

STM32 Nucleo Family

The STM32 Nucleo boards from STMicroelectronics are the industry-standard prototyping platform for ARM Cortex-M microcontrollers. They include an on-board ST-LINK debugger, Arduino-compatible headers, and Morpho extension connectors.

/* STM32 Nucleo — Blink LED (Bare-Metal HAL)
 * Board: Nucleo-F411RE, LED on PA5
 * IDE: STM32CubeIDE — create project via CubeMX
 */

#include "stm32f4xx_hal.h"

int main(void)
{
    /* Initialise HAL and system clock */
    HAL_Init();
    SystemClock_Config();  /* Generated by CubeMX */

    /* Enable GPIOA clock */
    __HAL_RCC_GPIOA_CLK_ENABLE();

    /* Configure PA5 as push-pull output */
    GPIO_InitTypeDef gpio = {0};
    gpio.Pin   = GPIO_PIN_5;
    gpio.Mode  = GPIO_MODE_OUTPUT_PP;
    gpio.Pull  = GPIO_NOPULL;
    gpio.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOA, &gpio);

    /* Blink loop — 500ms on, 500ms off */
    while (1)
    {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
        HAL_Delay(500);
    }
}

ESP32 DevKit

The ESP32 from Espressif is the go-to choice for WiFi and Bluetooth-enabled embedded projects. The DevKit boards are breadboard-friendly and can be programmed with Arduino IDE, ESP-IDF, or MicroPython.

## ESP32 — Blink LED + WiFi Scan (MicroPython)
## Flash MicroPython firmware, then upload this script

import machine
import network
import time

# Configure LED on GPIO2 (built-in blue LED on most DevKits)
led = machine.Pin(2, machine.Pin.OUT)

# Blink 3 times to show boot
for i in range(3):
    led.on()
    time.sleep_ms(200)
    led.off()
    time.sleep_ms(200)

# Scan for WiFi networks
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
networks = wlan.scan()

print(f"Found {len(networks)} WiFi networks:")
for ssid, bssid, channel, rssi, authmode, hidden in networks:
    auth_names = ["OPEN", "WEP", "WPA-PSK", "WPA2-PSK", "WPA/WPA2-PSK"]
    auth = auth_names[authmode] if authmode < len(auth_names) else "UNKNOWN"
    print(f"  {ssid.decode():.<30} Ch{channel:>2}  {rssi}dBm  {auth}")

Development Board Selection Guide

flowchart TD
    START{"What do you need?"} -->|"WiFi / BLE
connectivity"| ESP["ESP32 DevKit
~$5-10"]
    START -->|"Real-time control
bare-metal"| STM["STM32 Nucleo
~$12-25"]
    START -->|"Quick prototype
beginner"| ARD["Arduino Uno
~$5-15"]
    START -->|"Linux + cameras
ML inference"| RPI["Raspberry Pi
~$35-75"]
    START -->|"Ultra-low power
BLE beacon"| NRF["nRF52840 DK
~$40"]
    ESP -->|"Need more GPIO"| STM
    STM -->|"Need WiFi"| ESP
    ARD -->|"Outgrew it"| STM
                            

Sensor Integration Patterns

Sensors are the eyes and ears of your embedded system. This section covers the three most common interfacing methods: I2C digital sensors, analog sensors with ADC, and simple digital I/O.

I2C Sensors (Digital Bus)

I2C (Inter-Integrated Circuit) uses just two wires — SDA (data) and SCL (clock) — to communicate with multiple sensors on the same bus. Each sensor has a unique 7-bit address.

flowchart LR
    MCU["MCU
I2C Master"] --> SDA["SDA (data)"]
    MCU --> SCL["SCL (clock)"]
    SDA --> S1["BME280
Temp/Hum/Press
Addr: 0x76"]
    SCL --> S1
    SDA --> S2["BH1750
Light Sensor
Addr: 0x23"]
    SCL --> S2
    SDA --> S3["MPU6050
Accel/Gyro
Addr: 0x68"]
    SCL --> S3
    SDA -.->|"4.7kΩ pull-up to VDD"| VDD["3.3V"]
    SCL -.->|"4.7kΩ pull-up to VDD"| VDD
                            

## I2C Sensor Scan — Find all devices on the bus
## For ESP32 with MicroPython

import machine

# Configure I2C bus (ESP32: SDA=GPIO21, SCL=GPIO22)
i2c = machine.I2C(0, scl=machine.Pin(22), sda=machine.Pin(21), freq=400000)

# Scan for all devices on the bus
devices = i2c.scan()
print(f"I2C scan found {len(devices)} device(s):")
for addr in devices:
    # Common sensor addresses
    known = {
        0x23: "BH1750 (light)",
        0x3C: "SSD1306 (OLED)",
        0x48: "ADS1115 (ADC)",
        0x50: "AT24C32 (EEPROM)",
        0x68: "MPU6050 (IMU) / DS3231 (RTC)",
        0x76: "BME280 (env sensor)",
        0x77: "BMP280 (pressure)",
    }
    name = known.get(addr, "Unknown")
    print(f"  0x{addr:02X} — {name}")

I2C scan found 3 device(s):
  0x23 — BH1750 (light)
  0x68 — MPU6050 (IMU) / DS3231 (RTC)
  0x76 — BME280 (env sensor)

## Read BME280 Temperature/Humidity/Pressure
## For ESP32 with MicroPython + bme280 library

import machine
import time

# Minimal BME280 raw register read (no external library needed)
i2c = machine.I2C(0, scl=machine.Pin(22), sda=machine.Pin(21), freq=400000)
BME280_ADDR = 0x76

# Read chip ID to verify connection
chip_id = i2c.readfrom_mem(BME280_ADDR, 0xD0, 1)
print(f"BME280 Chip ID: 0x{chip_id[0]:02X} (expected 0x60)")

# Configure: forced mode, oversampling x1 for temp/hum/press
i2c.writeto_mem(BME280_ADDR, 0xF2, b'\x01')  # Humidity oversampling x1
i2c.writeto_mem(BME280_ADDR, 0xF4, b'\x25')  # Temp x1, Press x1, Forced mode

time.sleep_ms(50)  # Wait for measurement

# Read raw data (8 bytes from 0xF7)
data = i2c.readfrom_mem(BME280_ADDR, 0xF7, 8)
press_raw = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4)
temp_raw = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4)
hum_raw = (data[6] << 8) | data[7]
print(f"Raw readings — Temp: {temp_raw}, Press: {press_raw}, Hum: {hum_raw}")
print("(Compensation formulas needed for calibrated values — see BME280 datasheet)")

BME280 Chip ID: 0x60 (expected 0x60)
Raw readings — Temp: 524288, Press: 331776, Hum: 32768
(Compensation formulas needed for calibrated values — see BME280 datasheet)

Analog Sensors & ADC Reading

Analog sensors output a voltage proportional to the measured quantity. The MCU’s ADC (Analog-to-Digital Converter) reads this voltage and converts it to a digital value.

## Analog Sensor Reading — Temperature with NTC Thermistor
## For ESP32 with MicroPython

import machine
import math

# Configure ADC on GPIO34 (ESP32 ADC1_CH6)
adc = machine.ADC(machine.Pin(34))
adc.atten(machine.ADC.ATTN_11DB)  # 0-3.3V range
adc.width(machine.ADC.WIDTH_12BIT)  # 12-bit resolution (0-4095)

# NTC thermistor parameters (10kΩ at 25°C, B=3950)
R_SERIES = 10000   # Series resistor (voltage divider partner)
B_COEFF = 3950     # B-coefficient from datasheet
T_REF = 298.15     # Reference temp in Kelvin (25°C)
R_REF = 10000      # Resistance at reference temp

# Read 10 samples and average
samples = [adc.read() for _ in range(10)]
adc_avg = sum(samples) / len(samples)

# Convert ADC to resistance (voltage divider formula)
if adc_avg > 0 and adc_avg < 4095:
    r_ntc = R_SERIES * adc_avg / (4095 - adc_avg)

    # Steinhart-Hart simplified (B-parameter equation)
    temp_k = 1 / (1/T_REF + (1/B_COEFF) * math.log(r_ntc / R_REF))
    temp_c = temp_k - 273.15

    print(f"ADC raw: {adc_avg:.0f} / 4095")
    print(f"NTC resistance: {r_ntc:.0f} Ω")
    print(f"Temperature: {temp_c:.1f} °C")
else:
    print("ADC reading out of range — check wiring")

ADC raw: 2048 / 4095
NTC resistance: 10012 Ω
Temperature: 25.0 °C

Digital I/O & Actuators

Digital outputs control LEDs, relays, and motors. Digital inputs read buttons, switches, and interrupt signals. The key concepts: pull-up/pull-down resistors, debouncing, and PWM for variable control.

## Button Input with Debounce + LED PWM Output
## For ESP32 with MicroPython

import machine
import time

# Button on GPIO15 with internal pull-up
button = machine.Pin(15, machine.Pin.IN, machine.Pin.PULL_UP)

# LED on GPIO2 with PWM (variable brightness)
pwm = machine.PWM(machine.Pin(2), freq=1000)

# Software debounce — read button state with 50ms settling
def read_button_debounced(pin, delay_ms=50):
    """Read button with debounce. Returns True if pressed (active LOW)."""
    if pin.value() == 0:  # Button pressed (pulled to GND)
        time.sleep_ms(delay_ms)
        if pin.value() == 0:  # Still pressed after debounce
            return True
    return False

# Cycle LED brightness on each button press
brightness_levels = [0, 256, 512, 768, 1023]  # 0-1023 PWM range
level_index = 0

print("Press button to cycle LED brightness...")
while True:
    if read_button_debounced(button):
        level_index = (level_index + 1) % len(brightness_levels)
        duty = brightness_levels[level_index]
        pwm.duty(duty)
        print(f"Brightness: {duty/1023*100:.0f}% (duty={duty})")
        # Wait for button release
        while button.value() == 0:
            time.sleep_ms(10)
    time.sleep_ms(10)

Systematic Debugging

Debugging is where most prototyping time is spent. A systematic approach saves hours of frustration.

Multimeter Mastery

A digital multimeter (DMM) is your most important debugging tool. Master these four measurements:

The Debug Workflow

flowchart TD
                    A["Circuit doesn't work"] --> B{"Check power supply
V_DD = expected?"}
                    B -->|"No"| C["Fix power:
check USB, regulator,
decoupling caps"]
                    B -->|"Yes"| D{"Check connections
continuity test"}
                    D -->|"Open circuit"| E["Reseat wires,
check solder joints"]
                    D -->|"All connected"| F{"Check signals
with scope/logic analyser"}
                    F -->|"No signal"| G["Check MCU config:
GPIO mode, clock enable,
pin mapping"]
                    F -->|"Signal present"| H{"Signal correct?
Right frequency/level?"}
                    H -->|"Wrong level"| I["Level mismatch:
add level shifter
or voltage divider"]
                    H -->|"Wrong timing"| J["Check clock config,
baud rate, prescaler"]
                    H -->|"Looks correct"| K["Check peripheral:
sensor address,
register config"]
                            

Serial Monitor Debugging

The serial monitor (UART) is the embedded equivalent of console.log(). Use it systematically:

/* Serial Debug Macros for STM32 HAL
 * Redirect printf to UART2 (connected to ST-LINK virtual COM)
 * Add to your main.c or a debug.h header
 */

#include <stdio.h>
#include "stm32f4xx_hal.h"

extern UART_HandleTypeDef huart2;  /* Defined by CubeMX */

/* Redirect printf to UART2 */
int _write(int file, char *ptr, int len)
{
    HAL_UART_Transmit(&huart2, (uint8_t *)ptr, len, HAL_MAX_DELAY);
    return len;
}

/* Debug macros with file/line info */
#define DEBUG_PRINT(fmt, ...) \
    printf("[%lu] " fmt "\r\n", HAL_GetTick(), ##__VA_ARGS__)

#define DEBUG_HEX(label, data, len) do { \
    printf("[%lu] %s: ", HAL_GetTick(), label); \
    for (int i = 0; i < len; i++) printf("%02X ", data[i]); \
    printf("\r\n"); \
} while(0)

/* Usage example in main loop */
/*
    DEBUG_PRINT("ADC value: %d (%.2fV)", adc_raw, adc_raw * 3.3 / 4095);
    DEBUG_PRINT("I2C sensor addr 0x%02X responded", sensor_addr);
    DEBUG_HEX("BME280 raw", buffer, 8);
*/

BOM Builder Tool

Exercises

BOM Builder Tool

Use this tool to build a Bill of Materials for your prototype and download it as a reference document for ordering components.

Conclusion & Next Steps

You now have the practical skills to build working embedded prototypes: breadboarding with clean wiring discipline, choosing the right development board for your project, integrating sensors via I2C and analog ADC, and debugging systematically with a multimeter and serial monitor.