3 Overlooked Embedded Software Elements
Jacob Beningo points out three often-overlooked elements that can make embedded projects less painful and faster to ship. He highlights model-generated code for off-target iteration, configuration-generated code to manage SKUs and avoid fragile conditional compilation, and automated test harnesses to catch regressions early. The post gives practical reasons to consider each approach and how they fit into modern embedded DevOps.
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.
Scorchers, Part 3: Bare-Metal Concurrency With Double-Buffering and the Revolving Fireplace
Jason Sachs presents a practical, low-overhead concurrency pattern for tiny bare-metal systems where an ISR (Speedy) must safely exchange data with a nonreal-time main loop (Poky). He describes the "revolving fireplace", a double-buffering variant that swaps ownership of two shared memory regions, and walks through C examples, atomic/volatile considerations, and testing strategies so you can implement it on RAM-constrained MCUs.
Round-robin or RTOS for my embedded system
Manuel Herrera walks through the practical tradeoffs between bare-metal round-robin loops and adopting an RTOS for embedded projects. He outlines two round-robin styles, explains how an RTOS gives independent threads and synchronization primitives, and highlights added code, licensing, interrupt latency, and the learning curve. Read this to sharpen decision criteria around timing guarantees, reuse, and whether an RTOS truly adds value to your firmware.
Designing Communication Protocols, Practical Aspects
When your MCU must talk to a PC or smartphone, a clear protocol saves time and headaches. This post gives practical guidance for fast bring-up: how to structure a compact header, keep payloads byte-aligned and debug-friendly, and reserve bits for future use. It also covers CRCs for integrity, timeout and retry strategies for resynchronisation, and the simple start code trick that makes debugging easier.
AI at the Edge - Can I run a neural network in a resource-constrained device?
AI at the edge is no longer science fiction, it can run on tiny, resource-constrained devices like Arm Cortex-M4 and M7 microcontrollers. This post introduces inference-only neural networks on MCUs, explains why edge AI matters for power, latency, and privacy, and points to practical toolchains such as STM32Cube.AI, Arm NN, and AWS Greengrass to get started quickly.
Introduction to Deep Insight Analysis for RTOS Based Applications
Debugging can consume over 40% of a development cycle, and Jacob Beningo argues RTOS projects need more than breakpoints and assertions. He presents deep insight analysis as a trio of techniques—RTOS-aware debugging, run-time analysis, and profiling with coverage—that expose what the system is actually doing. These methods help engineers cut guesswork and speed verification of complex embedded applications.
From bare-metal to RTOS: 5 Reasons to use an RTOS
Most developers default to bare-metal, but Jacob Beningo argues an RTOS often simplifies modern embedded design. He outlines five practical reasons to move to an RTOS: easier integration of connectivity stacks and GUIs, true preemptive scheduling with priorities, tunable footprints, API-driven portability, and a common toolset for tasks and synchronization. The piece helps decide when RTOS adoption speeds development.
From Baremetal to RTOS: A review of scheduling techniques
Jacob Beningo walks through five common embedded scheduling techniques, showing how each scales from a single super loop to a full RTOS. He highlights practical trade-offs for round-robin, interrupt-driven, queued, cooperative, and RTOS approaches so you can spot when timing becomes fragile and when added complexity is justified. This primer sets up the next post on when to adopt an RTOS.
Choosing a Microcontroller for Your Vehicle
Picking the right microcontroller can make or break an autonomous vehicle project, and this post gives a practical checklist to help. It walks through voltage and power needs, memory and IO planning, cost and availability tradeoffs, and when to step up from an 8-bit MCU to a 32-bit controller or single-board computer. Real-world board examples illustrate the choices.
Getting Started With Zephyr: Devicetree Overlays
In this blog post, I show how the Devicetree overlay is a valuable construct in The Zephyr Project RTOS. Overlays allow embedded software engineers to override the default pin configuration specified in Zephyr for a particular board. In this blog post, I use I2C as an example. Specifically, I showed the default I2C pins used for the nRF52840 development kit in the nominal Zephyr Devicetree. Then, I demonstrated how an overlay can be used to override this pin configuration and the final result.
Understanding Microchip 8-bit PIC Configuration
The second post of a five part series picks up getting started developing with Microchip 8-bit PIC Microcontroller by examining the how and why of processor configuration. Topics discussed include selecting the oscillator to use during processor startup and refining the configuration once the application starts. A walk through of the code generated by the Microchip IDE provides a concrete example of the specific Configuration Word and SFR values needed to configure the project specific clock configuration.
Metal detection: beat frequency oscillator
Fabien Le Mentec walks through a practical beat frequency oscillator metal detector, from the LC oscillator theory to the Arduino-based frequency counter. He shows how changes in coil inductance reveal nearby metal, and why capacitor choice matters when you want a stable detector. The post focuses on the BFO sensing stage, with enough detail to help you build and test one yourself.
Getting Started with (Apache) NuttX RTOS Part 2 - Looking Inside and Creating Your Customized Image
This hands-on guide peels back the NuttX source tree and shows how to assemble a tailored firmware image. You will learn what each top-level directory does, how to enable apps with menuconfig and search tricks to resolve dependencies, and how to save a defconfig as a reusable board profile so you can rebuild the same image without repeating configuration steps.
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.
Working with Microchip PIC 8-bit GPIO
The third in a series of five posts looks at GPIO with PIC 8-bit microcontrollers. After a detailed review of the registers for configuring and managing GPIO on the PIC18F47Q10 processor, a basic application is stood up programming those registers to blink external LEDs at 0.5Hz.
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.
Cortex-M Exception Handling (Part 1)
This article describes how Cortex-M processors handle interrupts and, more generally, exceptions, a concept that plays a central role in the design and implementation of most embedded systems.
Introduction to Microcontrollers - Further Beginnings
Mike Silva walks through the CPU plumbing every embedded engineer needs to know before writing their first LED blinky. The post explains registers (data, address, stack pointer, link), the fetch-execute cycle, and the main instruction classes such as arithmetic, logic, shifts, branches, and call/return mechanics. Read this to see how C maps to CPU operations and why stack versus link register choices matter.
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.
C to C++: 5 Tips for Refactoring C Code into C++
The article titled "Simple Tips to Refactor C Code into C++: Improve Embedded Development" provides essential guidance for embedded developers transitioning from C to C++. The series covers fundamental details necessary for a seamless transition and emphasizes utilizing C++ as a better C rather than diving into complex language features. The article introduces five practical tips for refactoring C code into C++. Replace #define with constexpr and const: Discouraging the use of #define macros, the article advocates for safer alternatives like constexpr and const to improve type safety, debugging, namespaces, and compile-time computation. Use Namespaces: Demonstrating the benefits of organizing code into separate logical groupings through namespaces, the article explains how namespaces help avoid naming conflicts and improve code readability. Replace C-style Pointers with Smart Pointers and References: Emphasizing the significance of avoiding raw pointers, the article suggests replacing them with C++ smart pointers (unique_ptr, shared_ptr, weak_ptr) and using references
Metal detection: beat frequency oscillator
Fabien Le Mentec walks through a practical beat frequency oscillator metal detector, from the LC oscillator theory to the Arduino-based frequency counter. He shows how changes in coil inductance reveal nearby metal, and why capacitor choice matters when you want a stable detector. The post focuses on the BFO sensing stage, with enough detail to help you build and test one yourself.
Scorchers, Part 3: Bare-Metal Concurrency With Double-Buffering and the Revolving Fireplace
Jason Sachs presents a practical, low-overhead concurrency pattern for tiny bare-metal systems where an ISR (Speedy) must safely exchange data with a nonreal-time main loop (Poky). He describes the "revolving fireplace", a double-buffering variant that swaps ownership of two shared memory regions, and walks through C examples, atomic/volatile considerations, and testing strategies so you can implement it on RAM-constrained MCUs.
Getting Started With Zephyr: Devicetree Overlays
In this blog post, I show how the Devicetree overlay is a valuable construct in The Zephyr Project RTOS. Overlays allow embedded software engineers to override the default pin configuration specified in Zephyr for a particular board. In this blog post, I use I2C as an example. Specifically, I showed the default I2C pins used for the nRF52840 development kit in the nominal Zephyr Devicetree. Then, I demonstrated how an overlay can be used to override this pin configuration and the final result.
7 Essential Steps for Reducing Power Consumption in Embedded Devices
Reducing the amount of power your embedded device is consuming is not trivial. With so many devices moving to battery operations today, maximizing battery life can be the difference between a happy, raving customer and an unhappy one that ruins your company's reputation. This post explores seven steps for optimizing your embedded systems' power consumption. You'll gain insights into the steps and techniques necessary along with receiving a few resources to help you on your journey.
Round-robin or RTOS for my embedded system
Manuel Herrera walks through the practical tradeoffs between bare-metal round-robin loops and adopting an RTOS for embedded projects. He outlines two round-robin styles, explains how an RTOS gives independent threads and synchronization primitives, and highlights added code, licensing, interrupt latency, and the learning curve. Read this to sharpen decision criteria around timing guarantees, reuse, and whether an RTOS truly adds value to your firmware.
A wireless door monitor based on the BANO framework
Fabien Le Mentec built a battery-powered wireless door monitor and a reusable node framework called BANO to monitor doors across seven floors without wired links. The post highlights BANO's 17-byte key,value protocol, the node runtime that enables wake-on-interrupt low-power operation, and practical RF choices like the NRF905 plus a 330 µF cap to handle coin-cell transmission peaks. It includes source, PCB, and base station notes.
Designing Communication Protocols, Practical Aspects
When your MCU must talk to a PC or smartphone, a clear protocol saves time and headaches. This post gives practical guidance for fast bring-up: how to structure a compact header, keep payloads byte-aligned and debug-friendly, and reserve bits for future use. It also covers CRCs for integrity, timeout and retry strategies for resynchronisation, and the simple start code trick that makes debugging easier.
Arduino robotics #2 - chassis, locomotion and power
Lonnie Honeycutt walks through building Clusterbot's round differential-drive chassis, showing how a circular base and Tamiya gearbox simplify turning and torque tradeoffs. The post covers motor selection, wheel fit, balance issues, and a practical two-battery power arrangement with VMOT for the motors and a separate 9V for the Arduino. Expect hands-on tips and lessons learned from a first-time robot build.
Reverse engineering wireless wall outlets
Fabien Le Mentec reverse engineers a cheap set of wireless wall outlets to add them to his BANO home automation while avoiding uncertified mains hardware. He uses PCB inspection to identify a Holtek MCU and RF83C, captures 433.92 MHz OOK signals with an RTL-SDR and ookdump, then replays commands using an RFM22 in direct mode controlled by an ATmega328P. The post explains frame structure and links to a working GitHub implementation.
