Favorite Tools - Look Up Tables
Look up tables are one of the simplest but most effective tools in an embedded engineer's toolbox, and this post shows why. Using a keypad example the author demonstrates a static table of key behaviors that packs repeat rates, enum mappings, and debug names into one place so changing behavior or adding keys is trivial. The article also outlines other uses like state machines and UI internationalization.
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.
Best Firmware Architecture Attributes
A poor firmware architecture makes future product variants and team work costly; Dr. Tayyar GUZEL outlines the attributes that avoid that fate. The post emphasizes modularity, low coupling, and encapsulation, and shows how a hardware abstraction layer, blackboard pattern, and CI-based unit testing improve extensibility, portability, and robustness. Practical tips include using setter/getter APIs, Doxygen for dependency graphs, and nightly regression to catch interface breaks early.
Modern Embedded Systems Programming: Beyond the RTOS
Blocking-based RTOS tasks make embedded systems brittle and hard to extend, this post argues, and presents a practical alternative: active objects organized as message pumps. It explains why one-blocking-call tasks and nonblocking event handlers improve responsiveness and reduce task proliferation, and recommends using frameworks plus hierarchical state machines and UML to enforce good architecture and make designs scalable.
Embedded Firmware Refactoring, Optimisation and Migration
Legacy embedded products often hit CPU, memory, or power limits long before customers stop wanting new features. This article lays out three practical paths: squeeze more from the current build with optimisation, make the codebase maintainable through refactoring, or port firmware to new hardware when constraints demand it. Read on for a pragmatic view of when each approach makes sense and how to reduce risk.
Cutting Through the Confusion with ARM Cortex-M Interrupt Priorities
ARM Cortex-M interrupt priorities are famously confusing because numeric priority values are inverted relative to urgency and several different conventions coexist. This post cuts through the mess by explaining NVIC register bit placement, the CMSIS NVIC_SetPriority convention, preempt versus subpriority grouping, and when to use PRIMASK or BASEPRI. Read on for practical rules to avoid subtle priority bugs in real-time firmware.
Cortex-M Exception Handling (Part 2)
Exception entry and return on Cortex-M look simple, but the hardware does a lot to preserve context, enforce privilege, and pick the right stack. This post walks through the processor actions after an exception is accepted: which registers get pushed, how CONTROL, MSP and PSP affect stack selection, how EXC_RETURN encodes the return path, and why VTOR and vector table alignment matter for handler lookup.
Analyzing the Linker Map file with a little help from the ELF and the DWARF
Running out of Flash or RAM is a familiar pain for firmware engineers, and the linker map only tells part of the story. This post shows how to combine the linker MAP with ELF symbol tables and DWARF debug info to recover static symbols, sizes, and source files that the map omits. It also describes a C# WinForms viewer that automates the parsing with binutils and helps you spot module and symbol-level memory waste.
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.
Coding Step 4 - Design
Good embedded software design is about more than making code work, it is about making it readable, reusable, testable, debuggable, robust, and efficient. In this installment of the Coding Step series, Stephen Friederichs uses an AVR-based “Hello World” example to show how those goals shape naming, file structure, UART buffering, watchdog use, and heartbeat LEDs. The result is a practical design walkthrough that turns style and architecture choices into engineering advantages.
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.
Embedded Programming Video Course Teaches RTOS
From basic foreground/background loops to priority-inheritance protocols, this free video course walks you through building and improving an RTOS step by step. Lessons cover manual context switching, round-robin and preemptive priority schedulers, efficient thread blocking, and synchronization primitives. The series finishes with a practical port to a professional RTOS in the QP/C ecosystem, showing semaphores, mutexes, and ways to prevent priority inversion.
ANCS and HID: Controlling Your iPhone From Zephyr
In this blog post, we see how certain BLE services can be used to control an iPhone from a Nordic nRF52840 using The Zephyr Project. Specifically, we see how to control certain multimedia functionality using the HID service. Finally, we learn how to use the ANCS client library provided by Nordic in The Zephyr Project to accept or decline an incoming call.
Zephyr: West Manifest For Application Development
In this blog post, I show a simpler way to create custom West manifest files. This technique eliminates the need to duplicate the complex West manifest from upstream Zephyr. I also show how we can use the West manifest to include out-of-tree board and SoC definitions, and include our own out-of-tree drivers.
How to make a heap profiler
A heap profiler is surprisingly simple to build, and Yossi Kreinin walks through a compact working example called heapprof. The post shows how to intercept malloc/free, stash per-allocation metadata and call stacks into heap chunks, dump memory on crash or via JTAG, and map return addresses to source lines with addr2line or gdb. It also covers practical bootstrapping tricks for platforms without standard libc support.
More than just a pretty face - a good UI is essential
A user interface can make or break a device - determining its success in the marketplace. With careful design, the UI can make the product compelling and result in a high level of satisfaction from new and experienced users.
Tenderfoot: Recommended Reading
Twenty years on, these are the books that turned an electrical engineer into an embedded software pro. Matthew Eshleman walks through influential reads from Code Complete to Practical Statecharts and Test Driven Development, explaining how each shaped his design, estimation, and testing practices. This short list is a practical starting point for 'tenderfoots' launching an embedded firmware career.
Designing Embedded System with FPGA - 1
Getting an embedded system running on an FPGA is much simpler than it sounds when you use Xilinx EDK and a soft processor. Pragnesh Patel walks through a beginner-friendly approach using the MicroBlaze CPU, drag-and-drop IP cores, and a Spartan-3E starter kit so you can assemble peripherals without deep VHDL knowledge. The post focuses on the EDK base system builder and first setup steps to generate a working design.
Favorite Tools: C++11 std::array
Firmware teams that avoid malloc or new need safer alternatives, and this post makes a strong case for C++11 std::array as that alternative. It highlights zero-overhead, type-safe, compile-time buffers and points to an ESP32 LED-strip demo where NUM_PIXELS_ fixes RAM usage at build time. Read it to see std::array used with std::rotate, passed to C libraries via data(), and as a low-risk path to std::vector later.
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.
Coding Step 4 - Design
Good embedded software design is about more than making code work, it is about making it readable, reusable, testable, debuggable, robust, and efficient. In this installment of the Coding Step series, Stephen Friederichs uses an AVR-based “Hello World” example to show how those goals shape naming, file structure, UART buffering, watchdog use, and heartbeat LEDs. The result is a practical design walkthrough that turns style and architecture choices into engineering advantages.
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.
Getting Started With Zephyr: Devicetree Bindings
This blog post shines some light on how devicetrees are used in The Zephyr Project. Specifically, we understand the mechanisms that enable us to use nodes in the devicetree in the C source files. We use a sample provided in the Zephyr repository itself and work our way through portions of the Zephyr codebase to get insight into the mechanisms that make this possible.
Finite State Machines (FSM) in Embedded Systems (Part 3) - Unuglify C++ FSM with DSL
Domain Specific Languages (DSL) are an effective way to avoid boilerplate or repetitive code. Using DSLs lets the programmer focus on the problem domain, rather than the mechanisms used to solve it. Here I show how to design and implement a DSL using the C++ preprocessor, using the FSM library, and the examples I presented in my previous articles.
Video-Based STEM Embedded Systems Curriculum, Part 1
This curriculum shows how to teach introductory embedded systems using free online videos and low-cost kits, suitable for middle-school, high-school, college, or adult learners. It packages curated educator recommendations, a per-student equipment and book list, essential free software, and core lesson topics like Arduino, MicroPython, Kicad board design, soldering, and RTOS basics. The approach stresses hands-on labs, safety, backups, mentorship, and adapting to local budgets.
Why Containers Are the Cheat Code for Embedded DevOps
Embedded software teams have long accepted toolchain setup as “part of the job,” but it’s a hidden productivity killer. Manual installs waste days, slow onboarding, and derail CI pipelines with “works on my machine” issues. While enterprise software solved this years ago with containerization, many embedded teams are still stuck replicating fragile environments. Containers offer a proven fix: a portable, reproducible build environment that works identically on laptops and CI servers. No brittle scripts, mismatched versions, or wasted time—just code that builds. IAR has gone further by delivering pre-built, performance-tuned Docker images for Arm, RISC-V, and Renesas architectures, ready for GitHub Actions and CI/CD pipelines. For regulated industries, containers simplify audits and compliance by enabling validation once and reuse everywhere. The result: faster onboarding, consistent builds, and stronger safety assurance. Containers aren’t a luxury—they’re the cheat code embedded teams need to modernize DevOps and compete effectively.
Assembly language is best - except when it isn’t
A look at why writing in C often produces more efficient code than hand-written assembly language.
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.
Deeply embedded design example - Logic replacement
Gene Breniman shows how a tiny PIC10F200 can replace a forest of discrete timing components to control six 10A H-bridges, letting firmware tune sequencing to cut EMI and reduce cost. He walks through analyzing the original RC/inverter delays, choosing the PIC, pinout and timer setup, and implementing compact assembly firmware that reproduces and improves the timing behavior. The result is fewer parts, saved board space, and better EMI control.
Surprising Linux Real Time Scheduler Behavior
An embedded Linux data acquisition project ran into puzzling UART latency whenever heavy UI animations ran. Moving all app threads to SCHED_FIFO helped but did not eliminate delays. After reading about kernel worker thread interactions, Matthew moved the UI back to the normal scheduler and the jitter vanished. The post highlights an unexpected kernel level priority inversion risk and a pragmatic workaround.
