Getting Started With Zephyr: Devicetrees
This blog post provides an introduction to the "Devicetree", another unique concept in The Zephyr Project. We learn about the basic syntax of a device tree and how its structure and hierarchy mirror hardware, from the SoC to the final board. We also see how hardware described in a devicetree can be referenced and controlled in the source code of a Zephyr-based application.
NULL pointer protection with ARM Cortex-M MPU
This post explains how you can set up the ARM Cortex-M MPU (Memory Protection Unit) to protect thy code from dragons, demons, core dumps, and numberless other foul creatures awaiting thee after thou dereference the NULL pointer.
STM32 B-CAMS-OMV Walkthrough
Want to prototype embedded vision quickly? This walkthrough shows how the STM32 B-CAMS-OMV camera module pairs with the STM32H747I-DISCO discovery kit and the FP-AI-VISION1 function pack to get you running in minutes. The video covers the camera connection interface, key software functions to control and process data, and the ISP features that let image processing run inside the camera. The STM32 H7 project with B-CAMS-OMV drivers is available on GitHub.
STM32 VS Code Extension Under The Hood
ST's STM32 VS Code extension hides useful CMake projects and VS Code tasks behind a friendly UI, but understanding what it generates lets you bend it to your needs. This video peels back the layers to show the generated CMake files, how to modify them, how to add a VS Code-invokable flash task, and how to enable C++ support alongside C. The STM32 F0 example and flash task are available on GitHub.
Visual Studio Code Extensions for Embedded Software Development
Visual Studio Code can be a solid embedded development environment, if you equip it with the right extensions. Jacob Beningo walks through tools for Cortex-M debugging, register and RTOS inspection, build system support, formatting, linting, and vendor-specific workflows. It is a practical tour of the extensions that help VS Code feel much less like a general-purpose editor and more like an embedded IDE.
Libgpiod - Toggling GPIOs The Right Way In Embedded Linux
Accessing GPIOs through sysfs is simple but fragile, causing race conditions when multiple userspace processes touch the same line. This post explains libgpiod, introduced in Linux 4.8, and shows concise Python examples on a Toradex Verdin iMX8M Plus for requesting lines, tagging the consumer, using active_low flags, and reading or driving values. Learn why libgpiod provides safer, atomic GPIO handling.
A Beginner's Guide to Embedded Systems
Embedded systems are everywhere, and this guide gives a practical, project-first roadmap for beginners. It explains what embedded systems are, the typical constraints you will face, and a clear learning sequence: circuit fundamentals, digital logic, C, and microcontrollers before moving on to RTOS or embedded Linux. The post also recommends hands-on dev boards and student clubs to accelerate real-world skills.
Getting Started With Embedded Linux - From Nothing To A Login Prompt
This hands-on guide shows how to go from a blank board to a bootable embedded Linux system using Yocto and Docker. Follow the steps to build a reproducible Yocto environment, fetch Toradex manifests, set MACHINE to verdin-imx8mm, run bitbake, and produce the .wic.bmap image ready to flash. Ideal for engineers wanting a concise bringup path for a Verdin iMX8M Mini on a Dahlia carrier.
Learning A New Microcontroller
Learning a new microcontroller becomes manageable with a repeatable, stepwise process that focuses on common peripherals, tools, and example programs. This post lays out hands-on exercises from blinky and UART echoes through I2C/SPI, PWM and ADC to DMA and RTOS variations, and shows how to evolve prototype code into reusable HAL and OSAL layers. Practical tips cover hardware setup, logic analyzers, and keeping an engineering notebook.
VolksEEG: Rust Development On Adafruit nRF52840 Feather Express
Setting up Rust embedded development on an Adafruit Feather nRF52840 Express inside a VS Code devcontainer can save time, but the toolchain has a few gotchas. This post walks through using the VolksEEG prototype echo-server to verify the USB serial path, configuring probe-rs with J-Link and OpenOCD for on-chip debugging, and diagnosing a container build error fixed by adding libudev-dev. Expect step-by-step commands and troubleshooting tips.
The habitat of hardware bugs
Hardware bugs hide where you least expect them, not under the spotlight but in the nooks and crannies of system design. Yossi Kreinin argues that CPUs fail mostly in privileged areas used by OS kernels, DRAM chips and userspace memory are usually reliable, while DRAM controllers, PHYs, peripheral controllers, board bring-up, and uncommon bus protocol paths are fertile ground for quirks. Read this to learn where to look first when firmware misbehaves.
Introduction to Microcontrollers - Ada - 7 Segments and Catching Errors
Mike demos an Ada implementation of a multiplexed 7-segment driver on the STM32F407 Discovery board, highlighting Ada idioms like protected objects for ISRs and packed-boolean GPIO mapping. The post shows practical timer setup for Timer 6, how to avoid ARR/CNT races, and how Ada's runtime range checks plus a last-chance handler surface out-of-range errors with file and line diagnostics.
Hidden Gems from the Embedded Online Conference Archives - Part 2
A look back at a deep dive into the Mars Perseverance flight software from one of the technical leads at JPL.
STM32 VS Code Extension Under The Hood
ST's STM32 VS Code extension hides useful CMake projects and VS Code tasks behind a friendly UI, but understanding what it generates lets you bend it to your needs. This video peels back the layers to show the generated CMake files, how to modify them, how to add a VS Code-invokable flash task, and how to enable C++ support alongside C. The STM32 F0 example and flash task are available on GitHub.
Introduction to Microcontrollers - Buttons and Bouncing
Mechanical buttons lie to your microcontroller, producing bounces and occasional noise that look like multiple presses. Mike Silva walks through practical ways to represent buttons, simple and robust software debounce strategies, and how to convert states into single-use events. The post includes ready-to-use C patterns: N-sample filters, shift-accumulator filtering, per-button data structures, and keypad debouncing examples.
Getting Started with NuttX RTOS on Three Low Cost Boards
You can get Linux-like power on cheap microcontroller boards using NuttX, not a full Linux system. This article walks through building and flashing NuttX on three low-cost targets: Raspberry Pi Pico (RP2040), ESP32-DevKitC, and STM32F4Discovery, covering SDKs, toolchains, and serial access. Follow the provided commands to configure, compile, and connect to the NuttShell so you can start experimenting with NuttX quickly.
Introduction to Microcontrollers - Adding Some Real-World Hardware
Two blinking LEDs only teach you so much, so Mike designed a docking board that adds a 4x20 HD44780 LCD, a 4x4 button matrix, four LEDs, DIP switches and an ADC potentiometer for AVR and STM32 experiments. This post shows how to wire and drive the HD44780 in 4-bit mode, calibrate microsecond and millisecond software delays, use the busy flag to speed writes, and includes AVR example code to get the display running.
Introduction to Microcontrollers - More Timers and Displays
Mike Silva walks through using a single hardware timer to create the illusion of parallel tasks, combining a millisecond tick, deadline checks, and a cyclic executive to run time-driven and event-driven work. He shows safe deadline code that handles timer rollover and ISR races, and provides practical STM32 examples including SysTick-driven delays, atomic GPIO BSRR writes for LCD control, and a button-driven display demo.
Metal detection: building the detector
Fabien Le Mentec turns a bench-validated BFO stage into a field-ready metal detector using scavenged parts and straightforward fabrication. He moves the circuit from breadboard to a through-hole prototyping PCB, swaps the Arduino Nano for a lower-power Mini, and builds an ABS control box with buttons and a buzzer. The build uses a 2S LiPo pack with a 5V LDO and a nonmagnetic coil mount, with practical notes on tradeoffs and safety.
Three more things you need to know when transitioning from MCUs to FPGAs
Take a look at three more important difference between FPGAs and MCUs: "code reuse" vs templating, metastability and blocking vs. non-blocking operations.
Real-time clocks: Does anybody really know what time it is?
Most RTC chips still expose calendar fields rather than seconds-since-epoch, forcing embedded engineers to write ugly conversion code. Jason Sachs makes the case for offset encoding, subseconds, and an explicit snapshot feature to simplify interval math, raise precision, and avoid rare timing bugs. Read this practical take on RTC trade-offs and a short wishlist for chip makers.
Introduction to Microcontrollers - Adding Some Real-World Hardware
Two blinking LEDs only teach you so much, so Mike designed a docking board that adds a 4x20 HD44780 LCD, a 4x4 button matrix, four LEDs, DIP switches and an ADC potentiometer for AVR and STM32 experiments. This post shows how to wire and drive the HD44780 in 4-bit mode, calibrate microsecond and millisecond software delays, use the busy flag to speed writes, and includes AVR example code to get the display running.
Important Programming Concepts (Even on Embedded Systems) Part III: Volatility
Jason Sachs takes volatility out of the basement and into practical embedded programming. He shows why data that can change outside your thread of control breaks assumptions, how the volatile qualifier in C/C++ and Java affects compiler and CPU behavior, and when to prefer shadow registers, locks, or proper concurrency libraries instead of ad hoc volatile usage.
Introduction to Microcontrollers - More Timers and Displays
Mike Silva walks through using a single hardware timer to create the illusion of parallel tasks, combining a millisecond tick, deadline checks, and a cyclic executive to run time-driven and event-driven work. He shows safe deadline code that handles timer rollover and ISR races, and provides practical STM32 examples including SysTick-driven delays, atomic GPIO BSRR writes for LCD control, and a button-driven display demo.
Working With ESP-C3-32S-Kit Dev Board
This hands-on guide walks through setting up the ESP-C3-32S-Kit with ESP-IDF, from installing the toolchain to flashing and monitoring a hello-world example. It shows JTAG debugging with OpenOCD and GDB, how to use the NimBLE BLE stack for peripheral and central roles, and how to capture and filter BLE traffic with a Nordic sniffer and Wireshark so you can inspect pairing and connection behavior.
Linear Feedback Shift Registers for the Uninitiated, Part VII: LFSR Implementations, Idiomatic C, and Compiler Explorer
Jason Sachs takes LFSR theory back to real hardware, showing multiple C implementations and dsPIC33E assembly to squeeze cycles out of Galois LFSR updates. He digs into idiomatic C pitfalls like rotate idioms, demonstrates tricks using unions and 16/32-bit views, and shows when inline assembly with SL/RLC and conditional-skip instructions pays off. The article also uses Compiler Explorer and supplies an MPLAB X test harness for verification.
Creating a GPIO HAL and Driver in C
Creating a GPIO Hardware Abstraction Layer (HAL) in C allows for flexible microcontroller interfacing, overcoming the challenge of variability across silicon vendors. This method involves reviewing datasheets, identifying features, designing interfaces, and iterative development, as detailed in the "Reusable Firmware" process. A simplified approach prioritizes essential functions like initialization and read/write operations, showcased through a minimal interface example. The post also highlights the use of AI to expedite HAL generation. A detailed GPIO HAL version is provided, featuring extended capabilities and facilitating driver connection through direct assignments or wrappers. The significance of a configuration table for adaptable peripheral setup is emphasized. Ultimately, the blog illustrates the ease and scalability of developing a GPIO HAL and driver in C, promoting hardware-independent and extensible code for various interfaces, such as SPI, I2C, PWM, and timers, underscoring the abstraction benefits.
Interfacing LINUX with microcontrollers
Fabien presents a practical pattern: put Internet- facing logic on a Linux board and keep time-critical I/O on a microcontroller, using a Raspberry Pi and a Teensy 3.0. He introduces MASL, a reusable userspace library that hides master-slave details and shows how to use userspace SPI, sysfs GPIO and epoll for programming, reset and event-driven signaling with working code examples.
How to Arduino - a video toolbox
Lonnie Honeycutt is kicking off a practical Arduino video series aimed at hobbyists who want the fastest, simplest way to get things working. The first few lessons cover the Arduino IDE, breadboards, a 16x2 LCD, servos, potentiometers, and analogRead. He also shares a behind-the-scenes look at his multi-camera filming setup and how it helps him focus on the project instead of the shot.
C++ on microcontrollers 2 - LPCXpresso, LPC-link, Code Sourcery, lpc21isp, linkerscript, LPC1114 startup
Wouter van Ooijen walks you through getting C++ to run on a tiny LPC1114 board using LPCXpresso hardware and a command-line toolchain. He demonstrates a minimal linker script and startup code that initialize .data and .bss and call C++ global constructors, shows how to flash via the on-chip bootloader with lpc21isp when LPC-link is locked, and includes practical GPIO and SysTick LED examples.
