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.
Dealing With Fixed Point Fractions
Fixed-point fractional math is easy to botch, and this post lays out pragmatic ways to avoid those mistakes. It clarifies the difference between integer and fractional overflow, shows how Q notation helps track binary-point scaling, and explains why multiplies add sign bits that may require shifting. Read for concrete FPGA strategies: keeping bit growth, selective shifts, or aggressive normalization, plus testing tips.
What to See at Embedded World 2023
Stephane Boucher is heading back to Embedded World 2023 in Nuremberg and is excited to feel the show’s post-pandemic buzz, with more than 900 vendors on the floor. He’s compiled a short list of vendors worth visiting and invites attendees to a casual meet-up on Tuesday evening at Hausbrauerei Altstadthof at 18:30. Join him to reconnect, network, and catch the latest industry trends.
Polynomial Math
This post walks through squaring and inversion in a tiny finite field to make ECC math tangible. Using GF(2^5) with primitive polynomial beta^5 + beta^2 + 1 it shows why squaring cancels cross terms so you only need half the lookup table, and how Fermat exponentiation computes inverses via repeated squarings and multiplies. It also demonstrates the Extended Euclid polynomial inverse and compares FPGA and CPU tradeoffs.
Elliptic Curve Cryptography - Key Exchange and Signatures
Elliptic curve mathematics over finite fields helps solve the problem of exchanging secret keys for encrypted messages as well as proving a specific person signed a particular document. This article goes over simple algorithms for key exchange and digital signature using elliptic curve mathematics. These methods are the essence of elliptic curve cryptography (ECC) used in applications such as SSH, TLS and HTTPS.
An overview of Linux Boot Process for Embedded Systems
Booting Linux on embedded hardware collapses PC boot stages into a single bootloader, and understanding the early steps helps troubleshoot low-level failures. Kunal Singh breaks down the sequence from the bootstrap firmware and primary/secondary bootloaders through zImage decompression, MMU and page table setup, start_kernel, and the initrd pivot to the root filesystem. Practical focus favors ARM examples.
Margin Call: Fermi Problems, Highway Horrors, Black Swans, and Why You Should Worry About When You Should Worry
Jason Sachs walks through practical strategies for choosing engineering margin, from split-second Fermi estimates to industry-grade safety factors. He blends highway and boiler anecdotes with a MOSFET thermal example to show why probabilistic thinking, experiments, and documentation matter when you must decide fast or later justify your choices. Read this to learn how to balance conservatism, cost, and risk in real projects.
Introduction to Microcontrollers - Further Beginnings
Mike Silva walks through the CPU plumbing every embedded engineer needs to know before writing their first LED blinky. The post explains registers (data, address, stack pointer, link), the fetch-execute cycle, and the main instruction classes such as arithmetic, logic, shifts, branches, and call/return mechanics. Read this to see how C maps to CPU operations and why stack versus link register choices matter.
Steering an autonomous vehicle - two basic ways
Choosing how a small autonomous vehicle turns changes its mechanics, controls and navigation. This post compares Ackerman steering, which uses pivoting front wheels for energy-efficient, low-slip driving suited to encoder-based dead-reckoning, with skid-steering, which relies on differential wheel speeds for simple zero-turn maneuvers but introduces tire slip and odometry challenges. Read to weigh stability, mechanical complexity and suitability for tight spaces.
Using the C language to program the am335x PRU
Assembly-language PRU development is tedious and error prone, so Fabien Le Mentec shows how to use TI's PRU C toolchain to simplify the workflow. He walks through installing the CGT package, integrating the compiler with a modified prussdrv loader to honor the _c_int00 start symbol, and provides a BeagleBone Black example with build scripts and sources on GitHub. The post also covers inline assembly constraints and code-size tradeoffs.
From bare-metal to RTOS: 5 Reasons to use an RTOS
Most developers default to bare-metal, but Jacob Beningo argues an RTOS often simplifies modern embedded design. He outlines five practical reasons to move to an RTOS: easier integration of connectivity stacks and GUIs, true preemptive scheduling with priorities, tunable footprints, API-driven portability, and a common toolset for tasks and synchronization. The piece helps decide when RTOS adoption speeds development.
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.
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.
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.
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.
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.
Stairway to Thévenin
Jason Sachs strips away classroom mystique to show how Thevenin and Norton equivalents are practical tools for real embedded work. Using a simple two-terminal black-box example he shows how two measurements give Vth and Rth, then applies that model to voltage-divider references, potentiometer RC filters, and combining multiple sources with Millman's theorem. Read it for fast, practical ways to predict output impedance, droop, and filter time constants.
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.
Getting Started With Zephyr: Devicetree Overlays
In this blog post, I show how the Devicetree overlay is a valuable construct in The Zephyr Project RTOS. Overlays allow embedded software engineers to override the default pin configuration specified in Zephyr for a particular board. In this blog post, I use I2C as an example. Specifically, I showed the default I2C pins used for the nRF52840 development kit in the nominal Zephyr Devicetree. Then, I demonstrated how an overlay can be used to override this pin configuration and the final result.
