What we've been reading this Spring/Early Summer (2026)
Here are the articles, videos, tools, and announcements we’ve been excited about in March through June 2026.
Interrupt Blog
@interrupt-blog
Publisher
218
Posts
Posts by Interrupt Blog
Zephyr West tips and tricks
Some useful west tricks for managing Zephyr workspaces more effectively.
The Hidden Cost of Misalignment
Most embedded developers use #pragma pack(1) to create portable binary record formats. But pack(1) forces the compiler to byte-decompose every field access – even perfectly aligned fields – resulting in 7x more operations on RISC-V, ARM, and Xtensa. This post shows the problem, the fix (packed +...
Connecting Matter-over-Thread Devices to the Internet
Matter devices typically communicate within the local network, but sometimes you need to reach the internet, whether for telemetry, cloud services, or custom functionality. This post explains how to send UDP traffic from a Matter-over-Thread device through a Thread Border Router using NAT64, with...
What we've been reading in February (2026)
Here are the articles, videos, and tools we’ve been excited about in February 2026.
What we've been reading in January (2026)
Here are the articles, videos, and tools we’ve been excited about in January 2026.
What we've been reading in November & December (2025)
Here are the articles, videos, and announcements we’ve been excited about to close out 2025.
What we've been reading in September & October (2025)
Here are the articles, videos, and tools we’ve been excited about in September and October 2025.
What we've been reading in August (2025)
Here are the articles, videos, and tools we’ve been excited about in August 2025.
What we've been reading in July (2025)
Here are the articles, videos, and tools we’ve been excited about in July 2025.
Embedded Systems Roadmap: Bridging the Gap
Discover the story behind this embedded systems roadmap—a structured learning path for hardware and software engineers. It guides you in selecting resources, boosting career growth, and staying current with industry trends.
Smart Ring Development (Part 2) － Hardware Design
Diving into the hardware design of an Open Smart Ring project
What we've been reading in June (2025)
Here are the articles, videos, and tools we’ve been excited about in June 2025.
Linux Coredumps (Part 3) － On Device Unwinding
Unwinding coredumps on-device using .eh_frame and addr2line.
Smart Ring Development (Part 1) － Research and Prototype
Introducing Open Smart Ring project with a series of articles
What we've been reading in May (2025)
Here are the articles, videos, and tools we’ve been excited about in May 2025.
Gophyr: Building a Gopher Client for Zephyr with Claude
AI-skeptical engineer builds Gopher client for Zephyr using AI
What we've been reading in April (2025)
Here are the articles, videos, and tools we’ve been excited about in April 2025.
Linux Coredumps (Part 2) － Shrinking the Core
Limiting the size of Linux coredumps by collecting stacks and metadata for gdb
Beyond Error Codes - Debugging Ill-Defined Problems
Steps to debug embedded systems, including several case studies involving stack clobbering, undefined functions, and memory faults
What we've been reading in March (2025)
Here are the articles, videos, and tools we’ve been excited about in March 2025.
Robust OTA Updates For Linux Devices, the Easy Way
Learn how to build a custom Debian-based OS ready for OTA updates via Memfault.
What we've been reading in February (2025)
Here are the articles, videos, and tools we’ve been excited about in February 2025.
The Android Developer's Journey into Hardware Observability
An introduction to the technical decisions Android developers will have to make when designing AOSP observability tools for the first time.
Why std::this_thread::sleep_for() is broken on ESP32
A deep dive into how std::this_thread::sleep_for() is implemented on ESP32, and why it is broken in IDF v5.
Linux Coredumps (Part 1) － Introduction
The basics of Linux coredumps, how they’re used at Memfault, and how they’re captured.
What we've been reading in January (2025)
Here are the articles, videos, and tools we’ve been excited about in January 2025.
Monitoring a Low-Power Wireless Network Based on Smart Mesh IP
Tutorial of Application Performance Monitoring (APM) using Zephyr, nRF52, an Analog LTC5800, and Memfault
Introducing Interrupt Live － Meet the Minds Behind Interrupt
Announcement for a Interrupt Live, a live interview of Interrupt authors
What we've been reading in December (2024)
Here are the articles, videos, and tools we’ve been excited about in December 2024.
How to Transition from nRF5 SDK to Zephyr NCS － Lessons from Ultrahuman’s Journey
Ultrahuman’s account of doing a complex migration from nRF5 SDK to Zephyr NCS on a nRF52 project
What we've been reading in November (2024)
Here are the articles, videos, and tools we’ve been excited about in November 2024.
Sequential-storage － Efficiently Store Data in Flash
A discussion of a sequential storage crate which can be used in Rust projects for efficiently storing data in NOR flash.
What we've been reading in October (2024)
Here are the articles, videos, and tools we’ve been excited about in October 2024.
Embedded World North America 2024 Recap
A recap of Embedded World 2024
Comparing Firmware Development Environments — Linux, Windows, WSL2, and VMWare
A comparison of WSL2 to traditional firmware development environments.
What we've been reading in September (2024)
Here are the articles, videos, and tools we’ve been excited about in September 2024.
What we've been reading in August (2024)
Here are the articles, videos, and tools we’ve been excited about in August 2024.
How Memory Usage Patterns Can Derail Real-time Performance
A story about memory usage causing real-time performance issues in an audio system.
What we've been reading in July (2024)
Here are the articles, videos, and tools we’ve been excited about in July 2024, including how to reverse engineer a smartwatch, Rust support in Zephyr, and an in-depth look at the basic building blocks of CPUs. Plus, news of “motor doping” at the Olympics.
Considerations when Building Embedded Databases
Diving into the challenges of persisting device state to flash memory.
A Schematic Review Checklist for Firmware Engineers
A checklist with supporting stories for firmware engineers to review when doing a schematic review.
What we've been reading in June (2024)
Here are the articles, videos, and tools we’ve been excited about in June 2024, including a video tutorial on how to set up Matter and a reverse engineering hack of the tiny chip in Montreal’s subway tickets.
Updating NVIDIA Jetson devices with Memfault OTA
How to use Memfault to update NVIDIA Jetson devices over-the-air (OTA).
What we've been reading in May (2024)
Here are the articles, videos, and tools we’ve been excited about in May 2024, including a new Raspberry Pi-based hacking tool and a fun concert wristband hack for Swifties.
Practical Zephyr - West workspaces (Part 6)
Article series “Practical Zephyr” the sixth part about West workspaces.
Embedded Open Source Summit 2024 Recap
A discussion of our favorite talks from EOSS 2024, including those in the Embedded Linux Conference and the Zephyr Developer Summit
What we've been reading in April (2024)
Here are the articles, videos, and tools that we’ve been excited about in April 2024, including interesting video game projects, a new report on the state of IoT software, and a tech talk on the new hardware model from Zephyr.
Standout Exhibits at Embedded World 2024
A recap of the noteworthy exhibits from Embedded World 2024, including Hightec, Bluewind, RISC-V, TinyML, Zephyr, Emproof, and Embedd
Practical Zephyr - Devicetree practice (Part 5)
Article series “Practical Zephyr”, the fifth part about Devicetree practice.
What we've been reading in March (2024)
Here are the articles, videos, and tools that we’ve been excited about this March.
Diving into JTAG — Boundary Scan (Part 3)
This article dives into JTAG Boundary Scan, a method for testing interconnects on PCBs and internal IC sub-blocks.
Differences Between ELF-32 and ELF-64
A quick reference post for the differences between ELF-32 and ELF-64 object file formats.
What we've been reading in February (2024)
Here are the articles, videos, and tools that we’ve been excited about this February.
Diving into JTAG — Debugging (Part 2)
This article explores debugging microcontrollers using JTAG, with a special focus on the ARM Cortex-M architecture and the STM32F407VG microcontroller.
Best Practices for Monitoring Device Connectivity
Measure and monitor device connectivity using techniques such as logging, protocol captures, and metrics like connection uptime and sync success.
Practical Zephyr - Devicetree semantics (Part 4)
Article series “Practical Zephyr”, the fourth part about Devicetree bindings.
What we've been reading in January (2024)
Here are the articles, videos, and tools that we’ve been excited about this January.
Practical Zephyr - Devicetree basics (Part 3)
Article series “Practical Zephyr”, the third part covering Devicetree basics.
Practical Zephyr - Kconfig (Part 2)
Article series “Practical Zephyr”, the second part covering the kernel configuration system Kconfig.
Building Nordic nRF-Connect SDK Projects with GitHub Actions
Strategies for building nRF-Connect SDK projects using GitHub Actions
Practical Zephyr - Zephyr Basics (Part 1)
Article series “Practical Zephyr”, the first part about West, CMake, and Zephyr application types.
What we've been reading in December (2023)
🎉 Happy New Year! 🎉 Here’s to making 2024 the best year yet. 2023 was an exciting year for Interrupt, with 36 new articles, 13 new external contributors, 12 community Meetups, and a partridge in a pear tree. Thanks for being a part of it. Here are the articles, videos, and tools that we’ve been...
Logging on Embedded Devices
Trade-offs and considerations for logging on embedded hardware
LTE and IoT - How We Got Here
A look at LTE technology for IoT
What we've been reading in November (2023)
Here are the articles, videos, and tools that we’ve been excited about this November.
Visualizing Real-time Data With STMViewer
A brief introduction to STMViewer software use cases in debugging embedded targets
Counting Crashes to Improve Device Reliability
Understand IoT device reliability using metrics such as mean time between failure, crash-free hours, crash-free devices, and crash-free sessions. These all surface insights about device stability.
What we've been reading in October (2023)
Here are the articles, videos, and tools that we’ve been excited about this October.
MCU Peripheral Forwarding
Mapping MCU’s peripheral registers to the address space of PC programs
What we've been reading in September (2023)
Here are the articles, videos, and tools that we’ve been excited about this September.
Exploring printf on Cortex-M
Diving into the various ways to get printf on Cortex-M microcontrollers
A Simple Scheduler via an Interrupt-driven Actor Model
Description of how interrupt controllers may function as simple schedulers
What we've been reading in August (2023)
Here are the articles, videos, and tools that we’ve been excited about this August.
Integrating Memfault With AWS IoT Core and ExpressLink
In the dynamic realm of embedded systems, the right combination of hardware and software components can transform the development process and empower engineers to build robust and efficient solutions. This article explores a streamlined device-to-cloud embedded design utilizing the STM32G0 Nucleo...
Securing Firmware Updates With AES Encryption
Firmware encryption is an option to increase security in over the air (OTA) updates. In this post, we will see how to implement firmware encryption and decryption.
Debugging Android Devices
Exploring the tools and data available to embedded Android developers to fix issues with their AOSP based devices.
A Modern C Development Environment
Spinning up a C development environment using CMake, Docker, Unity, and GitHub Actions.
What we've been reading in July
Here are the articles, videos, and tools that we’ve been excited about this July.
Understanding Battery Performance of IoT Devices
Monitoring & predicting the battery life of millions of embedded devices in production is made possible through the use of state of charge delta metrics and aggregations.
Asynchronous Rust on Cortex-M Microcontrollers
An overview of how async Rust works, and how it can be used on embedded systems. Additionally, we’ll take a look at the Rust Embassy project, and work through some examples of how to use it.
Matter, Thread, and Memfault
Matter and Thread are changing the smart home landscape with IPv6-based connectivity. This post shows how to use Memfault in a Matter/Thread environment - the changes required to the Memfault SDK, the required set-up and ideas for future integration of Memfault with Thread.
What we've been reading in June
Here are the articles, videos, and tools that we’ve been excited about this June.
Emulating a Raspberry Pi in QEMU
Emulating a Raspberry Pi computer on your desktop in Docker using QEMU - an open source emulator
Measuring Stack Usage the Hard Way
Various techniques for measuring stack usage for embedded systems.
What we've been reading in May
Here are the articles, videos, and tools that we’ve been excited about this May.
Bazel Build System for Embedded Projects
Selecting a build system is an essential decision when creating a project. Changing is always painful, especially in a mature repository. Therefore the choice should be made carefully. With this article, I will try to describe a few advantages of what Bazel can provide in the context of an embedd...
Zephyr Deep Dive: Ring Buffers
Overview of Zephyr ring buffers covering how they work and when to use them in your design
C++17’s Useful Features for Embedded Systems
In this article, you will find some features of C++17 that can also be helpful in the embedded world.
OTA for Embedded Linux Devices: A practical introduction
A core belief of Memfault is that we can ship faster when we have good infrastructure in place. An essential piece of this infrastructure is tools to send firmware updates over the air. It enables the team to ship more often and spend more time building features. In this article, we look specific...
What we've been reading in April
Here are the articles, videos, and tools that we’ve been excited about this April.
Pocket article: Debug vs. Release Builds Considered Harmful
Why having separate Debug/Release builds should be avoided
What we've been reading in February & March
Here are the articles, videos, and tools that we’ve been excited about this February & March. We’re a little late with the February issue but we’ll catch up!
A Guide to Using ARM Stack Limit Registers
A step-by-step guide on configuring and leveraging the ARMv8 MSP and PSP limit registers to protect against stack overflows on the Renesas DA1469x.
What we've been reading in January
Here are the articles, videos, and tools that we’ve been excited about this January.
Integrating Memfault into an Embedded Linux Project
An introduction to a Memfault embedded Linux integration for device deployment and management, over-the-air (OTA) software updates, and remote monitoring and debugging
What we've been reading in November & December (2022)
Here are the articles, videos, and tools that we’ve been excited about this November & December. It’s a long list…happy new year!
Using SWIG to generate bindings between C and Lua
Trying out SWIG to automate generation of binding layer between Lua and C worlds
What we've been reading in October (2022)
Here are the articles, videos, and tools that we’ve been excited about this October
What we've been reading in September (2022)
Here are the articles, videos, and tools that we’ve been excited about this September
What we've been reading in August (2022)
Here are the articles, videos, and tools that we’ve been excited about this August
Integrating Memfault with Blecon Bluetooth Devices
In this post, I’ll go through how we evaluated Memfault at Blecon and talk through what we liked and why we decided to use it, how we integrated it into the nRF5 platform and carried the Memfault data over to the Memfault cloud via Bluetooth.
What we've been reading in July (2022)
Here are the articles, videos, and tools that we’ve been excited about this July
Saving bandwidth with delta firmware updates
An introduction to delta device firmware update (Delta DFU) with JanPatch and Jojodiff. This post explains what delta DFU is and walks through an example implementation.
What we've been reading in May & June (2022)
I apologize readers of Interrupt! I haven’t published a roundup post in a while, but fear not! We’re back after a couple of very busy months, both professionally and personally. Here are the articles, videos, and tools that we’ve been excited about this May & June
Building an On-Device Embedded Testing Library
Documents the design, architecture, implementation, and pros and cons of an on-device embedded MCU testing library written in C++ and compatible with Google Test.
Selecting Your Next Project's MCU
Choosing the best microcontroller is an important decision given the chip shortage and engineering effort involved.
What we've been reading in April (2022)
Here are the articles, videos, and tools that we’ve been excited about this April
What we've been reading in March (+ Announcements) (2022)
Here are the articles, videos, and tools that we’ve been excited about this March, and we have a few announcements, the first being about Interrupt’s first Quarterly Panel co-hosted with Phillip from Embedded Artistry, and a blurb about this year’s Embedded Online Conference
What we've been reading in February (2022)
Here are the articles, videos, and tools that we’ve been excited about this February.
C Structure Padding Initialization
Details on initialization of padding bits in C language structures
What we've been reading in January (2022)
Here are the articles, videos, and tools that we’ve been excited about this January.
Nash's Four Favorite Firmware Debug Tools
Find firmware flaws faster with these top notch tools
Tracing & Logging with the `TRICE` Library (Interrupts too!)
Best practices on embedded logging and tracing and an introduction to the open-source library Trice
What we've been reading in December (2021)
🎉 Happy 2022 everyone! 🎉 Here are the articles, videos, and tools that we’ve been excited about this December.
What we've been reading in November (2021)
Here are the articles, videos, and tools that we’ve been excited about this November.
Pocket article: How to implement and use `.noinit` RAM
Explanation of a non-initialized memory section for an embedded program, how it impacts application and bootloader, and some sample implementations.
New Events and Jobs Pages on Interrupt
Events and jobs pages on Interrupt to post embedded firmware engineering positions and events such as conferences, webinars, and meetups.
What we've been reading in October (2021)
Here are the articles, videos, and tools that we’ve been excited about this October.
Automatically format and lint code with pre-commit
How to use pre-commit for automated linting, formatting, and styling firmware code by using Python, clang-format, clang-tidy, and prettier
What we've been reading in September (2021)
Here are the articles, videos, and tools that we’ve been excited about this September.
Profiling newlib-nano's memcpy
Quick look at performance of the memcpy implementation in newlib-nano
What we've been reading in July and August (2021)
You may have noticed there was no July roundup. We’ve been busy improving Memfault, building out our partnerships with Nordic Semiconductor and Laird, and enjoying the summer months. Thanks for understanding. Here are the articles, videos, and tools that we’ve been excited about this July and Aug...
What we've been reading in June (2021)
Here are the articles, videos, and tools that we’ve been excited about this June.
Pocket article: Undefined Behavior Sanitizer Trap on Error
Using Undefined Behavior Sanitizer on small embedded programs without libubsan
What we've been reading in May (2021)
Here are the articles, videos, and tools that we’ve been excited about this May.
Firmware Static Analysis with CodeChecker
A step-by-step guide on how to use CodeChecker to run static analysis on your firmware
Practical Design Patterns: Opaque Pointers and Objects in C
An overview of the opaque pointer pattern in C. How to create objects in C.
What we've been reading in April (2021)
Here are the articles, videos, and tools that we’ve been excited about this April.
Share Your Debugging Scripts
How to share and load GDB gdbinit files automatically in firmware projects.
What we've been reading in March (2021)
Here are the articles, videos, and tools that we’ve been excited about this March.
Balancing Test Coverage vs. Overhead
In a perfect world, all software and firmware are given precisely the time and budget it needs to be successful, code is uniformly well-written to industry best practices, and the code is complemented with a complete test suite instrumenting all aspects of the software. In practice, this rarely,...
What we've been reading in February (2021)
Here are the articles, videos, and tools that we’ve been excited about this February.
Introduction to ARM Semihosting
An introduction to ARM semihosting, followed by an example with OpenOCD and arm-none-eabi toolchain
What we've been reading in January (2020)
Here are the articles, videos, and tools that we’ve been excited about this January.
Proper Release Versioning Goes a Long Way
Include standardized versions and other build metadata such as Git revisions and GNU Build ID’s into firmware binaries and debug symbols.
What we've been reading in December (2020)
Happy New Year! Here’s to a wonderful 2021. Here are the articles, videos, and tools that we’ve been excited about this December.
ARM Cortex-M33 Instruction Tracing Without a Debugger
A step by step guide on how to configure and leverage the Cortex M33 Micro Trace Buffer (MTB) for instruction tracing using Dialog Semiconductor’s DA14695 MCU
Defensive Programming - Friend or Foe?
Embedded systems can benefit from defensive and offensive programming with the use of asserts, timeouts, and watchdogs.
Seamless firmware development with PlatformIO
An overview of PlatformIO, as well as a getting started example on STM32.
What we've been reading in November (2020)
Here are the articles, videos, and tools that we’ve been excited about this November.
The Best and Worst MCU SDKs
A detailed comparison of ARM Cortex-M Microcontroller SDKs and BSPs, from best to worst.
MCUboot Walkthrough and Porting Guide
A guided tour of the MCUboot feature set and how to port it to a Cortex-M application
What we've been reading in October (2020)
Here are the articles, videos, and tools that we’ve been excited about this October.
Advanced GDB Usage
A collection of advanced GDB tips, extensions, and .gdbinit macros to speed up your debugging experience with the GNU debugger.
Separating Unique Parameters from Firmware Binaries
Post covering how to provision unique parameters, such as serial numbers or public and private encryption keys, onto firmware-based devices.
What we've been reading in September (2020)
Here are the articles, videos, and tools that we’ve been excited about this August and September.
Faster Debugging with Watchpoints
A step by step guide on how to use watchpoints for faster debugging and a deep dive into how watchpoints are implemented in ARM Cortex-M MCUs
Secure firmware updates with code signing
Firmware update signing is the cornerstone of a modern firmware update system. In this article we explain why it matters, and how firmware signing can be implemented.
Monitoring Fleet Health with Heartbeat Metrics
Monitoring and tracking embedded devices using heartbeat metrics, an alternative to log processing, helps hardware and IoT companies derisk firmware updates and alerts them to issues quickly.
What we've been reading in July (2020)
Here are the articles, videos, and tools that we’ve been excited about this July.
Parsing Logs Messages for Instant Crash Analysis
A stack trace for embedded software. Get all the information you need to debug firmware crashes right into your logs, in a few easy steps.
Step-through debugging with no debugger on Cortex-M
An exploration of how to debug running devices by taking advantage of debug monitor mode on ARM Cortex-M MCUs
How to Build Drivers for Zephyr
A guide on how to build custom drivers for hardware on the Zephyr RTOS using the Device Driver Model.
Firmware Testing with Renode and GitHub Actions
Automated embedded firmware testing with Renode, Robot Framework, and the GitHub Actions CI system.
What we've been reading in June (2020)
Here are the articles, videos, and tools that we’ve been excited about this June.
Device Firmware Update Cookbook
A guide on how to build OTA DFU for your projects, as well as some common design pattern that are useful for implementing firmware update.
How do breakpoints even work?
A walk through of how hardware and software breakpoints work, how they are configured using GDB Remote Serial Protocol, and how to configure hardware breakpoints using the ARM Cortex-M Flash Patch and Breakpoint Unit
Building a Tiny CLI Shell for Tiny Firmware
A command-line shell is a powerful way to interface with embedded devices, giving the developer the ability to automate tasks, inspections, and testing.
Profiling Firmware on Cortex-M
An exploration of profiling techniques on Cortex-M microcontrollers, ranging from sampling profilers, ITM, and function timing via the cycle counter.
What we've been reading in May (2020)
Here are the articles, videos, and tools that we’ve been excited about this May.
Better Firmware with LLVM/Clang
An overview of how to compile an ARM Cortex-M based project with LLVM/Clang and an exploration of the neat features available in the toolchain such as static analysis to identify memory leaks and deadlocks
Embedded C/C++ Unit Testing with Mocks
An overview of unit test mocking and integration tests for embedded software and firmware, using popular frameworks such as CppUTest, CppUMock, fff, and CMock.
What we've been reading in April (2020)
Here are the articles, videos, and tools that we’ve been excited about this April.
Hunting Bugs with Git Bisect
An introduction to using git bisect against a set of changes as a bug-hunting tool, followed by some deeper techniques to speed up the process of tracking down when unintended behavior is introduced
gdbundle - GDB and LLDB's Missing Plugin Manager
Introducing gdbundle, a minimalist plugin manager for GDB and LLDB, which enables developers to easily GDB and LLDB extensions, packages, and Python scripts from PyPi
GNU Binutils: the ELF Swiss Army Knife
A guide of how to make the most of GNU Binutils and other tools to examine ELFs
What we've been reading in March (2020)
Here are the articles, videos, and tools that we’ve been excited about this past month.
Cortex-M MCU Emulation with Renode
An overview of how Renode can be used to emulate Cortex-M series MCUs, speed up iteration time, and automate firmware testing.
Tracking Firmware Code Size
Tracking code size for embedded software projects can prevent surprises, maintain productivity, and give insight to developers looking to retroactively reduce a firmware binary size.
A Shallow Dive into GNU Make
A brief overview of GNU Make and its features, Makefile syntax, and how to use Make to build C/C++ software and firmware
What we've been reading in February (2020)
Here are the articles, videos, and tools we’ve been excited about this past month.
A Guide to Watchdog Timers for Embedded Systems
A step by step guide covering how to integrate watchdog timers (both hardware and software) on embedded systems, best practices, and how to debug and root cause the errors which lead to watchdog resets.
Beyond Firmware in the 2020s
In the next decade the capabilities of software for embedded systems will catch up to those of hardware, ‘firmware’ will become increasingly difficult to distinguish from ‘software’, and a new discipline altogether will begin to take shape.
Improving Compilation Time of C/C++ Projects
Strategies for improving up C/C++ compile times for embedded software projects using ccache, preprocessor optimizations, parallel execution, and other techniques.
Rust for Low Power Digital Signal Processing
A step by step guide on how to use Rust for Digital Signal Processing (DSP) in a firmware project
I2C in a Nutshell
An in-depth explanation of the I2C protocol, followed by common bugs and how to fix them.
What we've been reading in January
Happy New Year! Here are the articles, videos, and tools we’ve been excited about this past month.
Managing Developer Environments with Conda
How to use Conda for managing build, test, and debug environments and dependencies for local development and continuous integration in the context of embedded software projects
Loading more…