Shibboleths: The Perils of Voiceless Sibilant Fricatives, Idiot Lights, and Other Binary-Outcome Tests
Binary tests look simple until you try to pick a threshold, because false positives, false negatives, and base rate all collide. Jason Sachs uses a deliberately absurd detective story, then walks through the math of expected value, medical screening tradeoffs, idiot lights, and even a triage-style three-way decision. The payoff is a practical way to think about when a pass/fail signal helps, and when raw data or a second test is worth the extra complexity.
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.
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.
Patents and the little guy working at home
Patents can look impressive, but for a solo engineer or small startup, they can also be an expensive distraction. This post argues that the patent system is badly broken and points to Don Lancaster’s advice, which is simple, avoid the mess unless you are operating at a very large scale. It is a blunt, practical take on when patents may not be worth the hassle at all.
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.
Which MOSFET topology?
Jason Sachs breaks down the four basic MOSFET topologies for switching a two-wire load, showing why low-side N-channel is usually the simplest and cheapest option. He explains why grounding or chassis return can force a high-side switch, how P-channel devices trade performance for simpler gate drive, and why high-side N-channel options need extra driver circuitry. He also stresses adding freewheeling diodes for inductive loads.
Elliptic Curve Cryptography - Security Considerations
The security of elliptic curve cryptography is determined by the elliptic curve discrete log problem. This article explains what that means. A comparison with real number logarithm and modular arithmetic gives context for why it is called a log problem.
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.
Voltage Drops Are Falling on My Head: Operating Points, Linearization, Temperature Coefficients, and Thermal Runaway
A lot of the neat, tidy diode and transistor rules you learned in school are really just approximations. Jason Sachs shows how operating points, linearization, and temperature coefficients give you a better mental model for real circuits, then uses that framework to explain why thermal runaway happens. Along the way, he connects the theory to practical device behavior, op-amp output stages, and the design tricks that keep parts from letting out the magic smoke.
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.
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.
The New Forum is LIVE!
The EmbeddedRelated forum just got a major interface refresh, and Stephane Boucher is rolling it out in beta. The new editor makes it easier to drop in images and files, add LaTeX equations with MathJax, and publish highlighted code snippets with highlight.js. Access is gated by approval for now, mainly to keep trolls, spammers, and bots out.
Embedded World 2018 - More Videos!
Two cinematic videos from Embedded World 2018 turn the show floor into slow-motion, stabilized footage using a Zhiyun Crane gimbal and a Sony a6300. One is a SEGGER booth highlights piece featuring Rolf Segger and Axel Wolf, the other is a roaming montage with appearances from Jacob Beningo, Micheal Barr, and Alan Hawse. Stephane asks viewers to enable audio and share feedback.
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.
You Don't Need an RTOS (Part 2)
In this second article, we'll tweak the simple superloop in three critical ways that will improve it's worst-case response time (WCRT) to be nearly as good as a preemptive RTOS ("real-time operating system"). We'll do this by adding task priorities, interrupts, and finite state machines. Additionally, we'll discuss how to incorporate a sleep mode when there's no work to be done and I'll also share with you a different variation on the superloop that can help schedule even the toughest of task sets.
How to Achieve Deterministic Behavior in Real-Time Embedded Systems
Ensuring deterministic behavior in real-time embedded systems is paramount for their reliability and performance. The ability to predict precisely how a system will respond to various inputs at any given time is crucial in critical applications such as medical devices, aerospace systems, and automotive safety mechanisms. Achieving deterministic behavior involves meticulous design, stringent testing, and adherence to strict timing constraints.
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.
Continuous Integration for Embedded Systems
Hardware dependencies make continuous integration for embedded systems harder than for pure software, yet it is essential for quality and faster feedback. This post explains the three CI types, host, non-host and hardware-in-the-loop, then compares trade-offs in cost, parallelism, timing accuracy and portability. It also outlines steps in a typical CI pipeline and highlights practical tools and plugins, including Jenkins and static analysis to automate builds and tests.
Going back to Germany!
A conference conversation turned into a return trip to Germany for Stephane Boucher, this time to visit SEGGER’s headquarters in Dusseldorf and produce videos. The post shares how a chance introduction at ESC Boston led to the invitation, and it teases coverage from SEGGER’s 25th anniversary celebration. He also invites local tips and customer questions before the trip.
Trust, but Verify: Examining the Output of an Embedded Compiler
Jason Sachs argues embedded engineers should read their compiler's assembly even if they rarely write assembly. He walks through Microchip XC16 output for dsPIC33 devices, showing how simple C variants and optimization flags produce very different code. The article demonstrates practical verification techniques and a tiny Python helper, pyxc16, to quickly inspect assembly for timing-sensitive firmware without rewriting everything in assembly.
March is Oscilloscope Month — and at Tim Scale!
Jason Sachs just upgraded his lab with an Agilent MSOX3034A after snagging a vendor promotion, and he walks through first-day wins from probe compensation to scripting. He shows why 10x probes need capacitive matching and how to use the scope's calibration square wave to compensate them. He also covers connecting the MSOX3000 to Python via pyvisa and SCPI, including decoding waveform data for export.
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.
Specifying the Maximum Amplifier Noise When Driving an ADC
You can quantify how much amplifier noise is acceptable before adding gain actually hurts an ADC's output SNR. Rick Lyons presents a compact rule showing the amplifier input-referred noise power must be less than (1 - 1/α^2) times the ADC's q^2/12 quantization noise power, with Eq. (8) and a pair of figures that make it easy to pick or specify the right amplifier for a given gain α.
Project Directory Organization
A tidy project tree can make a bigger difference than you might think. Stephen Friederichs lays out a practical directory scheme for small software projects, using familiar folders like src, obj, bin, test, reports, docs, and conf to keep builds, tests, and documentation from turning into a mess. He also explains why the root directory should welcome contributors, not confuse them.
