Return of the Delta-Sigma Modulators, Part 1: Modulation
Jason Sachs returns to delta-sigma modulators with a hands-on, code-first treatment that focuses on the DAC side of things. Part 1 walks through first- and second-order kernels, linearized analysis, spectra, and practical coefficient choices while illustrating results with Python simulations. Expect clear rules of thumb for A, R, and B, a derivation of noise shaping behavior, and a useful error bound for RC filtering.
C to C++: Bridging the Gap from C Structures to Classes
Jacob Beningo walks through a practical, beginner-friendly path from C structures to C++ classes for embedded systems, using an LED example to make the ideas concrete. You will see how function pointers in C approximate methods, how C++ structs and classes let you place methods with data, and how access specifiers and constructors improve encapsulation and initialization. This gives a low-risk way to start adopting C++ features.
The Missing Agile Conversation
In this article, we learn about Agile practices and how they use stories as units of development. Stories consist of a brief description, one to a few sentences. They don’t contain details sufficient to allow a developer to implement them. The Agile practice is to defer details as long as possible because conditions may change. When a developer takes on a story to implement, that’s the time for them to perform the work that has been deferred. They do this by having a conversation, a series of specific discussions working closely with the various SME’s (Subject Matter Experts) who have information relevant to the story.
STM32 B-CAMS-OMV Walkthrough
Want to prototype embedded vision quickly? This walkthrough shows how the STM32 B-CAMS-OMV camera module pairs with the STM32H747I-DISCO discovery kit and the FP-AI-VISION1 function pack to get you running in minutes. The video covers the camera connection interface, key software functions to control and process data, and the ISP features that let image processing run inside the camera. The STM32 H7 project with B-CAMS-OMV drivers is available on GitHub.
Free Sessions @ the 2023 Embedded Online Conference
The 2023 Embedded Online Conference has pre-released 37 theatre talks and demos you can watch for free today by creating an account and skipping payment. Stephane Boucher walks through the free sessions and the paid portion of the weeklong program, highlighting live Q&A, hands-on workshops, and keynote talks across April 24–28. Add sessions to your agenda and check the schedule daily for last-minute changes.
STM32 VS Code Extension Under The Hood
ST's STM32 VS Code extension hides useful CMake projects and VS Code tasks behind a friendly UI, but understanding what it generates lets you bend it to your needs. This video peels back the layers to show the generated CMake files, how to modify them, how to add a VS Code-invokable flash task, and how to enable C++ support alongside C. The STM32 F0 example and flash task are available on GitHub.
Getting Started With Zephyr: West Manifest Customization
Create a reproducible Zephyr development baseline by customizing a West manifest, so your team avoids surprises from upstream changes. This post walks through forking Zephyr and MCUBoot when you need local changes, adapting Nordic Semiconductor's west.yml as a template, and updating remotes and defaults to point at your forks. Finish by running west init -m
Back from Embedded World 2023
Embedded World 2023 brought Stephane Boucher back to Nuremberg after three years, and the scale of the show still impressed him, with more than 900 vendors on the floor. He also highlights the value of in-person networking, from catching up with Embedded Online Conference speakers to swapping travel stories over dinner. The trip wrapped with a side visit to Heidelberg, then a quick look ahead to the next Embedded Online Conference.
Cracking the (embedded) Coding Interview
Landing your first embedded job is thrilling, but surviving months of interviews is brutal. This post condenses one engineer’s recent experience into a pragmatic playbook, covering behavioral prep, targeted coding practice, and the embedded theory you actually get asked about. Read it for a focused roadmap: what to study, which platforms to use, and how to present yourself so interviewers root for you.
Visual Studio Code Extensions for Embedded Software Development
Visual Studio Code can be a solid embedded development environment, if you equip it with the right extensions. Jacob Beningo walks through tools for Cortex-M debugging, register and RTOS inspection, build system support, formatting, linting, and vendor-specific workflows. It is a practical tour of the extensions that help VS Code feel much less like a general-purpose editor and more like an embedded IDE.
Why Containers Are the Cheat Code for Embedded DevOps
Embedded software teams have long accepted toolchain setup as “part of the job,” but it’s a hidden productivity killer. Manual installs waste days, slow onboarding, and derail CI pipelines with “works on my machine” issues. While enterprise software solved this years ago with containerization, many embedded teams are still stuck replicating fragile environments. Containers offer a proven fix: a portable, reproducible build environment that works identically on laptops and CI servers. No brittle scripts, mismatched versions, or wasted time—just code that builds. IAR has gone further by delivering pre-built, performance-tuned Docker images for Arm, RISC-V, and Renesas architectures, ready for GitHub Actions and CI/CD pipelines. For regulated industries, containers simplify audits and compliance by enabling validation once and reuse everywhere. The result: faster onboarding, consistent builds, and stronger safety assurance. Containers aren’t a luxury—they’re the cheat code embedded teams need to modernize DevOps and compete effectively.
Data Types for Control & DSP
Control engineers often default to double precision, but Tim Wescott shows that choice can waste CPU cycles on embedded targets. He separates numeric representation into floating point, integer, and fixed-point, then walks through the tradeoffs, including quantization, overflow, and performance. A concrete PID example highlights why integrator precision and ADC scaling should drive your choice of data type rather than habit.
The Other Kind of Bypass Capacitor
Most engineers treat bypass capacitors as supply decoupling, but Jason Sachs digs into the other kind: a capacitor placed in the feedback path to tame unpredictable high-frequency plant behavior. He walks through real examples, Bode plots, and a simple RC model to show how the cap forces unity-gain feedback at high frequency, stabilizing switching regulators and wideband amplifiers while revealing the speed versus stability tradeoff.
Arduino robotics #3 - wiring, coding and a test run
Lonnie Honeycutt walks through wiring, coding, and the first test run of Clusterbot, a budget Arduino robot build costing about $50. The post provides a clear pin-mapping to the TB6612FNG motor driver, ready-to-upload Arduino movement functions, and practical tips like tinning thin battery wires. You also get PWM calibration values and the measured RPM timing the author used to make reliable turns.
Video-Based STEM Embedded Systems Curriculum, Part 2
Part 2 delivers three ready-to-run lesson plans for a video-based STEM embedded course, starting with Arduino hands-on projects using an Elegoo UNO starter kit and Bryan Vines video walkthroughs that explain the code. It then teaches Fritzing for pictorial and schematic circuit drawings, followed by Collin Cunningham videos that cover resistors, capacitors, transistors, schematics, and other core components. The sequence stresses design, draw, build, test to keep students engaged.
Working With ESP-C3-32S-Kit Dev Board
This hands-on guide walks through setting up the ESP-C3-32S-Kit with ESP-IDF, from installing the toolchain to flashing and monitoring a hello-world example. It shows JTAG debugging with OpenOCD and GDB, how to use the NimBLE BLE stack for peripheral and central roles, and how to capture and filter BLE traffic with a Nordic sniffer and Wireshark so you can inspect pairing and connection behavior.
Padé Delay is Okay Today
High-order Padé approximations for time delays break in surprising ways, but the failure is not magic. Jason Sachs walks through why coefficient-based transfer functions and companion-form state-space are numerically fragile, shows how to compute poles and zeros directly from the hypergeometric form with Newton iteration, and demonstrates building modal or block-diagonal state-space realizations to make high-order Padé delays practical while noting remaining limits.
Square root in fixed point VHDL
In this blog we will design and implement a fixed point square root function in VHDL. The algorithm is based on the recursive Newton Raphson inverse square root algorithm and the implementation offers parametrizable pipeline depth, word length and the algorithm is built with VHDL records and procedures for easy use.
C++ Assertion? Well Yes, But Actually No.
Assertions are a double-edged sword - on one side you enforce program correctness catching bugs close to their origin, on the other your application is subject to run-time error, like any interpreted language. This article explores what C++ can offer to get the advantages of assertions, without risking the crashes by moving contract checking at compile time.
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.
Review: Hands-On RTOS with Microcontrollers
Brian Amos's Hands-On RTOS with Microcontrollers delivers a practical path from bare-metal to full RTOS applications using FreeRTOS on an STM32 Nucleo-F767ZI board. The book combines clear explanations of concurrency, interrupts, and DMA with step-by-step toolchain setup and runnable examples that show building, debugging, monitoring, and scaling embedded systems for real projects and coursework.
Optimizing Optoisolators, and Other Stories of Making Do With Less
Jason Sachs digs into how to squeeze speed and reliability from low-cost optoisolators, showing practical tweaks that often outperform default datasheet usage. He mixes hands-on circuits — using 4N35 base-emitter resistors, Schottky clamps, input speedup caps, and output buffering — with transistor-switching theory and a cautionary production story to show when to optimize and when to splurge on pricier isolators.
New Comments System (please help me test it)
DSPRelated just got a practical upgrade, Stephane Boucher has released a new comments system built from his earlier forum work. It supports drag-and-drop or Insert Image uploads, MathML, TeX and ASCIImath rendered by MathJax, syntax-highlighted code via highlight.js, and in-place editing and deletion of comments. Improved email notifications alert authors and commenters to replies, and readers are invited to post test comments and report problems.
Metal detection: beat frequency oscillator
Fabien Le Mentec walks through a practical beat frequency oscillator metal detector, from the LC oscillator theory to the Arduino-based frequency counter. He shows how changes in coil inductance reveal nearby metal, and why capacitor choice matters when you want a stable detector. The post focuses on the BFO sensing stage, with enough detail to help you build and test one yourself.
Introduction to Microcontrollers - Ada - 7 Segments and Catching Errors
Mike demos an Ada implementation of a multiplexed 7-segment driver on the STM32F407 Discovery board, highlighting Ada idioms like protected objects for ISRs and packed-boolean GPIO mapping. The post shows practical timer setup for Timer 6, how to avoid ARR/CNT races, and how Ada's runtime range checks plus a last-chance handler surface out-of-range errors with file and line diagnostics.
Examining The Stack For Fun And Profit
Stack bloat can hide in short initialization paths, and this post walks through finding it with hands-on debugging. The author builds a tiny test program and uses gdb plus custom stack-helper scripts to scan, watch, and walk the stack. That process reveals getaddrinfo pulling in glibc DNS code that allocates large local buffers and uses alloca and PLT resolution, consuming roughly 11KB of stack.
How to Give Persistent Names To USB-Serial Devices on Ubuntu 14.04
When your dock reshuffles ttyUSB assignments, Tayyar shows how to bind USB-serial devices to persistent names on Ubuntu 14.04. The post walks through using dmesg and udevadm to locate unique attributes like KERNELS and ATTRS{serial}, creating /etc/udev/rules.d entries with NAME and SYMLINK, and applying rules with udevadm trigger. It includes common pitfalls and quick fixes to get minicom talking to the right port.
Linear Feedback Shift Registers for the Uninitiated, Part VIII: Matrix Methods and State Recovery
Matrix methods for LFSRs look intimidating, but Jason Sachs walks through companion-matrix representations and shows why they matter for time shifts and state recovery. He derives lookahead masks from powers of the companion matrix, then translates those matrix insights into efficient bitwise and finite-field algorithms. The article includes two simple state-recovery methods and working Python/libgf2 examples you can run and adapt.
Code Metrics - SLOC Count
Metrics and SLOC can trigger flashbacks for experienced engineers, but counting source lines of code still has practical uses when applied sensibly. This post clarifies physical versus logical lines in C, explains how SLOC can be misused to judge developer productivity, and shows how to run cloc to produce accurate per-file SLOC reports for estimation and codebase analysis.
How precise is my measurement?
Precision is quantifiable, not guesswork. This post walks through practical, measurement-oriented statistics you can apply to static or dynamic signals to answer the question, "How precise is my measurement?" It focuses on using multiple samples, checking distribution assumptions, and constructing confidence intervals and levels so you can trade measurement time for a desired precision.
