Jaywalking Around the Compiler
Messing with inline assembly can feel powerful until the compiler silently undoes you. Jason Sachs walks through a real bug on a Microchip dsPIC33E where pushing CORCON and writing a fixed value corrupts compiler-managed state and produces wrong results when the compiler reorders code. The post shows why the stack and certain registers are off-limits to raw inline asm, and gives practical, safe patterns to save and restore mode bits.
Embedded Programming Video Course Shows How OOP Works Under the Hood
Want to see how OOP actually maps to machine level code? This free video course walks through encapsulation, inheritance, and polymorphism with hands-on comparisons between C and C++. You will inspect C implementations, compiler-generated code, and debug traces, and learn how encapsulation relates to RTOS concurrency. The polymorphism lesson reverses the usual order to expose runtime costs and previews implementing polymorphism in C.
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.
Watchdog Timer Anti-patterns
A watchdog timer can be useless or even harmful when misused. This post catalogs the most common watchdog anti-patterns, including feeding the watchdog unconditionally from a timer ISR, suspending it during long operations, sprinkling resets across code, timeout auctions, incomplete reset trees, and treating process supervision as a substitute for hardware. It finishes with practical rules to design watchdogs that genuinely improve embedded system reliability.
Linux Kernel Development - Part 1: Hello Kernel!
Skip userland and run code inside the kernel with a tiny "Hello Kernel" module that prints messages on load and unload. This introduction walks through required headers, the init and exit hooks, MODULE_* metadata, a kernel-friendly Makefile, and the basic workflow to build, insmod, rmmod and inspect messages with dmesg. It’s a hands-on first step into Linux kernel module development.
Mutex vs. Semaphores – Part 2: The Mutex & Mutual Exclusion Problems
Mutexes tackle many semaphore pitfalls by enforcing ownership and pairing lock and unlock operations, making mutual exclusion safer in RTOS code. This post explains how ownership enables recursion, priority inheritance and death detection, and why mutexes do not automatically solve circular deadlock or non-cooperative access. Read on for practical protocols such as Priority Inheritance and Priority Ceiling and a brief note on monitors.
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.
A brief overview of flight control software
Open source flight control software can feel like a maze of forks, retirements, and overlapping projects. In this post, the author builds a chart and comparison table to map how drone flight controller software evolved over time, using git commit history and repository data. It is a handy starting point if you want a quick overview of the current landscape before diving deeper.
Debugging DSP code.
Strange sinusoidal confidence scores from an HTM neural model revealed a familiar class of DSP bugs. Drawing from forum troubleshooting, the post maps common root causes: signed versus absolute value errors, wrong intermediate references, scaling mistakes, and sampling/stride problems in integer math. Embedded engineers will recognize the diagnostic clues and practical suspects to check first when DSP outputs vary with the input.
Mutex vs. Semaphore - Part 1
Most forum answers get the semaphore versus mutex debate wrong. This post traces semaphores back to Dijkstra and Scholten, explains the difference between binary and counting semaphores, and highlights runtime hazards such as accidental release, recursive and task-death deadlocks, priority inversion, and misuse as signals. Read if you want to avoid common concurrency pitfalls in RTOS code.
Getting Started With Zephyr: Kconfig
In this blog post, we briefly look at Kconfig, one of the core pieces of the Zephyr infrastructure. Kconfig allows embedded software developers to turn specific subsystems on or off within Zephyr efficiently and control their behavior. We also learn how we can practically use Kconfig to control the features of our application using the two most common mechanisms.
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.
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.
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.
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.
Never use Float or Integer
Ada treats numbers as more than just numbers, and that changes how embedded code fails. This post shows why you should avoid using Float and Integer directly, then demonstrates how distinct types, ranges, and subtypes let the compiler catch unit mix-ups and out-of-range values before runtime. It also shows the same code running on a Raspberry Pi Pico, and briefly introduces SPARK for proving correctness.
Coding Step 1 - Hello World and Makefiles
Stephen Friederichs walks through compiling a C Hello World using GCC on Windows, then shows how a simple makefile can automate the process. You will see how output naming, project layout, and makefile targets work, and learn dependency rules based on timestamps plus how to force rebuilds with clean and FORCE targets. This is a practical first step to escape the IDE and use Unix-style build tools.
Boot Sequence for an ARM based embedded system
Deeksha draws on five years in embedded systems to introduce the ARM boot sequence used on Boot ROM based platforms. The post outlines what the Boot ROM does at reset, how it probes boot media, and when control is passed to a software bootloader. It also highlights key differences between NOR XiP and NAND RAM-loading and the need for bad-block handling.
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.
Ada 2012 Comes to ARM Cortex M3/M4
Ada is not dead, and Mike Silva shows why by walking through Ada 2012 running on ARM Cortex‑M3/M4 hardware. He demos an STM32F4 LED-and-button example that highlights Ada advantages: strong typing, modular types, built-in time and tasking, and protected objects for safe concurrency without an RTOS. The post also notes AdaCore's GNAT tooling and links to further resources to get started.
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.
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.
Embedded Programming Video Course Shows How OOP Works Under the Hood
Want to see how OOP actually maps to machine level code? This free video course walks through encapsulation, inheritance, and polymorphism with hands-on comparisons between C and C++. You will inspect C implementations, compiler-generated code, and debug traces, and learn how encapsulation relates to RTOS concurrency. The polymorphism lesson reverses the usual order to expose runtime costs and previews implementing polymorphism in C.
UML Statechart tip: Handling errors when entering a state
Handling synchronous failures during state entry is trickier than the UML spec implies, because UML forbids transitions inside entry actions. This post compares three practical firmware patterns: explicit guarded transitions, self-posting a failure event to a LIFO queue, and converting the operation into an asynchronous service. It lays out benefits, downsides, and when each approach is appropriate for small teams, mid-sized projects, or larger firmware efforts.
C to C++: Templates and Generics – Supercharging Type Flexibility
"C to C++: Templates and Generics – Supercharging Type Flexibility" illuminates the rigidity of C when managing multiple types and the confusion of code replication or macro complexity. In contrast, C++ offers templates, acting as type-agnostic blueprints for classes and functions, which allows for the creation of versatile and reusable code without redundancy. By using templates, developers can define operations like add once and apply them to any data type, simplifying codebases significantly. Generics further this concept, enabling a single code structure to handle diverse data types efficiently—a boon for embedded systems where operations must be performed on varying data, yet code efficiency is critical due to resource limitations. The blog walks through practical applications, showcasing how templates streamline processes and ensure type safety with static_assert, all while weighing the pros and cons of their use in embedded software, advocating for careful practice to harness their full potential.
Simple Automated Log Processing
You don't need heavy tools to make sense of megabytes of embedded logs. This post shows a practical bash script that trims noisy serial and semihosting output, samples hourly heap-profile lines, and converts them into a CSV ready for graphing. It gives a simple, adaptable pattern you can reuse to spot memory leaks or triage recurring log signatures quickly.
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.
Global Variables vs. Safe Software
10,000 global variables is a striking code smell, and Stephen Friederichs uses the Toyota unintended-acceleration case to show why. He argues the issue was not mere coding style but absent processes: poor testing, lack of enforced standards, incorrect stack analysis, and unowned autogenerated code. Read this for a practical take on why globals and weak processes in safety-critical systems are a much bigger danger than style debates suggest.
Working with Strings in Embedded C++
This article discusses the use of strings in embedded systems. It explains how the need for and use of strings in embedded systems has changed with the advent of cheaper, full graphic displays and the growth of the ‘Internet of Things’ (IoT). The article also covers character literals, C-Strings and string literals, and the difference in memory models between them. It also highlights the safety and security issues that arise from using strings in embedded systems. Finally, it explains how C++11 introduced a Raw string literal type that is useful for storing file paths or regular expressions.
New book on Elliptic Curve Cryptography
New book on Elliptic Curve Cryptography now online. Deep discount for early purchase. Will really appreciate comments on how to improve the book because physical printing won't happen for a few more months. Check it out here: http://mng.bz/D9NA
