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.
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.
Tenderfoot: Introduction to Magic (Numbers that is...)
A source-code review revealed repeated numeric literals in C, exposing the classic problem of magic numbers in embedded software. This post explains what magic numbers are, why they are especially painful in firmware, and simple fixes using named constants and comments tied to specs. Read this if you want clearer, safer embedded C code and fewer surprises during maintenance.
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.
Intel 8088 - A blast from the past
The Intel 8088 is a reminder of how hands-on early microcomputer work really was. This short retrospective looks back at wire-wrapping, perfboard construction, and assembly language programming on a board built around the 8088 and its support chips. It is a fun contrast to today’s Raspberry Pi era, where far more performance comes in a sealed package you can’t build yourself.
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.
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.
Round Round Get Around: Why Fixed-Point Right-Shifts Are Just Fine
Jason Sachs explains why, in most embedded systems, simple bitwise right-shifts are an acceptable way to do fixed-point division rather than paying the runtime cost to round. He shows the cheap trick of adding 2^(N-1) to implement round-to-nearest, explains unbiased "round-to-even" issues, and compares arithmetic error to much larger ADC and sensor errors. The takeaway: save cycles unless your algorithm or inputs require extra precision.
Favorite Tools: C++11 User-defined literals
Units are a frequent source of bugs in embedded software, and keeping code aligned with product specs helps prevent mistakes. This post shows how C++11 user-defined literals let you write expressive, type-safe unit values like 80_MPH and convert them to meters per second using constexpr operator"" overloads. The conversion happens at compile time, improving readability and reducing reliance on macros or magic numbers.
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.
Dumb Embedded System Mistakes: Running The Wrong Code
Running the wrong firmware on a board can waste hours. This post shows a practical marking strategy for embedded Linux that embeds searchable proof-of-life strings into kernel, rootfs, overlay, and application code. It walks through choosing early-boot log points, using compile-time timestamps, and a small shell script to set, find, and clear marks so you can verify builds before flashing.
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.
How to Build a Fixed-Point PI Controller That Just Works: Part II
Jason Sachs walks through practical, battle-tested rules for implementing PI controllers in fixed-point arithmetic. He explains Q-format choices, why the integrator needs extra fractional bits, and why scale-then-integrate simplifies design. The post also covers proportional gain scaling, saturation and anti-windup, and common C pitfalls that cause overflow or lost resolution on 16/32-bit microcontrollers.
Energia - program a TI MSP430 using Arduino sketches
Energia brings Arduino simplicity to TI's MSP430, turning a fiddly toolchain into a sketch-based workflow you already know. Lonnie Honeycutt walks through why the Launchpad is a great low-cost dev option, outlines supported MSP430 families and caveats like 3.3 volt I/O, and shows a Halloween LED jack-o-lantern sketch to prove how quickly you can get blinking LEDs.
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.
Debug, visualize and test embedded C/C++ through instrumentation
Instrumenting a firmware is a highly effective methodology for debugging and testing an embedded softwares. In this article, I will present a way of achieving this using Scrutiny, an open-source software suite developed as a personal initiative, designed to streamline debugging, telemetry, and hardware-in-the-loop (HIL) testing for embedded devices.
Intel 8088 - A blast from the past
The Intel 8088 is a reminder of how hands-on early microcomputer work really was. This short retrospective looks back at wire-wrapping, perfboard construction, and assembly language programming on a board built around the 8088 and its support chips. It is a fun contrast to today’s Raspberry Pi era, where far more performance comes in a sealed package you can’t build yourself.
Small or fast?
Developers of software for desktop computers take code optimization for granted. Embedded developers typically need to pay much more attention to the details
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.
Ada 2012 for ARM M3/M4 Released for Download
AdaCore's initial Ada 2012 port for ARM Cortex M3/M4 is now downloadable, and Mike Silva walks it through a hands-on demo on an STM32F4 Discovery board. He shows an Ada-written LCD driver, LED multitasking, and how Ada language features like Ada.Realtime, array slices, and unchecked conversions make low-level GPIO and timing code clearer and safer. The post highlights atomic BSRR GPIO writes and Ravenscar runtime details.
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.
Dumb Embedded System Mistakes: Running The Wrong Code
Running the wrong firmware on a board can waste hours. This post shows a practical marking strategy for embedded Linux that embeds searchable proof-of-life strings into kernel, rootfs, overlay, and application code. It walks through choosing early-boot log points, using compile-time timestamps, and a small shell script to set, find, and clear marks so you can verify builds before flashing.
Acceptance Tests vs. TDD
Writing the tests in a Jira ticket is not the same as doing TDD, this post explains why. It separates acceptance tests, which define business completeness and are written up-front by the customer, from TDD unit tests, which developers write incrementally as a design and feedback tool. Readable advice covers test speed, avoiding brittle tests, and how both test types fit into CI and maintainable embedded development.
Six Software Design Tools
Software design need not be mysterious, these six practical tools give a disciplined way to shape readable, testable, and maintainable code. The post walks through naming (DAMP), duplication control (DRY), complexity metrics (MCC), SOLID principles, API layering, and test-driven development, showing how each idea applies across languages and embedded systems. Use them as checklists for code reviews and design thinking.
You Don't Need an RTOS (Part 4)
In this fourth (and final!) article I'll share with you the last of the inter-process communication (IPC) methods I mentioned in Part 3: mailboxes/queues, counting semaphores, the Observer pattern, and something I'm calling a "marquee". When we're done, we'll have created the scaffolding for tasks to interact in all sorts of different the ways. Additionally, I'll share with you another alternative design for a non-preemptive scheduler called a dispatch queue that is simple to conceptualize and, like the time-triggered scheduler, can help you schedule some of your most difficult task sets.
Embedded Toolbox: Windows GUI Prototyping Toolkit
You can prototype and debug complex embedded device user interfaces on Windows using the tiny, free QWin toolkit. It runs the same C code you compile for the target by implementing a Windows BSP, letting you develop UI code quickly with MinGW or Visual C++ and a visual resource editor. The result is far faster compile-run-debug cycles and a simpler path around flaky prototype hardware.
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.
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.
Blocking == Technical Debt
Blocking code in embedded systems trades quick development for long-term pain, effectively becoming technical debt. This post shows how blocking in Arduino examples and traditional RTOS threads hard-codes sequences and timing, making change and extension expensive. It contrasts blocking kernels with preemptive non-blocking approaches and recommends event-driven Active Objects and frameworks like QP as more scalable alternatives.
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.
