Articles, experiments, and teaching materials from decades of wiring software to hardware.
UNO Q with a 24 GHz radar wired to the board to build a live radar scope - the MCU turns a binary sensor stream into three tracked targets, and the Linux side draws them sweeping across a web dashboard. Along the way, a proper look at how FMCW radar works, all showing the strength of mmWave radar.
A gentle, but complete introduction to the Zephyr devicetree, taught through the one thing every beginner gets wrong - which way round an LED is wired. Built from nothing on a low-cost Seeed XIAO nRF52840, with three onboard LEDs, one external LED wired deliberately backwards, and a button.
Part three of the UNO Q series removes the App Lab, Arduino core, sketch loader and just uses west, a devicetree, and our own Zephyr firmware on the board's STM32U585, driving the 13x8 LED matrix through Zephyr's display API with grayscale functionality.
Eleven pins, 104 LEDs, and a scan you can slow down until the trick falls apart. An interactive walkthrough of the Arduino UNO Q's charlieplexed matrix, built from the board's own devicetree.
Part two of the OpenMV series shrinks the board and the power to a quarter of a watt, while running YOLO. Built on Alif's Ensemble E3 with two Cortex-M55s and two Ethos-U55 NPUs, the AE3 also carries something its bigger sibling does not, a VL53L8CX 8x8 ToF depth sensor.
The OpenMV N6 pairs an 800 MHz Cortex-M55 with ST's 600-GOPS Neural-ART NPU and a removable global-shutter camera, and MicroPython - YOLO object detection at 30 fps, in Python, under a watt. We tour the hardware properly, walk through setup, and build a people-counting application on the NPU.
Part two of the UNO Q series puts the board's dual-brain design to real work - a vision AI Brick on the Linux side detects a person through a camera, and the microcontroller side turns that into a smoothly breathing lamp that never stutters, no matter how hard the AI is working.
The Arduino UNO Q pairs a quad-core Linux processor with a real-time STM32 microcontroller on one UNO-shaped board, and quietly runs Zephyr where the classic Arduino runtime used to be. This guide takes an engineer's look at the architecture.
A survey of where Rust stands for embedded and edge development in mid-2026, from bare-metal async on microcontrollers to services on embedded Linux, including the toolchain, the safety-certification story, the wireless gaps, and measurements from this blog's own boards.
A field guide to state-of-the-art edge AI in 2026, covering the models that now run on small devices, the neural accelerators that make them possible, and federated learning, grounded in the low-cost hardware used throughout this blog.
A short follow-on from the Zephyr Thread web server guide, rebuilding the same project in C++ on the Seeed XIAO nRF52840, and adding the RGB LED and the on-die temperature sensor to show why classes suit Zephyr hardware so well.
In an earlier guide we built a tiny web server on an ESP32-C3 in async Rust, using Embassy. A browser could connect over Wi-Fi, toggle an onboard LED, and flip the page theme. This guide builds the same idea on completely different foundations: the Zephyr RTOS , written in C, running
Thread is the low-power IPv6 mesh that underpins most Matter smart-home devices, and to use it you need a Thread Border Router (a bridge between your normal network and the mesh). Commercial border routers are built into many smart speakers and hubs, but they rarely give you the access a
This guide explains how Embassy ties an ESP32-C3 Wi-Fi web server together. It assumes you are comfortable with basic Rust (ownership, traits, match) but new to embedded async.
This talk reflects on practical experience teaching C, C++, and Rust for edge programming in Electronic and Computer Engineering at Dublin City University, where language choices are shaped by emerging industry needs and sound educational pedagogy