Measuring PREEMPT_RT Latency with an Oscilloscope

A ready-to-use bootable SD card image for BeagleBone Black/Green with a fully preemptible Linux kernel (PREEMPT_RT) — includes a gpio-test program that mirrors an input signal to a GPIO output pin for measuring scheduler latency with an oscilloscope.

Oscilloscope view — yellow is the input signal, blue is the GPIO output. The phase difference indicates scheduler latency.

Thanks to Maxime Chevallier of Bootlin for providing the gpio-test demo utility during PREEMPT_RT training.

Setup diagram

Setup diagram — signal generator feeds the BeagleBone, oscilloscope measures input vs output.

Items needed

• BeagleBone Black or Green
• +5 V power adapter
• Micro SD card (1 GB or larger)
• Programmable signal generator board
• 2-channel oscilloscope
• Jumper wires

Instructions

1. Prepare the setup as shown in the diagram (set signal generator to 100 Hz, 50% duty cycle)
2. Download sdcard-beaglebone-preemptrt-demo.img.xz (~25 MB)
3. Write the image to a micro SD card using Balena Etcher
4. Insert the SD card into the BeagleBone and power on
5. After boot, the oscilloscope shows two square waves with a phase difference — yellow (input) and blue (output from BeagleBone)
6. The phase difference indicates the latency introduced by the scheduler while running the preemptrt-gpiotest program

On startup, /etc/init.d/S99PreemptrtGpioTester invokes:

chrt -r 99 /usr/sbin/preemptrt-gpiotest gpiochip0 28 gpiochip0 17 h p

This starts the gpio-test utility at real-time priority 99.

Measuring latency under load

The gpio-test program mirrors a GPIO input to an output — the phase difference between the two signals shows how fast the scheduler delivers context to your application. Jitter on the output signal (measured in oscilloscope persist mode) indicates the best and worst case scheduler latency under different load conditions (network traffic, interrupts, etc.).

Persist mode — showing best and worst case scheduler latency under load.

For further details on PREEMPT_RT, see Bootlin's PREEMPT_RT training material.

Building from source

Detailed build instructions are available in the git repository. Cross-compile instructions for modifying and running a customized gpio-test utility are also available.

SOURCE CODE

github.com/hackboxguy/preemptrt-gpiotest — GPIO latency test program

github.com/hackboxguy/br-wrapper — Buildroot config and build instructions

sdcard-beaglebone-preemptrt-demo.img.xz — pre-built SD card image (~25 MB)

Related posts

• CAN Bus Multi-Sensor Node with ESP32 and KiCad PCB
• AWS IoT on Raspberry Pi with 25 MB Buildroot Linux
• DIY Passive PoE for Raspberry Pi Under $2

AWS IoT on Raspberry Pi with 25 MB Buildroot Linux

Six simple steps to get an AWS IoT Device SDK demo running on a Raspberry Pi 4 — using a lightweight custom Linux image built with Buildroot (just under 25 MB).

Quick start

1. Download sdcard-pi4-aws-iot-demo.img.xz (~25 MB)
2. Write the image to an SD card using Balena Etcher
3. Unplug and re-plug the SD card so the boot partition appears on your PC
4. Open aws-iot-pubsub-agent.conf and set your AWS IoT endpoint
5. Copy your AWS-generated device certificate (xyz-certificate.pem) and private key (xyz-private.pem.key) to the boot partition
6. Insert the SD card into the Raspberry Pi 4, power on — the aws-iot-pubsub-agent will start publishing messages to your AWS IoT Core

The following image shows steps 4, 5, and 6 in detail:

Steps 4–6: configure endpoint, copy certificates, and boot the Pi.

AWS cloud preparation

Before booting the Pi, set up the following on console.aws.amazon.com:

1. Create an AWS IoT account (payment details required even for the free tier)
2. Navigate to IoT Core
3. Go to Manage → All Devices → Things → Create Thing
4. Download the device certificate and private key (copy these to the SD card boot partition as described in step 5 above)
5. Go to Settings and note your Endpoint (needed for step 4 above)
6. Go to Security → Policies and create a policy with 4 entries as shown below:

AWS IoT security policy — required permissions for the device.

Building the image from source

Two commands to build the SD card image (detailed instructions in the git repository):

make -C buildroot BR2_EXTERNAL=../ BR2_DL_DIR=../../br-dl O=../../br-output raspberrypi4_aws_iot_defconfig
make -C buildroot BR2_EXTERNAL=../ BR2_DL_DIR=../../br-dl O=../../br-output

Buildroot customizations

Key changes in the Raspberry Pi 4 Buildroot config for this AWS demo image:

1. Enabled Dropbear SSH for remote debugging without monitor/keyboard
2. Added Buildroot package for aws-iot-device-sdk-cpp-v2
3. Added Buildroot package for aws-iot-pubsub-agent
4. Enabled chrony for time sync (required for TLS handshake)
5. Enabled SDK dependencies (host-cmake, libcurl, openssl, util-linux)
6. Included AmazonRootCA1.pem in /etc/
7. Added aws-iot-pubsub-agent.conf to rootfs for the agent startup script
8. Added /etc/init.d/S03MountBoot to mount the boot partition at /mnt/certs (contains certificates, key, and config)
9. Included startup script for aws-iot-pubsub-agent

After booting

1. Connect the Raspberry Pi 4 to a DHCP network with internet access
2. Find the Pi on your network using hostname buildroot or its assigned IP
3. Log in via SSH: ssh root@192.168.x.y (password: brb0x)
4. Check the publish log: cat /tmp/aws-iot-pubsub-agent.log
5. To modify the aws-iot-pubsub-agent code, see how to cross-compile and run on target

If everything is configured correctly (SD card and AWS security policies), Hello World! messages will appear on your AWS IoT Core console:

AWS IoT Core — Hello World messages arriving from the Raspberry Pi 4.

SOURCE CODE

github.com/hackboxguy/br-wrapper — build instructions and Buildroot config

sdcard-pi4-aws-iot-demo.img.xz — pre-built SD card image (~25 MB)

Related posts

• Getting Started with AWS IoT on OpenWrt Routers
• $30 Pocket Router as an AWS IoT Edge Device
• Measuring PREEMPT_RT Latency with an Oscilloscope

Vendor-Neutral Zigbee Gateway with Raspberry Pi

A one-script installer that turns a Raspberry Pi + CC2531 USB adapter into a vendor-neutral Zigbee home automation gateway running Domoticz — supporting 800+ Zigbee devices from any manufacturer.

Raspberry Pi with CC2531 USB Zigbee adapter — the complete Pimoticz hardware.

The problem

Cheap Zigbee home automation devices are everywhere, but they're locked to the manufacturer's gateway — limiting you to a small set of supported devices. With commercial off-the-shelf (COTS) hardware, you can build your own vendor-neutral gateway, but it requires setting up multiple components:

1. Raspberry Pi
2. CC2531 USB Zigbee adapter (with Koenkk firmware, ~$12 on Amazon)
3. Raspberry Pi OS (32-bit)
4. Node.js (v12 or higher)
5. zigbee2mqtt
6. Mosquitto MQTT broker
7. Domoticz
8. zigbee2mqtt plugin for Domoticz

For beginners, getting all these components working together is a challenging task. Pimoticz simplifies this with an automated installer script — in about 5 minutes you should be ready to pair your first Zigbee device.

Items needed

• Raspberry Pi
• Micro SD card
• 5V power adapter
• CC2531 USB Zigbee adapter

Important: To avoid the CC2531 programming setup, buy a pre-programmed USB adapter with Koenkk firmware (CC2531_DEFAULT_20190608.zip or higher).

Raspberry Pi OS setup

CC2531 USB adapter, keyboard, mouse, monitor, and internet connection are only needed during the initial setup.

Step 1 — Prepare the SD card using Raspberry Pi Imager and install Raspberry Pi OS 32-bit.

Step 2 — Insert the SD card, connect keyboard/mouse/monitor and internet to your Raspberry Pi, then power on.

Step 3 — On first boot, the setup wizard will guide you through:

• Language and keyboard layout (important for correct local time — Domoticz needs it)
• Set a new password for the pi user
• Black border check (not important — Raspi will run headless after setup)
• Wi-Fi setup (skip if using Ethernet)
• Software update (optional — can skip to save time)
• Reboot to apply settings

Pimoticz software stack — zigbee2mqtt, Mosquitto, and Domoticz working together.

Pimoticz installation

Open a terminal on the Raspberry Pi (locally or via SSH) and run:

git clone https://github.com/hackboxguy/pimoticz.git
cd /home/pi/pimoticz
sudo ./setup.sh -h my-pimoticz    # -h hostname is optional
# wait ~5 minutes for setup to complete
sudo reboot

Setup script in progress — installing all dependencies automatically.

After reboot, open a browser and navigate to http://127.0.0.1:8080 or http://my-pimoticz:8080 — Domoticz will show the detected CC2531 Zigbee coordinator.

Domoticz running on Pimoticz — CC2531 Zigbee coordinator detected and ready to pair devices.

Your Pimoticz gateway is ready. You can now pair Zigbee devices from any manufacturer — Xiaomi, IKEA, Philips Hue, Sonoff, and 800+ more.

SOURCE CODE

github.com/hackboxguy/pimoticz — installer script and documentation

Related posts

• $20 Pocket Router as Domoticz Smart Home Gateway
• Alexa Controls Domoticz via Philips Hue Emulator
• Control Home Devices via XMPP Chat with Raspberry Pi