Linear Feedback Shift Registers for the Uninitiated, Part XVII: Reverse-Engineering the CRC
You Don't Need an RTOS (Part 1)
In this first article, we'll compare our two contenders, the superloop and the RTOS. We'll define a few terms that help us describe exactly what functions a scheduler does and why an RTOS can help make certain systems work that wouldn't with a superloop. By the end of this article, you'll be able to: - Measure or calculate the deadlines, periods, and worst-case execution times for each task in your system, - Determine, using either a response-time analysis or a utilization test, if that set of tasks is schedulable using either a superloop or an RTOS, and - Assign RTOS task priorities optimally.
Data Types for Control & DSP
There's a lot of information out there on what data types to use for digital signal processing, but there's also a lot of confusion, so the topic bears repeating.I recently posted an entry on PID control. In that article I glossed over the data...
Static or static
The keyword static in C and C++ has multiple uses, which are not always well understood.
Mutex vs. Semaphore - Part 1
It never ceases to amaze me how often I see postings in forums asking the difference between a semaphore and a mutex. Probably what baffles me more is that over 90% of the time the responses given are either incorrect or missing the key...
Creating a Hardware Abstraction Layer (HAL) in C
In my last post, C to C++: Using Abstract Interfaces to Create Hardware Abstraction Layers (HAL), I discussed how vital hardware abstraction layers are and how to use a C++ abstract interface to create them. You may be thinking, that’s great for C++, but I work in C! How do I create a HAL that can easily swap in and out different drivers? In today’s post, I will walk through exactly how to do that while using the I2C bus as an example.
Cutting Through the Confusion with ARM Cortex-M Interrupt Priorities
The insanely popular ARM Cortex-M processor offers very versatile interrupt priority management, but unfortunately, the multiple priority numbering conventions used in managing the interrupt priorities are often counter-intuitive, inconsistent,...
I Stopped Testing Embedded Systems by Hand. Here's What Replaced It.
Everardo Garcia walks through the shift from manual, terminal-based system-level testing to automated tests that run during development. He shows how OpenHTF (a framework originally built at Google for manufacturing lines) plus a laptop, a USB cable, and ~150 lines of Python closes the functional testing gap most embedded teams carry, and how spec-driven prompting with GitHub Copilot makes writing plugs and phases fast enough to keep up.
Embedded Development Is Broken. Here's the Strategy I'm Betting My Company On.
Here's a 79-word summary: Embedded software complexity is growing about 4x per decade while developer productivity grows 1.5x, and regulations like the EU CRA are widening the gap further. After running a firmware services company through this shift, I've come to see three things separating the teams that are pulling ahead: using AI where the work is actually hard, designing security in from day one, and reading the standards that govern their market (62304, 26262, CRA) before writing code, not after.
Finite State Machines (FSM) in Embedded Systems (Part 5) - From One FSM to Many
Traditionally, complex systems are implemented using multi-threading and mutexes. Trying to scale up this approach usually results in a nightmare of data races and hidden bugs. A single Finite State Machine may bring order to chaos in applications, but cannot be scaled beyond a limit. In this installment, we explore the Actor Model: a shift from shared state to communicating state machines. Discover how treating FSMs as independent, message-passing entities can eliminate concurrency issues, simplify testing, and improve your embedded architecture.
Your Unit Tests Won't Find the Wolves: Why Embedded Developers Should Be Fuzzing
You test the happy paths. You check the well-formatted packets and the expected inputs. But real users don't read manuals, and real data doesn't follow your protocol spec. Fuzzing throws millions of randomized inputs at your code to find the crashes you never thought to look for. Here's why it matters for embedded systems.
Quickfire Heuristics: A Fast Usability Evaluation Framework for Lean Hardware Teams
That device with the single LED that requires you to count blink patterns just to understand system status. The button you must hold for 8 seconds, which also performs four other actions depending on hold duration. These are not accidents of negligence; they are the predictable output of development processes that have no rigorous usability evaluation component. Usability tends to slip through the gaps of standard engineering reviews, surfacing late, when design flexibility is already gone. This article introduces a framework that adapts Jakob Nielsen's Ten Usability Heuristics, for hardware and embedded systems, translating each principle into concrete evaluation questions for physical interfaces, firmware state machines, constrained displays, and cross-layer interactions. Using a smartwatch as the running example, it also introduces a structured session format, maps the framework to key lifecycle stages, and extends it to manufacturing, test, and field service contexts.
Embedded Linux Board Farms 101: The Requirements That Actually Matter
When you keep your embedded Linux boards in a rack or remote lab, the "plug in HDMI" workflow breaks down fast. One bad kernel push and SSH never comes back. This post lays out the core requirements for a real board farm: out-of-band serial console access, remote power cycling, and scripted reimaging so you never need someone on-site who knows Linux. Once those primitives are in place, everyday smart home devices — Tasmota switches, Home Assistant, environmental sensors — become legitimate development tools that bring enterprise lab capabilities to a hobbyist budget. Includes a pre-flight checklist for transitioning from KVM-style access to a fully remote setup, and a preview of the full implementation presented at the Embedded Online Conference in May.
Small Language Models (SLMs): The Future of AI is Smaller, Faster, and Closer to the Edge
AI industry is shifting from a "bigger is better" mentality to a focus on efficiency, localization, and real-world utility. The article argues that the AI industry is pivoting from massive, cloud-bound models toward Small Language Models (SLMs) designed for efficiency, speed, and edge deployment. Driven by the need to overcome cloud-centric hurdles like high latency, bandwidth costs, and privacy risks, SLMs (ranging from 100M to 14B parameters) leverage architectural innovations such as quantization, sparse attention, and high-quality synthetic data to deliver specialized intelligence on local hardware. Rather than replacing large models, SLMs represent a shift toward a hybrid intelligence future where the cloud provides depth while the edge provides real-time, sustainable action, ultimately moving the focus of AI progress from raw parameter count to practical, real-world utility.
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.
How to Deploy Local LLMs for Embedded Software Development: Terminology and Motivation
In this blog post series, I walk you through creating a fully local, offline AI pipeline. In this first post, I outline the motivation and relevant terminology that are important before we dive into hardware selection and implementation of the pipeline.
How to Estimate Encoder Velocity Without Making Stupid Mistakes: Part II (Tracking Loops and PLLs)
Yeeehah! Finally we're ready to tackle some more clever ways to figure out the velocity of a position encoder. In part I, we looked at the basics of velocity estimation. Then in my last article, I talked a little about what's necessary to...
Lost Secrets of the H-Bridge, Part IV: DC Link Decoupling and Why Electrolytic Capacitors Are Not Enough
Those of you who read my earlier articles about H-bridges, and followed them closely, have noticed there's some unfinished business. Well, here it is. Just so you know, I've been nervous about writing the fourth (and hopefully final) part of this...
Introduction to Microcontrollers - Beginnings
Welcome to this Introduction to Microcontroller Programming tutorial series. If you are looking to learn the basics of embedded programming for microcontrollers (and a bit of embedded hardware design as well), I hope these tutorials will help you...
How to Deploy Local LLMs for Embedded Software Development: Hardware Selection and Trade-offs
In this post, I map the LLM terminology covered in the previous post to real hardware decisions. I walk through memory sizing depending on different parameters, the core trade-off between discrete GPU VRAM and unified memory. Finally, I describe a workflow to help you identify which setup is right for your workflow.
Lost Secrets of the H-Bridge, Part V: Gate Drives for Dummies
Learn the most important issues in power MOSFET and IGBT gate drives: - Transistor behavior during switching - Calculating turn-on and turn-off times - Passive components used between gate drive IC and transistor - Reverse recovery - Capacitively-coupled spurious turn-on - Factors that influence a good choice of turn-on and turn-off times - Gate drive supply voltage management - Bootstrap gate drives - Design issues impacting reliability
Return of the Delta-Sigma Modulators, Part 1: Modulation
About a decade ago, I wrote two articles: Modulation Alternatives for the Software Engineer (November 2011) Isolated Sigma-Delta Modulators, Rah Rah Rah! (April 2013) Each of these are about delta-sigma modulation, but they’re...
C Is for Complacency: Friendship Is Not Transitive, but What About Module Dependencies?
In the C programming language, if module A depends on module B, and module B depends on module C, does this mean module A depends on module C? Well, it depends....
MSP430 Launchpad Tutorial - Part 1 - Basics
TI's LaunchPad is a complete MSP430 development environment: all you have to do is download and install CCS IDE (login required), connect your G2231-ready LaunchPad to your computer with the included mini-usb cable, and you are ready to...
Review: Embedded Software Design: A Practical Approach to Architecture, Processes, and Coding Techniques
Introduction Full disclosure: I was given a copy of this book to review. Embedded Software Design: A Practical Approach to Architecture, Processes, and Coding Techniques, by Jacob Beningo, is an excellent introduction to strategies for...
