Skills For Embedded Systems Software Developers
Embedded development demands a broad, practical skillset, and this post lays out the core knowledge employers expect across software, hardware, and tooling. It highlights essential languages like C, low-level concepts such as interrupts and RTOS, plus hardware skills like debugging with JTAG and using oscilloscopes. You also get realistic timelines, hands on study advice, and resource pointers to build a portfolio that proves you can ship reliable firmware.
Five ‘80s Movies that Inspired Me to Become an Engineer
Jacob Beningo revisits five 1980s films that helped spark his interest in electronics and engineering. From Short Circuit's exposed control ports to Data's DIY gadgets in The Goonies, these movies show hardware, invention, and imagination in action. The post ties on-screen robot tricks, backyard-built spaceships, and retro dashboards to modern themes like IoT, CubeSats, and autonomous systems, making a case for learning through storytelling.
3 Overlooked Embedded Software Elements
Jacob Beningo points out three often-overlooked elements that can make embedded projects less painful and faster to ship. He highlights model-generated code for off-target iteration, configuration-generated code to manage SKUs and avoid fragile conditional compilation, and automated test harnesses to catch regressions early. The post gives practical reasons to consider each approach and how they fit into modern embedded DevOps.
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.
Development of the MOS Technology 6502: A Historical Perspective
A tiny team at MOS Technology pulled off one of the most influential microprocessor wins of the 1970s, creating the 6502 by marrying clever circuit choices with pragmatic manufacturing techniques. This excerpt by Jason Sachs focuses on the NMOS depletion-load process, mask and layout workflows, and yield-improving tricks like Micralign projection lithography and spot-knocking, showing how engineering and process decisions made a low-cost CPU ubiquitous.
Supply Chain Games: What Have We Learned From the Great Semiconductor Shortage of 2021? (Part 2)
Jason Sachs zooms through semiconductor history, fab economics, and the microcomputer era to explain why the 2021 chip shortage unfolded the way it did. He blends technical explainers on photolithography, yields, and node migration with business lessons about risky multi-year fab investments and cyclic demand. Engineers get historical case studies and practical signals to watch when designing products for greater supply resilience.
Patterns of Thinking: Metaphors in Programming
Why do some programming ideas click while others confuse engineers? This post shows that the metaphors you choose — from biological classification for inheritance to a “quantum” analogy for hierarchical state machines — shape how developers learn, design, and communicate. It also explains the surprising power of anthropomorphic (“naïve psychology”) language in team discussions and gives practical cautions about when metaphors help or mislead.
New Promo Video for the 2022 Embedded Online Conference
Less than a week remains before the 2022 Embedded Online Conference, and Stephane Boucher shares a new promo video that previews an all-star lineup of embedded engineers, shown in order of appearance: Helen Leigh, Peter McLaughlin, Jack Ganssle, Colin O'Flynn, Miro Samek, Jean Labrosse and others. If you haven't registered yet, watch the video and save $100 on registration with promo code EMBEDDEDRELATED.
2022 Embedded Online Conference - Final Push!
The Embedded Online Conference is just weeks away, and Stephane Boucher is making one last push to get the word out. Engineers who share the conference promo image on LinkedIn or Twitter can enter a raffle to win one of two Saleae Logic Pro 8 analyzers, with a simple hashtag-based entry process.
Reading and Understanding Profitability Metrics from Financial Statements
Reading a company’s financial statements does not have to feel like accounting homework. Jason Sachs shows how engineers can pull out the most useful profitability signals, especially gross margin and operating margin, from SEC filings and earnings releases. Using semiconductor companies as examples, he explains what those ratios mean, how they’re computed, and why they can hint at business strength or weakness.
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.
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.
Stuck with Jira — and Stuckons
Jason Sachs vents about Jira’s quirks and why it still feels stuck despite years of fixes. He walks through concrete pain points: nonstandard markup, relentless notification noise, poor meta-task support, and limited analytics that make day-to-day engineering work harder. To explain why schedules blow up, he introduces a simple kepton model of planons, workons, and stuckons that highlights unexpected work.
Intel 8088 - A blast from the past
The Intel 8088 is a reminder of how hands-on early microcomputer work really was. This short retrospective looks back at wire-wrapping, perfboard construction, and assembly language programming on a board built around the 8088 and its support chips. It is a fun contrast to today’s Raspberry Pi era, where far more performance comes in a sealed package you can’t build yourself.
Introduction to Microcontrollers - Button Matrix & Auto Repeating
Wiring every button to its own GPIO gets expensive fast, so Mike Silva shows how to read a 4x4 keypad with only eight pins using matrix scanning. He then builds the raw scan into a debounced state machine, adds auto-repeat, and even extends it to a two-stage repeat rate. The result is a practical, code-heavy walkthrough for turning a keypad into clean button events on AVR and STM32.
Linear Feedback Shift Registers for the Uninitiated, Part VI: Sing Along with the Berlekamp-Massey Algorithm
Jason Sachs breaks down the Berlekamp-Massey algorithm and shows how to recover an LFSR's minimal connection polynomial from a stream of output bits. The article mixes intuition, worked examples, and Python code to demonstrate the update rule, visual debugging tables, and when the solution is unique. Expect practical implementation notes, a complexity discussion, and a libgf2 example you can run in an IPython notebook.
Getting Started with NuttX RTOS on Three Low Cost Boards
You can get Linux-like power on cheap microcontroller boards using NuttX, not a full Linux system. This article walks through building and flashing NuttX on three low-cost targets: Raspberry Pi Pico (RP2040), ESP32-DevKitC, and STM32F4Discovery, covering SDKs, toolchains, and serial access. Follow the provided commands to configure, compile, and connect to the NuttShell so you can start experimenting with NuttX quickly.
Using a RTLSDR dongle to validate NRF905 configuration
Fabien Le Mentec wanted to be sure his nRF905 radio link was configured correctly before trusting it across seven floors. Instead of guessing, he used a cheap RTLSDR dongle, rtl_fm, and a small custom decoder to inspect the 433 MHz traffic directly. The result was a practical way to validate packet framing, Manchester coding, and signal strength without relying only on the radio module’s own feedback.
OOKLONE: a cheap RF 433.92MHz OOK frame cloner
Fabien Le Mentec built a pocket device that listens to and clones 433.92MHz OOK frames, automating the tedious reverse engineering of cheap wireless outlets. The prototype uses a Moteino with an RFM69 to sample demodulated OOK data, stores pulse durations in SRAM, and replays frames; the code and hardware notes are available on GitHub along with limitations and next steps.
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.
Sensors Expo - Trip Report & My Best Video Yet!
Stephane Boucher turns a first-time Sensors Expo visit into a fun travelogue and a polished conference highlights video. He mixes candid trip anecdotes from Moncton to San Jose, electric-scooter discoveries, Santa Cruz detours, Airbnb tips, and on-the-floor expo footage. The post culminates in what he calls his best highlights reel yet, plus a follow-up video focused on embedded and IoT.
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.
Linear Feedback Shift Registers for the Uninitiated, Part XV: Error Detection and Correction
CRCs and Hamming codes look a lot less magical when you view them as redundancy with a purpose. Jason Sachs walks from parity bits and checksums into finite-field polynomial arithmetic, then shows how CRCs map cleanly onto LFSRs and how Hamming codes use syndromes to locate single-bit errors. It is a practical tour of error detection and correction, with enough worked examples to make the theory feel usable.
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.
Isolated Sigma-Delta Modulators, Rah Rah Rah!
Analog isolation can blow up DAQ budgets, but isolated sigma-delta modulators let you send a single 1-bit stream and a clock across the barrier, keeping costs down. Jason walks through Avago, TI, and Analog Devices parts, explains sigma-delta noise shaping in plain terms, and calls out the real engineering work: converting a 10–20 MHz bitstream into usable samples with sinc/CIC decimators or FPGA filtering.
How to Include MathJax Equations in SVG With Less Than 100 Lines of JavaScript!
Jason Sachs recounts a simple hack to get MathJax equations inside SVG without heavy dependencies or complex tools. His approach renders MathJax in temporary HTML divs, captures the resulting SVG nodes, and swaps them into SVG
Scorchers, Part 3: Bare-Metal Concurrency With Double-Buffering and the Revolving Fireplace
Jason Sachs presents a practical, low-overhead concurrency pattern for tiny bare-metal systems where an ISR (Speedy) must safely exchange data with a nonreal-time main loop (Poky). He describes the "revolving fireplace", a double-buffering variant that swaps ownership of two shared memory regions, and walks through C examples, atomic/volatile considerations, and testing strategies so you can implement it on RAM-constrained MCUs.
Little to no benefit from C based HLS
Christopher shows why C-based HLS delivers little practical benefit compared with a MyHDL RTL approach, using a Vivado HLS median-filter example. He walks through the sort-network median, compares C and MyHDL implementations, and argues MyHDL is as concise while providing clearer microarchitecture control. The post emphasizes that choosing the right algorithm is the hard part, and HLS won’t replace hardware understanding.
Linear Feedback Shift Registers for the Uninitiated, Part VI: Sing Along with the Berlekamp-Massey Algorithm
Jason Sachs breaks down the Berlekamp-Massey algorithm and shows how to recover an LFSR's minimal connection polynomial from a stream of output bits. The article mixes intuition, worked examples, and Python code to demonstrate the update rule, visual debugging tables, and when the solution is unique. Expect practical implementation notes, a complexity discussion, and a libgf2 example you can run in an IPython notebook.
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.
