The problem
The core idea
What's on the bench
Block diagram
Why Robot Framework
The suite, briefly
One bench, two jobs
Hard-earned warnings
Roadmap

Published July 2, 2026 © GPL3+

A Configurable Raspberry Pi Hardware Test Bench

A reconfigurable EOL + regression test bench: a Pi, a stack of HATs, and Robot Framework. Change what it tests by changing the HATs.

IntermediateWork in progress16 hours18

A Configurable Raspberry Pi Hardware Test Bench

Things used in this project

Hardware components

Raspberry Pi 4 Model B

DQ5rly-I2C-HAT

Raspberry Pi I/O Module / I2C / 5 Relay Outputs

DQ10rly I2C-HAT

Raspberry Pi I/O Module / I2C / 10 Relay Outputs

DI16ac I2C-HAT

Raspberry Pi I/O Module / I2C / 16 Digital Inputs

DIN Pi Case

Raspberry Pi and HATs enclosure / DIN Rail

DIN Pi Case Extension

HAT case / DIN Rail

Software apps and online services

robotframework

Story

I design and manufacture Raspberry Pi HATs, and for too long every board that shipped was tested by hand: wire it up, toggle outputs, repeat. This is the test bench that replaced me. The interesting part isn't any single test, it's that the bench's capabilities are defined entirely by which HATs are stacked on the Pi. Swap the HAT combination and the.robot file, and the same bench tests completely different hardware. No dedicated fixture electronics, no separate PC: the Pi drives the instruments, runs the tests, flashes firmware, and writes the reports.

Full disclosure: the I/O HATs used here are boards I design and sell, and the DUT is one of my own products. The architecture works with any I/O boards.

The problem

Two pains pushed me into building this, and they turn out to be the same problem wearing different hats :).

End-of-line testing. Every manufactured board needs a functional test before shipping. Manual EOL testing is slow and, worse, inconsistent. The human checking board #100 of the day is not the human who checked board #2.

Firmware regression. Every firmware change should re-run the full functional suite against real hardware, and nobody does regression testing by hand more than twice.

Both reduce to: stimulate the DUT's inputs, observe its outputs, compare against expectations. So one bench does both jobs.

The core idea

A Raspberry Pi 4 sits in the middle. On top of it: whichever I2C I/O HATs match the DUT. Need to read the DUT's outputs? Stack a digital-input HAT. Need to drive its inputs? Stack a relay HAT or some other type of output HAT. I'm using I2C HATs, so each HAT has a configurable I2C address, they all share one bus, and everything goes through one Python library. Robot Framework sits on top and turns the Python calls into plain-English test cases and outputs nice, detailed HTML reports.

Contrast with a typical commercial functional test fixture: built for exactly one product, rebuilt from scratch when the product changes. Here, the Pi and HAT stack stay put. Need more I/O for the next product? Stack another HAT, give it an address. In practice, only the.robot file changes.

A lucky twist in my case: since my DUTs are themselves Pi HATs, they connect the same way the bench HATs do, so the stack plus wiring to terminal blocks *is* the fixture. No bed of nails. For any other product you'd put a jig (pogo pins, harness, clamp) between the terminal blocks and the DUT; the test logic doesn't care.

What's on the bench

Current DUT: a board with 6 isolated digital inputs and 6 relay outputs (DI6acDQ6rly I2C HAT), which conveniently exercises everything in one suite: input reading, relay switching, interrupts, and boot/address jumpers.

The bench stack:

Two details I'm fond of:

1. Jumpers emulated by relays. The DUT's boot and address jumpers are each replaced by a relay contact, so the suite can short pins programmatically: activate the boot "jumper, " reset the DUT over I2C, scan the bus, assert it enumerated at the bootloader address. The address-jumper test is a Robot Framework template, a four-row table of jumper index vs. expected address. A broken jumper solder-joint/pad/trace on a manufactured board fails instantly, by name.

2. A deliberately marginal supply. The DUT inputs are driven from a separate 3V supply chosen to sit right at the minimum high-level threshold. Every input test therefore validates the input circuit's *sensitivity*, not just its logic. The inputs also accept both wiring polarities, so a dedicated relay HAT(DQ5rly I2C-HAT) flips the supply and the whole input matrix runs again reversed.

Block diagram

+---------- TEST BENCH -----------+
|                                 | I2C bus + power
|              +------------------------------------+
|              |                  |                 |
|   +----------------------+      |      +--------------------+
|   | Test Bench HAT stack |      |      |        DUT         |
|   |                      |      |      |                    |
|   |  DQ10rly  @ 0x5E     |------------>| boot/addr jumpers  |
|   |  DI16ac   @ 0x40     |<------------| DUT relay outputs  |
|   |  DQ10rly  @ 0x5F     |---+-------->| DUT digital inputs |
|   |  DQ5rly   @ 0x5D     |---+  |      |                    |
|   +----------+-----------+      |      +--------------------+
|              | I2C bus + power  |
|   +----------v----------+       |
|   |   Raspberry Pi 4    |       |
|   +---------------------+       |
+---------------------------------+

Why Robot Framework

No deep selection process: the HAT libraries are Python, I had Robot Framework experience from a previous job, done. pytest would work just as well. The real value is in the Python layer underneath, not the runner. What Robot gives for free: readable keyword-style test cases, HTML report + log per run, and a clean split between test logic and hardware access. The glue layer exposing the HAT library as Robot keywords is thin and linked below.

The suite, briefly

Suite setup creates a handle per bench HAT and resets every output, so each test starts from a known state. Test #1 connects to the DUT, checks name/firmware version, verifies all I/O idle, since there's no point continuing otherwise.
Input tests run per-channel on each COM pin, then all channels at once as a bitmask read in both polarities. That single-pass bitmask check is exactly what an EOL run wants: fast, all channels, one verdict.
Interrupt tests are three order-dependent cases: pulse with IRQs disabled does nothing; enabling rising-edge detection makes a pulse assert the active-low IRQ pin; clearing the capture register releases it. The pulse is 15 ms: long enough for relays that simulate it to actually make contact, short enough to look like a real event. Every 'Sleep' in the suite exists because a relay, a bus, or a firmware state machine demanded it.
Relay tests close each DUT relay and read the corresponding monitor input.
The one manual step: LEDs. The suite chases the channel LEDs and uses Robot's Dialogs library to ask the operator for a verdict. This step is living on borrowed time, a camera is next!

One bench, two jobs

During firmware development the suite is a regression net: flash, run, know in minutes whether the change broke inputs, IRQ handling, or address selection. At end-of-line the *identical* suite is the production gate: jumpers, both polarities, interrupts, relays, LEDs, consistent verdicts across hundreds of boards, failing channel named in the report. One set of test logic, maintained once.

Hard-earned warnings!

Trim bench wiring to length and hot-glue the connectors. A bench sees hundreds of insertion cycles, and loose wires produce the most maddening class of intermittent failure.
Do NOT write Robot's output files (report.html, log.html, output.xml) to the Pi's SD card if the bench runs hundreds of cycles. A power loss mid-write will eventually corrupt the card. Network share or external storage from day one.

Roadmap

Camera-based LED verification (kills the last manual step; write-up coming as a project log)
GitLab CI runner on the Pi, so every firmware commit gets tested on real hardware

Code

Robotframework Test Suite

*** Settings ***
Documentation       Test suite for the DI6acDQ6rly I2C-HAT (6 AC digital inputs + 6 relay outputs).
...
...                 Test bench wiring:
...                 - DI16ac  @ ${RELAY_MONITOR_ADDRESS}: monitors DUT relay outputs (wired to inputs 8..15)
...                 - DQ10rly @ ${INPUT_CONTROL_ADDRESS}: drives DUT digital inputs (ch 0..5) and selects COM pin (ch 6 = COM0, ch 7 = COM1)
...                 - DQ10rly @ ${JUMPER_CONTROL_ADDRESS}: boot jumper (relay 0) and address jumpers 0..3 (relays 4..1)
...                 - DQ5rly  @ ${POLARITY_CONTROL_ADDRESS}: input polarity wiring (0x18 = reverse). The polarity relays
...                   re-wire the source so the expected logical values are identical for normal and reverse polarity.
...
...                 Note: the three IRQ test cases are order-dependent and must run in suite order.

Library             Process
Library             Collections
Library             Dialogs
Library             raspihats.i2c_hats.robot

Suite Setup         Open Test Bench
Suite Teardown      Close Test Bench
Test Setup          Open Test Case


*** Variables ***
# I2C addresses
${DUT_ADDRESS}                  ${0x60}
${BOOTLOADER_ADDRESS}           ${0x3E}
${RELAY_MONITOR_ADDRESS}        ${0x40}
${INPUT_CONTROL_ADDRESS}        ${0x5F}
${JUMPER_CONTROL_ADDRESS}       ${0x5E}
${POLARITY_CONTROL_ADDRESS}     ${0x5D}

# DUT characteristics
${DUT_NAME}                     DI6acDQ6rly I2C-HAT
${CHANNEL_COUNT}                ${6}
${ALL_CHANNELS_MASK}            ${0x3F}
${RELAY_MONITOR_OFFSET}         ${8}
${REVERSE_POLARITY_MASK}        ${0x18}

# Timing
${SETTLE_DELAY}                 0.1s
${BUS_SETTLE_DELAY}             0.5s
${VALUE_SETTLE_DELAY}           0.5s
${IRQ_PULSE_DELAY}              0.015s
${LED_CHASE_DELAY}              0.25s


*** Test Cases ***
Initialize DUT
    [Documentation]    Creates the DUT handle, verifies name and firmware version, and checks idle I/O state.
    ${i2c_hat}=    New DI6acDQ6rly    ${DUT_ADDRESS}
    Set Suite Variable    ${DUT}    ${i2c_hat}
    ${name}=    Get Name    ${DUT}
    Should Be Equal As Strings    ${name}    ${DUT_NAME}
    ${fw_version}=    Get Firmware Version    ${DUT}
    Log To Console    ${fw_version}
    DO Set Value    ${DUT}    ${0}
    ${di_value}=    DI Get Value    ${DUT}
    Should Be Equal As Integers    ${di_value}    ${0}

Boot Pin
    [Documentation]    With the boot jumper active, the DUT must enumerate at the bootloader address after reset.
    Activate Boot Jumper
    Reset DUT
    ${i2c_devices}=    Scan I2C Bus
    Should Contain    ${i2c_devices}    ${BOOTLOADER_ADDRESS}
    Deactivate Boot Jumper
    # The device stays in bootloader mode (at ${BOOTLOADER_ADDRESS}) after the jumper is released. The bus scan 
    # below is what resets the bootloader and returns control to the application.
    Scan I2C Bus
    Sleep    ${BUS_SETTLE_DELAY}
    New DI6acDQ6rly    ${DUT_ADDRESS}

Address Pins
    [Documentation]    Each address jumper must shift the I2C address by its bit weight.
    [Template]    Verify Address Jumper
    # jumper index    expected address
    ${0}               ${0x61}
    ${1}               ${0x62}
    ${2}               ${0x64}
    ${3}               ${0x68}

Digital Input Channels On COM Pin 0
    [Template]    Verify Digital Input Channel
    # COM pin    channel
    ${0}          ${0}
    ${0}          ${1}
    ${0}          ${2}
    ${0}          ${3}
    ${0}          ${4}
    ${0}          ${5}

Digital Input Channels On COM Pin 1
    [Template]    Verify Digital Input Channel
    # COM pin    channel
    ${1}          ${0}
    ${1}          ${1}
    ${1}          ${2}
    ${1}          ${3}
    ${1}          ${4}
    ${1}          ${5}

All Digital Input Channels
    [Template]    Verify All Digital Input Channels
    # COM pin    polarity
    ${0}          normal
    ${0}          reverse
    ${1}          normal
    ${1}          reverse

IRQ Disabled - Input Pulse Does Not Assert IRQ
    Use Digital Inputs COM Pin    ${0}
    Disable And Clear IRQ
    IRQ Pin State Should Be    ${1}
    Pulse Digital Input    ${0}
    IRQ Pin State Should Be    ${1}

IRQ Rising Edge Enabled - Input Pulse Asserts IRQ
    DI Set IRQ Reg Rising Edge Control    ${DUT}    ${ALL_CHANNELS_MASK}
    Pulse Digital Input    ${0}
    IRQ Pin State Should Be    ${0}

IRQ Cleared By Capture Register
    DI Set IRQ Reg Capture    ${DUT}    ${0}
    IRQ Pin State Should Be    ${1}
    [Teardown]    Disable And Clear IRQ

Relay Channels
    [Template]    Verify Relay Channel
    ${0}
    ${1}
    ${2}
    ${3}
    ${4}
    ${5}

All Relay Channels
    Verify All Relay Channels

LEDs Visual Inspection
    Pause Execution    Press OK when you are ready to start the LEDs visual inspection!
    Use Digital Inputs COM Pin    ${0}
    Chase Channel LEDs    ${INPUT_CONTROL}
    Chase Channel LEDs    ${DUT}
    Execute Manual Step    Your evaluation after observing the LEDs?    LEDs visual inspection failed.


*** Keywords ***
# ----------------------------------------------------------------------------
# Test bench lifecycle
# ----------------------------------------------------------------------------
Open Test Bench
    Init Irq Pin
    ${i2c_hat}=    New DI16ac    ${RELAY_MONITOR_ADDRESS}
    Set Suite Variable    ${RELAY_MONITOR}    ${i2c_hat}
    ${i2c_hat}=    New DQ10rly    ${INPUT_CONTROL_ADDRESS}
    Set Suite Variable    ${INPUT_CONTROL}    ${i2c_hat}
    ${i2c_hat}=    New DQ10rly    ${JUMPER_CONTROL_ADDRESS}
    Set Suite Variable    ${JUMPER_CONTROL}    ${i2c_hat}
    ${i2c_hat}=    New DQ5rly    ${POLARITY_CONTROL_ADDRESS}
    Set Suite Variable    ${POLARITY_CONTROL}    ${i2c_hat}
    Reset Test Bench Outputs

Close Test Bench
    Reset Test Bench Outputs

Open Test Case
    DO Set Value    ${JUMPER_CONTROL}    ${0}
    Set Normal Polarity For Digital Inputs

Reset Test Bench Outputs
    DO Set Value    ${JUMPER_CONTROL}    ${0}
    DO Set Value    ${INPUT_CONTROL}    ${0}
    DO Set Value    ${POLARITY_CONTROL}    ${0}

# ----------------------------------------------------------------------------
# Generic helpers
# ----------------------------------------------------------------------------
Scan I2C Bus
    ${result}=    Run Process    i2cdetect    -y    1
    ${bus_devices}=    Evaluate
    ...    [int(x, 16) for x in """${result.stdout}""".replace('--', '').split() if len(x) == 2 and int(x, 16) > 0x0F]
    RETURN    ${bus_devices}

Reset DUT
    Reset    ${DUT}
    Sleep    ${BUS_SETTLE_DELAY}

# ----------------------------------------------------------------------------
# Boot and address jumpers (JUMPER_CONTROL hat)
# ----------------------------------------------------------------------------
Activate Boot Jumper
    [Arguments]    ${delay}=${SETTLE_DELAY}
    DO Set Channel    ${JUMPER_CONTROL}    ${0}    ${1}
    Sleep    ${delay}

Deactivate Boot Jumper
    [Arguments]    ${delay}=${SETTLE_DELAY}
    DO Set Channel    ${JUMPER_CONTROL}    ${0}    ${0}
    Sleep    ${delay}

Set Address Jumper
    [Documentation]    Address jumpers 0..3 are wired to relays 4..1 of the jumper control hat.
    [Arguments]    ${index}    ${state}    ${delay}=${SETTLE_DELAY}
    ${relay_index}=    Evaluate    4 - ${index}
    DO Set Channel    ${JUMPER_CONTROL}    ${relay_index}    ${state}
    Sleep    ${delay}

Verify Address Jumper
    [Arguments]    ${index}    ${expected_address}
    Set Address Jumper    ${index}    ${1}
    Reset DUT
    ${i2c_hat}=    New DI6acDQ6rly    ${expected_address}
    Set Address Jumper    ${index}    ${0}
    Reset    ${i2c_hat}
    Sleep    ${BUS_SETTLE_DELAY}
    ${i2c_hat}=    New DI6acDQ6rly    ${DUT_ADDRESS}
    Set Suite Variable    ${DUT}    ${i2c_hat}

# ----------------------------------------------------------------------------
# Digital input stimulation (INPUT_CONTROL and POLARITY_CONTROL hats)
# ----------------------------------------------------------------------------
Set Normal Polarity For Digital Inputs
    DO Set Value    ${POLARITY_CONTROL}    ${0x00}

Set Reverse Polarity For Digital Inputs
    DO Set Value    ${POLARITY_CONTROL}    ${REVERSE_POLARITY_MASK}

Use Digital Inputs COM Pin
    [Documentation]    Selects COM pin 0 or 1. Channel 6 connects COM0, channel 7 connects COM1; only one may be active.
    [Arguments]    ${com_pin}
    DO Set Channel    ${INPUT_CONTROL}    ${{6 + $com_pin}}    ${1}
    DO Set Channel    ${INPUT_CONTROL}    ${{7 - $com_pin}}    ${0}
    Sleep    ${BUS_SETTLE_DELAY}

Drive Digital Input
    [Arguments]    ${index}    ${state}    ${delay}=${SETTLE_DELAY}
    DO Set Channel    ${INPUT_CONTROL}    ${index}    ${state}
    Sleep    ${delay}

Pulse Digital Input
    [Arguments]    ${index}    ${pulse}=${IRQ_PULSE_DELAY}
    Drive Digital Input    ${index}    ${1}    ${pulse}
    Drive Digital Input    ${index}    ${0}    ${pulse}

Digital Input State Should Be
    [Arguments]    ${index}    ${expected}
    ${state}=    DI Get Channel    ${DUT}    ${index}
    Should Be Equal As Integers    ${state}    ${expected}

Verify Digital Input Channel
    [Arguments]    ${com_pin}    ${index}
    Use Digital Inputs COM Pin    ${com_pin}
    Drive Digital Input    ${index}    ${1}
    Digital Input State Should Be    ${index}    ${1}
    Drive Digital Input    ${index}    ${0}
    Digital Input State Should Be    ${index}    ${0}

Verify All Digital Input Channels
    [Arguments]    ${com_pin}    ${polarity}=normal    ${delay}=${VALUE_SETTLE_DELAY}
    IF    '${polarity}' == 'reverse'
        Set Reverse Polarity For Digital Inputs
    ELSE
        Set Normal Polarity For Digital Inputs
    END
    Use Digital Inputs COM Pin    ${com_pin}
    ${do_value}=    DO Get Value    ${INPUT_CONTROL}
    DO Set Value    ${INPUT_CONTROL}    ${{$do_value | $ALL_CHANNELS_MASK}}
    Sleep    ${delay}
    ${state}=    DI Get Value    ${DUT}
    Should Be Equal As Integers    ${state}    ${ALL_CHANNELS_MASK}
    DO Set Value    ${INPUT_CONTROL}    ${{$do_value & ~$ALL_CHANNELS_MASK}}
    Sleep    ${delay}
    ${state}=    DI Get Value    ${DUT}
    Should Be Equal As Integers    ${state}    ${0}

# ----------------------------------------------------------------------------
# Relay verification (RELAY_MONITOR hat)
# ----------------------------------------------------------------------------
Relay State Should Be
    [Documentation]    DUT relay outputs are wired to relay monitor inputs 8..15.
    [Arguments]    ${index}    ${expected}    ${delay}=${SETTLE_DELAY}
    Sleep    ${delay}
    ${state}=    DI Get Channel    ${RELAY_MONITOR}    ${{$index + $RELAY_MONITOR_OFFSET}}
    Should Be Equal As Integers    ${state}    ${expected}

Verify Relay Channel
    [Arguments]    ${index}
    DO Set Channel    ${DUT}    ${index}    ${1}
    Relay State Should Be    ${index}    ${1}
    DO Set Channel    ${DUT}    ${index}    ${0}
    Relay State Should Be    ${index}    ${0}

Verify All Relay Channels
    [Arguments]    ${delay}=${VALUE_SETTLE_DELAY}
    DO Set Value    ${DUT}    ${ALL_CHANNELS_MASK}
    Sleep    ${delay}
    ${state}=    DI Get Value    ${RELAY_MONITOR}
    Should Be Equal As Integers    ${state}    ${{$ALL_CHANNELS_MASK << $RELAY_MONITOR_OFFSET}}
    DO Set Value    ${DUT}    ${0}
    Sleep    ${delay}
    ${state}=    DI Get Value    ${RELAY_MONITOR}
    Should Be Equal As Integers    ${state}    ${0}

# ----------------------------------------------------------------------------
# IRQ helpers
# ----------------------------------------------------------------------------
Disable And Clear IRQ
    DI Set IRQ Reg Rising Edge Control    ${DUT}    ${0}
    DI Set IRQ Reg Falling Edge Control    ${DUT}    ${0}
    DI Set IRQ Reg Capture    ${DUT}    ${0}

IRQ Pin State Should Be
    [Documentation]    IRQ pin is active low: 1 = idle, 0 = asserted.
    [Arguments]    ${expected}
    ${irq_state}=    Get IRQ Pin State
    Should Be Equal As Integers    ${irq_state}    ${expected}

# ----------------------------------------------------------------------------
# LED inspection
# ----------------------------------------------------------------------------
Chase Channel LEDs
    [Arguments]    ${i2c_hat}    ${on_time}=${LED_CHASE_DELAY}
    FOR    ${index}    IN RANGE    ${CHANNEL_COUNT}
        DO Set Channel    ${i2c_hat}    ${index}    ${1}
        Sleep    ${on_time}
        DO Set Channel    ${i2c_hat}    ${index}    ${0}
        Sleep    ${on_time}
    END

Credits

raspihats

1 project • 0 followers

Software, firmware & hardware engineer. From idea to market, creator of raspihats Raspberry Pi I/O boards!

A Configurable Raspberry Pi Hardware Test Bench