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.
The three laws of safe embedded systems
This short article is part of an ongoing series in which I aim to explore some techniques that may be useful for developers and organisations that are beginning their first safety-related embedded project.
Developing software for a safety-related embedded system for the first time
Developing a safety-related embedded product is not the same as writing ordinary firmware, and this article lays out eight practical steps to get you started. Using a washing-machine controller as a running example, it covers scoping, key requirements, hazard analysis, applicable standards, platform and MCU choices, runtime monitoring, and prototyping. The checklist helps teams prepare for verification, testing, and later certification work.
“Smarter” cars, unintended acceleration – and unintended consequences
Smarter cars are arriving fast, but the software tricks behind them may be creating new safety and compliance risks. This post connects Tesla’s autopilot, the VW emissions scandal, and a reported Porsche throttle-delay case to ask whether automotive standards and regulations are keeping pace with increasingly intelligent vehicle control systems.
Coding Step 3 - High-Level Requirements
Stephen Friederichs turns the series toward embedded code by showing how to write a single high-level requirement for an embedded Hello World. He explains when requirements pay off, how they support testing and scope control, and why you should not write them for every small script. He then lays out five practical rules and applies them to a concrete EHW-001 serial transmission requirement.
Lessons Learned from Embedded Code Reviews (Including Some Surprises)
Jason Sachs recounts a round of motor-controller code reviews and the practical lessons his team learned about quality and tooling. He explains how a simple "ready for review" checklist and automated style checks kept meetings focused on substantive issues, and why choosing the right review tool matters after discovering lost comments in Stash. Read for concrete tips on process, subgit mirroring, vera++, and Upsource.
Dark Corners of C - The Comma Operator
Ever seen a line like if (!dry_run && ((stdout_closed = true), close_stream(stdout) != 0)) and wondered what that comma means? Stephen Friederichs unpacks the rarely-discussed C comma operator, shows a circular-buffer example where it seemed to simplify looping, then demonstrates how precedence and readability problems (and even MISRA C bans) make it dangerous in practice. Read on for practical uses and cautionary lessons.
Ten Little Algorithms, Part 4: Topological Sort
Jason Sachs detours from signal processing to make topological sort feel practical and even a little funny, using a Martian Stew recipe to illustrate dependencies and cycles. He walks through two canonical algorithms, Kahn’s method and the depth-first-search variant, compares adjacency-list and matrix graph representations, and provides complete Python implementations so you can run and inspect cycle detection and ordering yourself.
Open-Source Licenses Made Easy with Buildroot and Yocto for Embedded Linux
In this article I will try to explain what are the copyrights/copyleft, what are the popular opensource software licenses, and how to make sure that your Embedded Linux system complies with them using popular build systems ; Buildroot or YOCTO projec
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.
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.
Parlez vous Fortran?
A look at the variety of programming languages that are [or have been] used for embedded and some thoughts on the future possibilities.
Dark Corners of C - The Comma Operator
Ever seen a line like if (!dry_run && ((stdout_closed = true), close_stream(stdout) != 0)) and wondered what that comma means? Stephen Friederichs unpacks the rarely-discussed C comma operator, shows a circular-buffer example where it seemed to simplify looping, then demonstrates how precedence and readability problems (and even MISRA C bans) make it dangerous in practice. Read on for practical uses and cautionary lessons.
Donald Knuth Is the Root of All Premature Optimization
Knuth's famous line "premature optimization is the root of all evil" has turned into a blunt rule on forums, Jason Sachs argues, and that overuse masks important nuance. He walks through concrete embedded examples, from dsPIC33E floating-point timings to an ROI analysis in the Kittens Game and a continuous optimization toy problem, to show when to measure, when to speculate, and why profilers can mislead.
Embedded Toolbox: Programmer's Calculator
A tiny but powerful cross-platform tool, QCalc evaluates full C-syntax expressions so you can paste results straight into firmware. It handles bitwise ops, mixed hex/decimal/binary constants, and scientific math, and it automatically shows integer results in formatted hex and binary. The post explains key features, variable handling, error messages, and how to run qcalc.tcl with the wish Tk interpreter.
C++ on microcontrollers 1 - introduction, and an output pin class
Wouter van Ooijen shows how small C++ abstractions make GPIO code portable and reusable. Starting from a simple output_pin interface he implements concrete pins for an LPC2148 GPIO and a 74HC595 shift register, then composes behaviors with wrappers like tee and invert. The post demonstrates virtual methods, references, and constructor initialization lists to build drivers you can reuse across boards.
Getting Started with the Microchip PIC® Microcontroller
This first post of a five part series looks at the available hardware options for getting started with Microchip 8-bit PIC® Microcontroller, explores the MPLAB® X Integrated Development Environment and walks through setting up a project to expose the configured clock to an external pin and implement a single output GPIO to light an LED.
Software is free and can right any wrong
Software changes are so much easier than hardware modifications, so the temptation is always to take this approach to fixing bugs. This may not always be a good idea.
Working with Microchip PIC 8-bit Interrupts
This fifth and final post of the Getting Started with Microchip PIC 8 Bit Development series looks at interrupts on 8-bit PIC microcontrollers. After a review of basic interrupt functionality, an actual implementation is explored with the development of a four bit counter driven via Timer0 interrupts whose value is displayed through four LEDs on Microchip's Curiosity HPC Development Board.
Review: Modern Software Engineering
Long-lived branches, manual releases, and slow feedback waste engineering time. This review of three Dave Farley books distills a practical playbook: continuous delivery pipelines, trunk-based development, and disciplined TDD to keep trunk always releasable. It shows how fast, automated feedback at every stage shrinks cycle time, reduces merge pain, and makes teams far more productive.
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.
The Hardest Bug I Never Solved
A single overlooked sentence in the STM32 datasheet turned intermittent startup resets into a major time-leach. Senior engineers chased DMA buffers and overflows for hours until Unni discovered the ISR vector table had been relocated to RAM with only 256 byte alignment while the MCU required 512 bytes. The misalignment caused interrupts to jump to the reset handler, and fixing the alignment stopped the reboot loop for good.
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.
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.
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.
Getting Started with the Microchip PIC® Microcontroller
This first post of a five part series looks at the available hardware options for getting started with Microchip 8-bit PIC® Microcontroller, explores the MPLAB® X Integrated Development Environment and walks through setting up a project to expose the configured clock to an external pin and implement a single output GPIO to light an LED.
C++ on microcontrollers 3 – a first shot at an hc595 class with 8 output pins
A simple HC595 wrapper turns into a nice C++ lesson in how to build reusable I/O abstractions for microcontrollers. Wouter van Ooijen shows how to expose all eight shift-register outputs as regular output pin objects, then generalizes the same pattern to MCU ports and even daisy-chained HC595 chips. Along the way, he runs into a classic class dependency problem and resolves it with forward declarations and out-of-class method definitions.
Vala applications on Embedded Linux: maybe a clever choice [part 1]
If you need a high-level language for constrained embedded Linux devices, Vala is worth a look. It compiles to C and relies mainly on GLib, giving you native performance and minimal runtime dependencies. With reference counting instead of a garbage collector, modern language features, and a small storage footprint, Vala can outperform Python, Java, or Qt on low-RAM, low-storage boards. This first part focuses on dependencies, ABI compatibility, runtime characteristics, and a real-world example.
