Interrupt

Zephyr West tips and tricks

Fri, 03 Apr 2026 19:48:05 +0000

The Zephyr west tool is a powerful workspace manager, but it is admittedly pretty feature-rich: there’s a lot of functionality buried inside that tool!

I thought it would be interesting to share a few tips and tricks that I use with west to make my Zephyr development workflow a little smoother.

Continue reading…

OTA Firmware Updates for Matter Devices via nRF Cloud

Fri, 03 Apr 2026 19:48:05 +0000

This post walks through implementing OTA firmware updates on a Matter-over-Thread device, bypassing Matter’s standard update mechanism in favor of a direct CoAP connection to nRF Cloud. We cover the full pipeline: checking for new versions, downloading firmware in 1024-byte blocks over CoAP, streaming it to flash, and safely swapping images with MCUboot.

Continue reading…

The Hidden Cost of Misalignment

Fri, 03 Apr 2026 00:00:00 +0000

In this post, we show how to fix using the packed and aligned attributes, and how to avoid byte-decomposition even as the struct grows in the future.

Continue reading…

Connecting Matter-over-Thread Devices to the Internet

Tue, 24 Mar 2026 00:00:00 +0000

In this post, we look at how a Matter-over-Thread device can reach the internet through a Thread Border Router. We will cover the key networking concepts (Thread, NAT64, and UDP) and walk through a working example that sends a UDP message from an nRF54LM20 DK to an echo server on the public internet.

Continue reading…

What we've been reading in February (2026)

Fri, 06 Mar 2026 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this February.

Continue reading…

What we've been reading in January (2026)

Thu, 05 Feb 2026 00:00:00 +0000

Hope everyone has had a great start to the year. Here are the articles, videos, and tools that we’ve been excited about this January!

Continue reading…

What we've been reading in November & December (2025)

Wed, 31 Dec 2025 00:00:00 +0000

Here are the articles, videos, and tools that stood out to us as we wrap up 2025.

Thanks to everyone who shared articles, talks, and ideas this year, and to everyone we met in person along the way. We’re heading into 2026 energized by readers like you in the embedded community that keep pushing the space forward.

Continue reading…

What we've been reading in September & October (2025)

Wed, 05 Nov 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this September and October.

Continue reading…

What we've been reading in August (2025)

Fri, 05 Sep 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this August.

Continue reading…

What we've been reading in July (2025)

Fri, 08 Aug 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this July.

Continue reading…

Embedded Systems Roadmap: Bridging the Gap

Fri, 25 Jul 2025 00:00:00 +0000

In this article, I’ll share the story behind creating my embedded systems engineering roadmap, why it became necessary, the logic behind its structure, and how to use it effectively in your learning journey.

Continue reading…

Smart Ring Development (Part 2) － Hardware Design

Thu, 10 Jul 2025 00:00:00 +0000

This series of articles discusses the development of a SOTA Open Smart Ring － a tiny wearable packed with electronics that fits on your (even the smallest) finger. We dive deep into what it means to develop such a product, its challenges, and ultimately, how to make it a manufacturable and usable piece.

Continue reading…

What we've been reading in June (2025)

Thu, 03 Jul 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this June.

Continue reading…

Linux Coredumps (Part 3) － On Device Unwinding

Fri, 20 Jun 2025 00:00:00 +0000

In this post, we’ll go over a method of coredump collection that does the stack unwinding on-device. This approach allows devices that may be sensitive to leaking PII (Personally Identifiable Information) that may be stored in memory on the stack or heap to safely collect coredumps in addition to greatly reducing the size needed to store them.

Continue reading…

Smart Ring Development (Part 1) － Research and Prototype

Fri, 13 Jun 2025 00:00:00 +0000

Continue reading…

What we've been reading in May (2025)

Fri, 06 Jun 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this May.

Continue reading…

Gophyr: Building a Gopher Client for Zephyr with Claude

Fri, 16 May 2025 00:00:00 +0000

This article chronicles my unexpected 3-hour adventure using Claude to create Gophyr: a fully functional Gopher client for Zephyr, complete with a Zephyr shell command set.

Continue reading…

What we've been reading in April (2025)

Fri, 09 May 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this April.

Continue reading…

Linux Coredumps (Part 2) － Shrinking the Core

Fri, 02 May 2025 00:00:00 +0000

In this article, we’ll take a look at what comprises a coredump, why they can be so large, and what we can strip away to make them smaller while retaining critical debugging information.

Continue reading…

Beyond Error Codes - Debugging Ill-Defined Problems

Fri, 18 Apr 2025 00:00:00 +0000

The following guide serves as a prescriptive, step-by-step way of debugging errors that on their face appear to be intangible.

Continue reading…

What we've been reading in March (2025)

Thu, 03 Apr 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this March.

Continue reading…

Robust OTA Updates For Linux Devices, the Easy Way

Thu, 20 Mar 2025 00:00:00 +0000

This guide will walk you through all the steps necessary to build a bespoke variant of Debian with over-the-air update support, including delta updates, integrated with Memfault. Following this guide, you will also install a full system update via Memfault to your custom system running in a VM or on a Raspberry Pi. To follow this guide you only need a working Docker installation on either Linux or macOS. End-to-end this guide should take less than 30 minutes to complete, so let’s get started.

Continue reading…

What we've been reading in February (2025)

Fri, 07 Mar 2025 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this February.

Continue reading…

The Android Developer's Journey into Hardware Observability

Fri, 28 Feb 2025 00:00:00 +0000

In this article, I walk through how the growth of internal observability tooling for an AOSP device might look like, and the variety of pitfalls one might encounter as they scale from 1s to 10s to 1000s of Android devices in the field, based off my experience talking to AOSP developers and teams, and personally as an Android app developer working on AOSP hardware.

Continue reading…

Why std::this_thread::sleep_for() is broken on ESP32

Thu, 20 Feb 2025 00:00:00 +0000

A curious bug appearing after upgrading to IDF v5 led me into a deep dive of how std::this_thread::sleep_for() is implemented on the ESP32. I discuss how the IDF implements pthreads and newlib to provide C++ threading functionality. The results are surprising: a simple 10 millisecond sleep was killing performance, but only in the new version of IDF due to an interaction between libstdc++ and usleep().

Continue reading…

Linux Coredumps (Part 1) － Introduction

Fri, 14 Feb 2025 00:00:00 +0000

In this article, we’ll start by taking a look at how a Linux coredump is formatted, how you capture them, and how we use them at Memfault.

Continue reading…

What we've been reading in January (2025)

Thu, 06 Feb 2025 00:00:00 +0000

We hope your year is off to a great start! January has been an exciting month for Interrupt — we launched Interrupt Live, a new series where our co-founder and host, Tyler Hoffman, sits down with Interrupt contributors to share their insights and stories. We’d love for you to tune in — see more details here!

Here are the articles, videos, and tools that we’ve been excited about this January.

Continue reading…

Monitoring a Low-Power Wireless Network Based on Smart Mesh IP

Wed, 29 Jan 2025 00:00:00 +0000

This blog post provides a practical tutorial demonstrating a simple APM solution for low-power devices. The solution leverages Zephyr RTOS on an nRF52, and SmartMesh IP on an Analog LTC5800 which can accommodate an arbitrary number of wireless motes. The motes can send a set of performance metrics at certain heartbeat intervals via a framework provided by Memfault. The framework is scalable and allows the creation of a customized group of metrics.

Continue reading…

Introducing Interrupt Live － Meet the Minds Behind Interrupt

Fri, 24 Jan 2025 00:00:00 +0000

After nearly seven years of Interrupt contributions, we’ve decided to take this conversation to the next level. Introducing Interrupt Live: a YouTube Live series where we sit down with Interrupters to hear more about their origin stories, engineering journeys, and the unique challenges that inspired their contributions. If you’ve ever wanted to hear directly from the engineers behind your favorite Interrupt posts, now’s your chance.

Continue reading…

What we've been reading in December (2024)

Fri, 03 Jan 2025 00:00:00 +0000

🎆 Happy New Year! 🎆 Here’s to making 2025 the best year yet. 2024 was an exciting year for Interrupt with 39 new articles, 6 new external contributors, and 576 new subscribers. Thanks for being a part of it!

Here are the articles, videos, and tools that we’ve been excited about this December.

Continue reading…

WSL2 for Firmware Development

Wed, 18 Dec 2024 00:00:00 +0000

This guide provides instructions for setting up an environment for developing, debugging, and programming embedded systems firmware in the Windows Subsystem for Linux (WSL2).

Continue reading…

How to Transition from nRF5 SDK to Zephyr NCS － Lessons from Ultrahuman’s Journey

Wed, 11 Dec 2024 00:00:00 +0000

In this article, we’ll walk you through our journey, the challenges we faced, and how this migration is shaping a better future for those who rely on our technology to improve their health and fitness.

Continue reading…

What we've been reading in November (2024)

Wed, 04 Dec 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this November.

Continue reading…

Sequential-storage － Efficiently Store Data in Flash

Thu, 14 Nov 2024 00:00:00 +0000

While using a full-blown filesystem for storing your data in non-volatile memory is common practice, those filesystems are often too big, not to mention annoying to use, for the things I want to do. My solution? I’ve been hard at work creating the sequential-storage crate. In this blog post I’d like to go over what it is, why I created it and what it does.

Continue reading…

What we've been reading in October (2024)

Thu, 07 Nov 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this October.

Continue reading…

Publishing the Memfault SDK as an ESP-IDF Component

Thu, 24 Oct 2024 00:00:00 +0000

In this very Memfault-centric post, I’ll be talking about how we shipped our SDK as an ESP-IDF component. This is a continuation of our efforts to make it easier to integrate Memfault into your projects, specifically targeting ESP32-based projects.

Continue reading…

Embedded World North America 2024 Recap

Thu, 17 Oct 2024 00:00:00 +0000

In this post, we will cover what we learned from the first Embedded World North America. Our team had the chance to meet with some IoT device makers and understand what is top of mind for them.

Continue reading…

Comparing Firmware Development Environments — Linux, Windows, WSL2, and VMWare

Thu, 10 Oct 2024 00:00:00 +0000

About a year and a half ago, I decided to take a different approach to setting up a Zephyr environment for a new project at Intercreate. Instead of using my trusty VMWare Workstation Linux VM, I opted for WSL2. I was curious to find out: Would hardware pass-through for debugging work reliably? Would all of the tooling dependencies be supported? What about build system performance?

Continue reading…

What we've been reading in September (2024)

Thu, 03 Oct 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this September.

Continue reading…

What we've been reading in August (2024)

Wed, 04 Sep 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this August.

Continue reading…

How Memory Usage Patterns Can Derail Real-time Performance

Thu, 29 Aug 2024 00:00:00 +0000

In this article, we will learn how memory usage patterns can affect the real-time performance of an embedded application, drawing from a recent experience tracing an audio DSP application running on an embedded Linux platform. First, I will introduce the product in question and the real-time audio software I developed for it. Then, I’ll describe the issues I encountered with audio callbacks and the strategy I followed to determine the cause of the issues, ending with my solution and lessons learned.

Continue reading…

Diving into JTAG — Security (Part 6)

Wed, 14 Aug 2024 00:00:00 +0000

The JTAG interface is an important tool for debugging and testing embedded systems, providing low-level access to the internal workings of microcontrollers and other integrated circuits. However, this powerful interface also presents significant security threats. In the sixth and final part of this Diving into JTAG article series, we will focus on security issues related to JTAG and the Debug Port.

Continue reading…

What we've been reading in July (2024)

Thu, 08 Aug 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this July.

Continue reading…

GitHub Actions for STM32CubeIDE

Thu, 01 Aug 2024 00:00:00 +0000

In this article, we will explore how to use GitHub Actions to automate building STM32CubeIDE projects. Eclipse-based IDEs like STM32CubeIDE are often used for developing embedded systems but can be a little tricky to build in a headless environment.

Continue reading…

Considerations when Building Embedded Databases

Wed, 24 Jul 2024 00:00:00 +0000

Persisting to flash is a necessary evil for many embedded devices. Let’s take a look at some of the pitfalls and how they may be avoided.

Continue reading…

A Schematic Review Checklist for Firmware Engineers

Thu, 18 Jul 2024 00:00:00 +0000

Schematic reviews are a part of the hardware development cycle in many if not most, hardware development companies. Typically led by the electrical engineering team, it is easy to overlook design issues that will be important to the firmware team. This post tells of a few stories of design misses that I have made and puts some common lessons learned into a checklist for other firmware engineers. It is not meant to be an exhaustive list, but rather a starting point for a firmware engineer to build their own checklist with the goal of helping teams catch software/hardware interaction bugs earlier in the design cycle when they’re cheaper to fix.

Continue reading…

What we've been reading in June (2024)

Thu, 11 Jul 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this June.

Continue reading…

Updating NVIDIA Jetson devices with Memfault OTA

Wed, 26 Jun 2024 00:00:00 +0000

NVIDIA offers one of the most comprehensive SDKs for developers of AI-heavy products. It includes a development kit that can emulate other devices in the lineup (Jetson AGX Orin DK), a simpler development kit for “entry-level” products (Jetson Orin Nano DK), a ton of exciting software libraries, AI models and even more examples of how to use them. It’s truly outstanding and out of the box shows up as a Ubuntu workstation which will feel very familiar.

However, it can be a bit daunting to figure out how to take this workstation experience and turn it into a headless unit that you can ship to customers far away and update remotely.

Continue reading…

Diving into JTAG — Usage Scenarios (Part 5)

Wed, 12 Jun 2024 00:00:00 +0000

In previous articles, we have considered the primary uses of JTAG, including debugging and testing boards in production. For firmware developers, the first - debugging - is the most common. In this article, I want to look at two uses of JTAG Boundary Scan, which are also common tasks for a firmware developer: board bring-up and reverse engineering.

Continue reading…

What we've been reading in May (2024)

Wed, 05 Jun 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this May.

Continue reading…

Practical Zephyr - West workspaces (Part 6)

Thu, 16 May 2024 00:00:00 +0000

In the previous articles, we used freestanding applications and relied on a global Zephyr installation. In this article, we’ll see how we can use West to resolve global dependencies by using workspace applications. We first explore West without even including Zephyr and then recreate the modified Blinky application from the previous article in a West workspace.

Continue reading…

Embedded Open Source Summit 2024 Recap

Wed, 08 May 2024 00:00:00 +0000

We cover the talks I was able to see in person, as well as some talks seen by my colleagues since they were posted. Obviously this is just our little biased selection, we have not been able to see everything, let us know in the comments what we missed!

Continue reading…

What we've been reading in April (2024)

Wed, 01 May 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this April.

Continue reading…

Standout Exhibits at Embedded World 2024

Thu, 25 Apr 2024 00:00:00 +0000

In this post, I will share the technologies I saw at Embedded World 2024 that I was most impressed by. I was lucky to have plenty of time to walk from booth to booth, and had some fantastic conversations that I hope you will find interesting.

Continue reading…

Practical Zephyr - Devicetree practice (Part 5)

Wed, 17 Apr 2024 00:00:00 +0000

In the previous articles, we covered Devicetree in great detail: We’ve seen how we can create our own nodes, we’ve seen the supported property types, we know what bindings are, and we’ve seen how to access the Devicetree using Zephyr’s devicetree.h API. In this fifth article of the Practical Zephyr series, we’ll look at how Devicetree is used in practice by dissecting the Blinky application.

Continue reading…

What we've been reading in March (2024)

Thu, 04 Apr 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this March.

Continue reading…

Diving into JTAG — BSDL (Part 4)

Fri, 29 Mar 2024 00:00:00 +0000

In the previous article of this series, we briefly touched on how .bsd files written in Boundary Scan Description Language (BSDL) describe the structure of the boundary scan chain and the instruction set. In this article, we will examine this language’s syntax more closely before seeing how .bsd files are leveraged in JTAG testing in the next article.

Continue reading…

Diving into JTAG — Boundary Scan (Part 3)

Fri, 22 Mar 2024 00:00:00 +0000

In the third installment of this JTAG deep dive series, we will talk in-depth about JTAG Boundary-Scan, a method used to test interconnects on PCBs and internal IC sub-blocks. It is defined in the IEEE 1149.1 standard. I recommend reading Part 1 & Part 2 of the series to get a good background on debugging with JTAG before jumping into this one!

Continue reading…

Differences Between ELF-32 and ELF-64

Wed, 13 Mar 2024 00:00:00 +0000

The ELF object file format is one of the most commonly used today. Most build systems provide an output to this format, and ELF is commonly used to output coredumps. The format varies in subtle ways for 32-bit and 64-bit targets though, which can present problems for tools supporting both. This post will highlight the main differences and is intended as a quick reference for these differences.

Continue reading…

What we've been reading in February (2024)

Thu, 07 Mar 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this February.

Continue reading…

Diving into JTAG — Debugging (Part 2)

Thu, 29 Feb 2024 00:00:00 +0000

In this second part of a JTAG deep-dive series, we take an in-depth look at interacting with a microcontroller’s memory and engaging with the processor core and debug registers. While the use of JTAG in testing is fairly standardized when it comes to debugging, each processor architecture has its unique nuances. With that in mind, this article will focus on debugging using JTAG on the ARM Cortex-M architecture, specifically with the STM32F407VG microcontroller.

Continue reading…

Best Practices for Monitoring Device Connectivity

Thu, 22 Feb 2024 00:00:00 +0000

This post will cover why device connectivity is complex and what methods we have available to diagnose and solve connectivity problems, both in the office and remotely in production. The tool at the core of our strategy is metrics, but we’ll briefly survey other tools like logging and protocol analysis. We’ll look in-depth at the utility of metrics and wrap up with some practical metric examples to use in your device.

Continue reading…

Practical Zephyr - Devicetree semantics (Part 4)

Thu, 15 Feb 2024 00:00:00 +0000

Having covered the Devicetree basics in the previous article, we now add semantics to our Devicetree using so-called bindings: For each supported type, we’ll create a corresponding binding and look at the generated output to understand how it can be used with Zephyr’s Devicetree API.

Continue reading…

What we've been reading in January (2024)

Wed, 07 Feb 2024 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this January.

Continue reading…

Practical Zephyr - Devicetree basics (Part 3)

Thu, 01 Feb 2024 00:00:00 +0000

In this third article of the “Practical Zephyr” series, we’ll see how we configure and use hardware. For this, Zephyr borrows another tool from the Linux kernel: Devicetree.

In contrast to Kconfig, the Devicetree syntax and its use are more intricate. Therefore, we’ll cover Devicetree in two articles. In this article, we’ll see what Devicetree is and how we can write our own Devicetree source files. In the next article, we’ll look at so-called Devicetree bindings, which add semantics to our Devicetree. Be prepared for a fair bit of theory, but as usual, we’ll use an example project to follow along.

Continue reading…

Practical Zephyr - Kconfig (Part 2)

Wed, 24 Jan 2024 00:00:00 +0000

In this second article of the “Practical Zephyr” series, we’ll explore the kernel configuration system Kconfig by looking at the printk logging option in Zephyr. We won’t explore the logging service as such in detail but instead use it as an excuse to dive deep into Kconfig. Finally, we’ll create our own little application-specific Kconfig configuration.

Continue reading…

Building Nordic nRF-Connect SDK Projects with GitHub Actions

Thu, 18 Jan 2024 00:00:00 +0000

Recently we ran through a re-vamp of our CI builds targeting the Nordic nRF-Connect SDK, and I wanted to share some of the things we learned along the way! This article walks through setting up a GitHub Actions workflow for building nRF-Connect SDK projects.

Continue reading…

Practical Zephyr - Zephyr Basics (Part 1)

Wed, 10 Jan 2024 00:00:00 +0000

If you’re working a full-time job and would still like to get started with Zephyr but don’t have the energy to set up your environment to dive deeper into the docs, this article series will guide you through the Zephyr basics. Of course, you’ll learn most if you follow along with programming, but all code, including snippets of generated code and build logs, are included in the articles of this series. Thus, even just reading this series should give you a good idea about how Zephyr works.

Continue reading…

What we've been reading in December (2023)

Thu, 04 Jan 2024 00:00:00 +0000

🎉 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 excited about this December.

Continue reading…

Logging on Embedded Devices

Wed, 20 Dec 2023 00:00:00 +0000

In this article, I discuss some of the problems I’ve encountered in producing and analyzing device logs over the years, on single digit number of devices up to hundreds of thousands, and concepts I’ve applied to manage that complexity. My background is in Android development, so some of the examples may skew towards much more powerful hardware than simple microcontrollers.

Continue reading…

LTE and IoT - How We Got Here

Wed, 13 Dec 2023 00:00:00 +0000

In this article, I describe some of my findings from a recent investigation of how LTE technology was built for IoT systems. Complete with some history and a few diagrams to illustrate cellular network architecture and LTE power-saving features like eDRX and PSM, this read will give a nice introduction to LTE in embedded systems.

Continue reading…

What we've been reading in November (2023)

Wed, 06 Dec 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this November.

Continue reading…

Diving into JTAG - Overview (Part 1)

Wed, 29 Nov 2023 00:00:00 +0000

As the first segment of a three-part series on JTAG, this post will give an overview of JTAG to set up some more in-depth discussions on debugging and JTAG Boundary-Scan. We will dive into the intricacies of the interface, such as the Test Access Port (TAP), key registers, instructions, and JTAG’s finite state machine.

Continue reading…

Visualizing Real-time Data With STMViewer

Wed, 15 Nov 2023 00:00:00 +0000

If you’ve ever wanted to plot data acquired on your embedded target, this article is for you. It explores common use cases for real-time data visualization using STMViewer. Say goodbye to manual, time-consuming, and error-prone data collection and display methods to speed up your debugging process.

Continue reading…

Counting Crashes to Improve Device Reliability

Wed, 08 Nov 2023 00:00:00 +0000

This post will cover the most common reliability metrics that hardware manufacturers use. It will explore which are best for IoT devices, including a novel measurement, Crash Free Hours. We’ll cover exactly what you’ll need to collect on your devices within firmware to measure device reliability and ensure your devices are working as expected.

Continue reading…

What we've been reading in October (2023)

Wed, 01 Nov 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this October.

Continue reading…

Rust on Yocto: A Seamless Integration

Wed, 18 Oct 2023 00:00:00 +0000

At Memfault, our love affair with Rust began in late 2022. What drew us to Rust? Well, the typical allure of a modern programming language: an impressive type-system, memory safety without the constant jitters, efficient concurrency management, a thriving package ecosystem, and overwhelming support from our engineering team. To put it simply, we’re smitten. Our journey with Rust has been nothing short of transformative, enabling rapid progress and leading us to conquer challenges we previously deemed … non-trivial.

Continue reading…

MCU Peripheral Forwarding

Wed, 11 Oct 2023 00:00:00 +0000

PC applications that interact with MCUs are used by developers for a number of reasons, such as data visualization, monitoring during testing campaigns, and command and control via a GUI. In this article, we’ll explore mapping an MCU’s peripherals to your personal computer to simplify development of PC applications built for embedded systems.

Continue reading…

What we've been reading in September (2023)

Wed, 04 Oct 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this September.

Continue reading…

Exploring printf on Cortex-M

Wed, 20 Sep 2023 00:00:00 +0000

The C printf function is a staple of embedded development. It’s a simple way to get logs or debug statements off the system and into a terminal on the host. This article explores the various ways to get printf on Cortex-M microcontrollers.

Continue reading…

A Simple Scheduler via an Interrupt-driven Actor Model

Wed, 13 Sep 2023 00:00:00 +0000

In this article, we’ll weigh the benefits of using the Cortex-M interrupt model as a scheduler and go over a simple implementation of this concept.

Continue reading…

What we've been reading in August (2023)

Wed, 06 Sep 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this August.

Continue reading…

Integrating Memfault With AWS IoT Core and ExpressLink

Wed, 30 Aug 2023 00:00:00 +0000

To ensure the reliability and stability of IoT applications, effective debugging and error monitoring are crucial. Memfault comes to the rescue with its comprehensive set of tools for remote debugging, crash reporting, and real-time error monitoring.

Continue reading…

Securing Firmware Updates With AES Encryption

Wed, 23 Aug 2023 00:00:00 +0000

In this publication, we will explore a simple method to encrypt the firmware using the AES algorithm, using open-source libraries in Python. Of course, we will also see how to decrypt the firmware from the MCU using the AES encryption engine.

Continue reading…

Debugging Android Devices

Wed, 16 Aug 2023 00:00:00 +0000

In this article we will explore the different facilities and tools available to debug Android based devices and produce robust systems that can handle a wide range of applications from smart fridges, to payment terminals, and of course mobile phones.

Continue reading…

A Modern C Development Environment

Wed, 09 Aug 2023 00:00:00 +0000

In this article we’ll go over how to set up a containerized development environment for C projects. We’ll touch on setting up a build system using CMake, a testing environment using Unity, and even how to use our containerized environment in our CI pipeline!

Continue reading…

What we've been reading in July

Wed, 02 Aug 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this July.

Continue reading…

Understanding Battery Performance of IoT Devices

Wed, 26 Jul 2023 00:00:00 +0000

In this post, I’ll cover how to start thinking about collecting metrics that contribute to battery life, how to dig into this data for individual devices, and finally how to aggregate all metrics from devices in the field to accurately predict the battery life of devices in the field for a given firmware release. All of these abilities will help projects optimize battery life and combat issues quickly when they arise, whether you have ten or a million devices in the field.

Continue reading…

Asynchronous Rust on Cortex-M Microcontrollers

Wed, 19 Jul 2023 00:00:00 +0000

In this article, we explore the inner workings of Futures, cooperative scheduling, and Async Rust executors, highlighting their significance in optimizing resource utilization. Moreover, we introduce the Rust Embassy project, an innovative framework designed to unlock the power of asynchronous programming on microcontrollers.

Continue reading…

Matter, Thread, and Memfault

Wed, 12 Jul 2023 00:00:00 +0000

I’m Markus, software engineer @ Tridonic, where we are working on Internet-connected wireless lighting solutions based on the Matter standard. To be able to monitor the reliability of those devices we’ve been using Memfault and tied it into Matter/Thread and its UDP/IPv6 stack based on the Nordic Connect SDK. In the following, I’ll show you the modifications we’ve done to enable Memfault in an IPv6 solution.

Continue reading…

What we've been reading in June

Wed, 05 Jul 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this June.

Continue reading…

Emulating a Raspberry Pi in QEMU

Wed, 21 Jun 2023 00:00:00 +0000

This article dives into QEMU, a popular open-source emulator, and how to use it to emulate a Raspberry Pi on your desktop. At the end of the article, we will put the whole environment in Docker, so you will be able to emulate a Raspberry Pi by just using a Docker container.

Continue reading…

Measuring Stack Usage the Hard Way

Wed, 14 Jun 2023 00:00:00 +0000

This article is intended to shed some light on strategies for measuring stack memory usage on a small embedded system.

Continue reading…

What we've been reading in May

Tue, 06 Jun 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this May.

Continue reading…

Bazel Build System for Embedded Projects

Tue, 30 May 2023 00:00:00 +0000

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 embedded repository and show how to set up a build environment with a cross compiler from scratch.

Continue reading…

Zephyr Deep Dive: Ring Buffers

Wed, 24 May 2023 00:00:00 +0000

This post covers Zephyr’s built-in ring buffer API, a component commonly used in producer-consumer scenarios. We will cover how ring buffers in Zephyr work, when to use them, and their strengths and weaknesses. This post will close with an example of augmenting ring buffers with waiting capabilities.

Continue reading…

C++17’s Useful Features for Embedded Systems

Wed, 17 May 2023 00:00:00 +0000

In this article, I will be showing some features of C++17 that can also be helpful in the embedded world.

Continue reading…

OTA for Embedded Linux Devices: A practical introduction

Tue, 09 May 2023 00:00:00 +0000

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 specifically at what is required to ship over-the-air firmware updates for Linux systems.

Continue reading…

What we've been reading in April

Wed, 03 May 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this April.

Continue reading…

Pocket article: Debug vs. Release Builds Considered Harmful

Tue, 25 Apr 2023 00:00:00 +0000

Separate “debug” and “release” builds are very common in embedded development. Typically the notion is improved debug capabilities (less aggressive compiler optimizations, more debugging information like logs) vs. highly optimized and hardened production release builds. I’m here to describe disadvantages to this practice, and why it might make sense to consolidate to a single build!

Continue reading…

What we've been reading in February & March

Wed, 12 Apr 2023 00:00:00 +0000

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!

Continue reading…

A Guide to Using ARM Stack Limit Registers

Tue, 14 Feb 2023 00:00:00 +0000

We will explore using the MSP Limit and the PSP Limit Registers on the ARM Cortex-M33 architecture to detect stack overflows. We will walk through an implementation on the Renesas DA1469x and look at practical examples of detecting stack overflows. Additionally, we will look at supplementary options for scenarios that the MSPLIM and PSPLIM features fall short.

Continue reading…

What we've been reading in January

Tue, 07 Feb 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this January.

Continue reading…

Integrating Memfault into an Embedded Linux Project

Wed, 18 Jan 2023 00:00:00 +0000

In this blog post, I will demonstrate how to integrate Memfault’s offering on a Raspberry Pi 3B+ running embedded Linux.

Continue reading…

What we've been reading in November & December (2022)

Thu, 12 Jan 2023 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this November & December. It’s a long list…happy new year!

Continue reading…

Using SWIG to generate bindings between C and Lua

Tue, 29 Nov 2022 00:00:00 +0000

This article covers how to write a C program that launches a Lua interpreter and then how to use SWIG to generate the necessary wrapper code to allow Lua scripts to access the functions and data inside of the C runtime.

Continue reading…

What we've been reading in October (2022)

Tue, 01 Nov 2022 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this October

Continue reading…

What we've been reading in September (2022)

Tue, 11 Oct 2022 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this September

Continue reading…

Pocket article: Debugging ccache misses

Tue, 04 Oct 2022 00:00:00 +0000

This article provides a few tips and tricks for diagnosing ccache misses, to keep your C/C++ build nice and snappy!

Continue reading…

What we've been reading in August (2022)

Tue, 06 Sep 2022 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this August

Continue reading…

Integrating Memfault with Blecon Bluetooth Devices

Tue, 23 Aug 2022 00:00:00 +0000

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.

Continue reading…

What we've been reading in July (2022)

Wed, 17 Aug 2022 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this July

Continue reading…

Saving bandwidth with delta firmware updates

Tue, 09 Aug 2022 00:00:00 +0000

In this post, we introduce the concept of delta (i.e. partial) firmware updates, explain why you may want to implement them in your projects and go through an example implementation from top to bottom.

Continue reading…

Tools we use: installing GDB for ARM

Wed, 03 Aug 2022 00:00:00 +0000

In this mini article, I’ll be going on a few strategies and nuances around getting a copy of GDB installed for debugging ARM chips.

Continue reading…

What we've been reading in May & June (2022)

Tue, 19 Jul 2022 00:00:00 +0000

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

Continue reading…

Building an On-Device Embedded Testing Library

Tue, 07 Jun 2022 00:00:00 +0000

There are too few C/C++ testing libraries designed for embedded devices. The traditional libraries are not designed for constrained resources and rely on host functionality like a filesystem or standard output.

In this post, I detail why I’ve decided to design a new testing library for microcontrollers and cover the rationale, design choices, and thoughts on the prototype.

Continue reading…

Selecting Your Next Project's MCU

Tue, 24 May 2022 00:00:00 +0000

Selecting the best chip can be tedious work but the best chip can save you a lot of time and money, and might even be faster! So should you spend time finding the best? I have some words on the topic.

Continue reading…

What we've been reading in April (2022)

Thu, 12 May 2022 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this April

Continue reading…

What we've been reading in March (+ Announcements) (2022)

Thu, 14 Apr 2022 00:00:00 +0000

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

Continue reading…

Dealing with Large Symbol Files

Wed, 30 Mar 2022 00:00:00 +0000

Large applications can produce very large symbol files when debug information is enabled (especially at the higher, more verbose levels of debug info!). This article describes some techniques for reducing debug symbol file sizes!

Continue reading…

What we've been reading in February (2022)

Tue, 15 Mar 2022 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this February.

Continue reading…

C Structure Padding Initialization

Tue, 01 Mar 2022 00:00:00 +0000

This article takes a look at a few different aspects of C structure initialization. In particular, we’ll look at when it matters, the current state of things in Clang and GCC, recommendations, and the ✨ future ✨.

Continue reading…

What we've been reading in January (2022)

Tue, 01 Feb 2022 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this January.

Continue reading…

Nash's Four Favorite Firmware Debug Tools

Tue, 25 Jan 2022 00:00:00 +0000

Firmware is an essential part of every modern electronic system. Try as we might to achieve perfection in our firmware, things will, inevitably, start to act funny. And when they do, it’s time for debugging! While a poor craftsman chooses to blame his tools, proper tooling can speed you to a robust diagnosis and an expeditious fix. Here are four of my favorite friends for finding and fixing firmware flaws.

Continue reading…

Tracing & Logging with the `TRICE` Library (Interrupts too!)

Wed, 12 Jan 2022 00:00:00 +0000

Embedded engineers need something as easy to use as printf, usable within interrupts, small enough for today’s MCU’s, and have minimal performance impact when running. The Trice technique tries to fill this gap. It is the result of a long-year dissatisfaction and several attempts to find a loophole to make embedded programming more fun and effective.

Continue reading…

What we've been reading in December (2021)

Tue, 04 Jan 2022 00:00:00 +0000

🎉 Happy 2022 everyone! 🎉

Here are the articles, videos, and tools that we’ve been excited about this December.

Continue reading…

What we've been reading in November (2021)

Mon, 06 Dec 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this November.

Continue reading…

Pocket article: How to implement and use `.noinit` RAM

Tue, 23 Nov 2021 00:00:00 +0000

This pocket article will describe how a non-initialized region of memory works, how to implement it, and how it can be used in a typical embedded system.

Continue reading…

New Events and Jobs Pages on Interrupt

Wed, 03 Nov 2021 00:00:00 +0000

Interrupt now has a community-curated Events and Jobs page! We’ve pre-populated it a bit and we invite and welcome you to submit job listings and events that you believe are relevant to the embedded engineering space.

Continue reading…

What we've been reading in October (2021)

Tue, 02 Nov 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this October.

Continue reading…

Automatically format and lint code with pre-commit

Wed, 27 Oct 2021 00:00:00 +0000

This article provides some background and guidelines for using pre-commit to automatically format and lint C-language firmware codebases. We’ll cover general guidelines and go over an example set of checks that can be helpful when working on firmware code.

Continue reading…

What we've been reading in September (2021)

Tue, 12 Oct 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this September.

Continue reading…

Peeking inside CMSIS-Packs

Thu, 07 Oct 2021 00:00:00 +0000

In this article, we’ll take a look at what CMSIS-Packs are, and how they can be useful!

Continue reading…

Profiling newlib-nano's memcpy

Tue, 07 Sep 2021 00:00:00 +0000

This article takes a look at one of the commonly used functions provided by the Newlib C library: memcpy. We’ll examine the default nano implementation and the performance implications, comparing it against the faster non-default implementation.

Continue reading…

What we've been reading in July and August (2021)

Tue, 31 Aug 2021 00:00:00 +0000

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 August.

Continue reading…

What we've been reading in June (2021)

Tue, 06 Jul 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this June.

Continue reading…

Pocket article: Undefined Behavior Sanitizer Trap on Error

Tue, 22 Jun 2021 00:00:00 +0000

This post is a brief overview on how the Undefined Behavior Sanitizer can be used to trap unintentional or error prone parts of a C program. We’re going to look at how it’s used on a desktop program, as well as a way to use it in small embedded programs!

Continue reading…

What we've been reading in May (2021)

Tue, 01 Jun 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this May.

Continue reading…

Firmware Static Analysis with CodeChecker

Wed, 19 May 2021 00:00:00 +0000

In this post, I go over how to set up CodeChecker on a firmware project to reap the benefits of static analysis. I’ll also cover ways to deal with false positives, and configure your assert functions to be analysis-friendly.

Continue reading…

Practical Design Patterns: Opaque Pointers and Objects in C

Tue, 11 May 2021 00:00:00 +0000

Objects are not a native concept in C, but you can achieve something resembling objects by using a design pattern known as the “opaque pointer”. This post will show you what the pattern is, explain some of the finer details, and provide guidance on when you should and shouldn’t use it.

Continue reading…

What we've been reading in April (2021)

Tue, 04 May 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this April.

Continue reading…

Share Your Debugging Scripts

Wed, 21 Apr 2021 00:00:00 +0000

In this short-form post, I want to share how you can go about keeping a central gdbinit file that you can commit into your project’s repo and automatically source it in the popular editor and IDE environments that firmware engineers find themselves in today.

Continue reading…

What we've been reading in March (2021)

Tue, 30 Mar 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this March.

Continue reading…

Balancing Test Coverage vs. Overhead

Tue, 23 Mar 2021 00:00:00 +0000

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, if ever, happens! Development teams and organizations continually have to re-prioritize tasks to meet deadlines and avoid going over budget. In this article, we’ll cover how you can think about rapidly modifying and updating firmware, testing these changes, all the while allowing you to get the product out the door.

Continue reading…

What we've been reading in February (2021)

Tue, 02 Mar 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this February.

Continue reading…

Introduction to ARM Semihosting

Tue, 16 Feb 2021 00:00:00 +0000

This post introduces semihosting and shows how to use it and integrate it into your own embedded projects.

Continue reading…

What we've been reading in January (2020)

Tue, 09 Feb 2021 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this January.

Continue reading…

Proper Release Versioning Goes a Long Way

Tue, 19 Jan 2021 00:00:00 +0000

In this article, we are going to talk through all the various pieces of metadata to be included in your firmware binaries, debug symbols, and build artifacts so that developers and machines can quickly and easily know exactly which build is which and how to fetch associated files for the debug, test, and release pipeline.

Continue reading…

What we've been reading in December (2020)

Tue, 05 Jan 2021 00:00:00 +0000

Happy New Year! Here’s to a wonderful 2021.

Here are the articles, videos, and tools that we’ve been excited about this December.

Continue reading…

ARM Cortex-M33 Instruction Tracing Without a Debugger

Wed, 23 Dec 2020 00:00:00 +0000

In this post we will explore how to perform instruction tracing without a debugger by using the ARM Cortex-M33 Micro Trace Buffer (MTB). We will walk through a few practical examples of how to configure the MTB with Dialog Semiconductor’s DA14695 MCU.

Continue reading…

Defensive Programming - Friend or Foe?

Tue, 15 Dec 2020 00:00:00 +0000

In this article, we’ll dive into what defensive and offensive programming are, where defensive programming falls short, how developers should think about using them within embedded systems, and how the techniques of offensive programming can surface bugs and help developers root cause them immediately at runtime.

Continue reading…

Seamless firmware development with PlatformIO

Tue, 08 Dec 2020 00:00:00 +0000

In this post, I’d like to introduce PlatformIO. I will go over what PlatformIO is, how you can use it for your project, and what it is good at. I also highlight a few shortcomings worth keeping in mind.

Continue reading…

What we've been reading in November (2020)

Tue, 01 Dec 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this November.

Continue reading…

The Best and Worst MCU SDKs

Tue, 10 Nov 2020 00:00:00 +0000

In this post, I download SDKs for 10 popular Cortex-M4 microcontrollers, and evaluate how straightforward it is to get a simple example compiling. I include some step by step instructions to get started, a rating out of 10, and a few comments.

Continue reading…

MCUboot Walkthrough and Porting Guide

Wed, 04 Nov 2020 00:00:00 +0000

In this article, we will explore the feature set of MCUboot and how it works. We will walk through step-by-step how to port it to a custom platform and test our port out on a Cortex-M based development board.

Continue reading…

What we've been reading in October (2020)

Tue, 27 Oct 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this October.

Continue reading…

Advanced GDB Usage

Tue, 20 Oct 2020 00:00:00 +0000

In this reference-style post, we discuss some of the more advanced and powerful commands of the GNU debugger, GDB, as well as cover some of the best practices and hacks I’ve found over the years that help make GDB more pleasant to use.

Continue reading…

Separating Unique Parameters from Firmware Binaries

Tue, 06 Oct 2020 00:00:00 +0000

In this post, we take a look at a method for separating unique parameters such as keys and IDs from firmware. This enables us to program these parameters separately from the firmware, making our setup much more scalable and suitable for use in production.

Continue reading…

What we've been reading in September (2020)

Tue, 29 Sep 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this August and September.

Continue reading…

Faster Debugging with Watchpoints

Wed, 16 Sep 2020 00:00:00 +0000

In this post we will explore how to save time debugging by making the most of watchpoints. We will walk through a few classic use cases of watchpoints by debugging an example application with GDB. Then, we will dive into how watchpoints are implemented for ARM Cortex-M based MCUs with the Data Watchpoint & Trace (DWT) unit and explore some advanced features.

Continue reading…

Secure firmware updates with code signing

Tue, 08 Sep 2020 00:00:00 +0000

In this post, we explain why firmware signing is important, how it works, and what algorithm should be used to implement it. We also detail a full implementation built with open source, cross platform libraries.

Continue reading…

Monitoring Fleet Health with Heartbeat Metrics

Wed, 02 Sep 2020 00:00:00 +0000

In this post, we lay the foundation for how an organization should instrument their embedded firmware to measure performance, stability, and the overall “health” of each device and an entire fleet of devices. We also compare and contrast the various approaches projects generally take to surface these metrics and I’ll discuss why I believe heartbeat metrics are the best method for driving product decisions.

Continue reading…

Parsing Logs Messages for Instant Crash Analysis

Tue, 04 Aug 2020 00:00:00 +0000

Having a logger display execution information on the terminal is pretty common for firmware developers. What’s less common is having an instant stack trace when the program crashes.

Continue reading…

What we've been reading in July (2020)

Tue, 04 Aug 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this July.

Continue reading…

Step-through debugging with no debugger on Cortex-M

Wed, 29 Jul 2020 00:00:00 +0000

This week we explore how to debug running systems with ARM Cortex-M’s DebugMonitor exception handler. We cover how to configure the MCU to operate in this mode and walk through an example of installing breakpoints and single-stepping on a running device!

Continue reading…

How to Build Drivers for Zephyr

Thu, 23 Jul 2020 00:00:00 +0000

In this post, I’ll go over some of the nuances related to creating drivers for your peripherals on Zephyr. We’ll talk about Device Tree organization, Kconfig, and CMakeLists.txt files. By the end, you should have an idea on how to tackle your own Zephyr driver aspirations!

Continue reading…

Firmware Testing with Renode and GitHub Actions

Tue, 07 Jul 2020 00:00:00 +0000

In this post, I cover what it takes to build a simple firmware for use with Renode, how to build and administer tests with Robot Framework, and how to run these tests within GitHub’s continuous integration system.

Continue reading…

What we've been reading in June (2020)

Tue, 30 Jun 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this June.

Continue reading…

Device Firmware Update Cookbook

Tue, 23 Jun 2020 00:00:00 +0000

In this post, I share the device firmware update architecture I would implement knowing everything I know now. I also highlight a few design patterns that are particularly useful. The example comes with a fully functional example of a multi-stage bootloader with DFU functionality.

Continue reading…

How do breakpoints even work?

Wed, 17 Jun 2020 00:00:00 +0000

In this article, we will discuss the basic types of breakpoints (hardware and software) and how they are utilized by the GNU Project Debugger, GDB. We will then explore how to configure hardware breakpoints on an ARM Cortex-M MCU using the Flash Patch and Breakpoint Unit (FPB) and examine a real-world configuration with an example application.

Continue reading…

Building a Tiny CLI Shell for Tiny Firmware

Tue, 09 Jun 2020 00:00:00 +0000

In this post, we go over why an embedded firmware should include a command-line shell interface, common use cases for it, how to build and extend one, and cover common issues that developers run into while build and maintaining one. The shell we will build will work over a UART serial port, which should make it applicable to most embedded systems.

Continue reading…

Profiling Firmware on Cortex-M

Tue, 02 Jun 2020 00:00:00 +0000

In this post, we explore different techniques that can be used to profile firmware applications running on ARM Cortex-M microcontrollers. To profile our Mandelbrot application on STM32, we start with a naive debugger-based sampling method, and eventually discover ITM, DWT cycle counters, and more!

Continue reading…

What we've been reading in May (2020)

Tue, 26 May 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this May.

Continue reading…

Better Firmware with LLVM/Clang

Wed, 20 May 2020 00:00:00 +0000

In this article, I hope I can convince you that adding a Clang build target to your project can be a relatively simple and useful endeavor. We will cover how to take advantage of some of the rich features shipped with the toolchain and identify some memory leaks and mutex deadlocks in an example project at compile time! We will also walk through a step-by-step example of updating a GCC based ARM Cortex-M project to cross-compile with LLVM/Clang.

Continue reading…

Embedded C/C++ Unit Testing with Mocks

Tue, 12 May 2020 00:00:00 +0000

In this article, we do a deep-dive into unit testing with mocks. We’ll go over where they fit into your unit testing infrastructure, how to write them in C/C++, and finally run through some real-world examples. At the end, we’ll briefly talk about integration tests.

Continue reading…

What we've been reading in April (2020)

Tue, 28 Apr 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this April.

Continue reading…

Hunting Bugs with Git Bisect

Tue, 21 Apr 2020 00:00:00 +0000

This article is a personal story of a time I had to run a bisect on a repository, and the thoughts that went through my mind as it happened. I touch on how to find a bug using git’s bisect feature and go over some easy strategies to narrow your search space as much as possible. Lastly, I detail some ways of speeding up that search through git bisect’s automation options.

Continue reading…

gdbundle - GDB and LLDB's Missing Plugin Manager

Tue, 14 Apr 2020 00:00:00 +0000

GDB and LLDB desperately need a way for developers to share scripts, user-interface improvements, and utilities with their peers. This would enable building upon existing work and debugging techniques, progressing the entire community and preventing developers from reinventing the wheel. GDB and LLDB need a plugin manager, and I’d like to introduce to you gdbundle.

Continue reading…

GNU Binutils: the ELF Swiss Army Knife

Wed, 08 Apr 2020 00:00:00 +0000

In this article, we will explore some of my favorite binary introspection tools, such as GNU Binutils. The material is geared toward the embedded software crowd that typically writes C and C++, but many of the ideas, tools, and lessons learned can be applied to a variety of low-level software. We will walk through practical examples of how the tools can be leveraged to aid in the development process irrespective of the compiler you are using (e.g. GCC, Clang, IAR, ARMCC, etc).

Continue reading…

What we've been reading in March (2020)

Tue, 31 Mar 2020 00:00:00 +0000

Here are the articles, videos, and tools that we’ve been excited about this past month.

Continue reading…

Cortex-M MCU Emulation with Renode

Mon, 23 Mar 2020 00:00:00 +0000

In this post, I walk through setting up the Renode emulator and running a firmware in it for STM32. Using that setup, we’ll debug our firmware, run it through integrated tests, and shorten the iteration cycle of development.

Continue reading…

Tracking Firmware Code Size

Wed, 18 Mar 2020 00:00:00 +0000

In this post, I will show you how to set up a code size dashboard for your project. I’ll cover why should track code size, how to do it, and the steps to calculate code size deltas on every pull requests to keep it to a minimum.

Continue reading…

A Shallow Dive into GNU Make

Tue, 03 Mar 2020 00:00:00 +0000

This article explains general concepts and features of GNU Make and includes recommendations for getting the most out of a Make build! Consider it a brief guided tour through some of my favorite/most used Make concepts and features 🤗.

Continue reading…

What we've been reading in February (2020)

Tue, 25 Feb 2020 00:00:00 +0000

Here are the articles, videos, and tools we’ve been excited about this past month.

Continue reading…

A Guide to Watchdog Timers for Embedded Systems

Tue, 18 Feb 2020 00:00:00 +0000

In this article we will discuss the last line of defense in embedded systems – watchdogs. We will walk through a step-by-step example of how to implement a watchdog subsystem, incorporating a “hardware” and “software” watchdog, and examine effective strategies for root causing the underlying problems leading to these hangs.

Continue reading…

Improving Compilation Time of C/C++ Projects

Tue, 11 Feb 2020 00:00:00 +0000

Build times don’t have to be long, even yours! However, many factors play a role. In this post, we’ll dive into which factors contribute to slower builds, compare and contrast options, and also go over some easy wins which you can immediately contribute to your project and share with your teammates. The techniques discussed apply to most C/C++ compilers and projects, and there are a couple extra tips for those using the GNU GCC compiler.

Continue reading…

Beyond Firmware in the 2020s

Tue, 11 Feb 2020 00:00:00 +0000

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.

Continue reading…

Rust for Low Power Digital Signal Processing

Tue, 04 Feb 2020 00:00:00 +0000

In this post, I go over how Rust can be used to implement DSP algorithms for firmware today, and compare the process and performance to the equivalent code written with CMSIS-DSP.

Continue reading…

I2C in a Nutshell

Wed, 22 Jan 2020 00:00:00 +0000

I2C is perhaps the most commonly used bus to connect ICs together. As such, firmware engineers encounter it on most projects. In this post, we explain how I2C works, explore common bugs and investigate how to debug these issues.

Continue reading…

What we've been reading in January

Tue, 14 Jan 2020 00:00:00 +0000

Happy New Year! Here are the articles, videos, and tools we’ve been excited about this past month.

Continue reading…

Managing Developer Environments with Conda

Tue, 07 Jan 2020 00:00:00 +0000

This post gives an introduction to what Conda is, explains why you should care about keeping your developer environments in sync, and finally provides a walk-through on getting started with Conda to set up a GCC based developer environment.

Continue reading…

From Zero to main(): Bare metal Rust

Tue, 17 Dec 2019 00:00:00 +0000

Since 2015, Rust has been redefining what it means to combine the best-in-class aspects of performance, correctness, and developer convenience into one language, without compromise. In this post, we’ll bootstrap a Rust environment on a Cortex-M microcontroller from scratch, and explain a few of the language concepts you might not have seen before.

Continue reading…

Reproducible Firmware Builds

Wed, 11 Dec 2019 00:00:00 +0000

In this article we will discuss what a Reproducible Build is, walk through the process of updating a firmware project so the build is reproducible, and explore how we can leverage what we have learned for other aspects of development.

Continue reading…

What we've been reading in November (2019)

Tue, 03 Dec 2019 00:00:00 +0000

Starting this month, we will be sharing with you what we have been reading at the end of each month. This will include blog posts, videos, tools, and libraries that we found insightful or useful.

Continue reading…

How to debug a HardFault on an ARM Cortex-M MCU

Wed, 20 Nov 2019 00:00:00 +0000

In this article, we explain how to debug faults on ARM Cortex-M based devices. In the process, we learn about fault registers, how to automate fault analysis, and figure out ways to recover from some faults without rebooting the MCU. We include practical examples, with a step by step walk-through on how to investigate them.

Continue reading…

From Zero to main(): Bootstrapping libc with Newlib

Tue, 12 Nov 2019 00:00:00 +0000

In this post, we will add RedHat’s Newlib to our firmware and highlight some of its features. We will implement syscalls, learn about constructors, and finally print out “Hello, World”! We will also learn how to replace parts or all of the standard C library.

Continue reading…

Using Asserts in Embedded Systems

Tue, 05 Nov 2019 00:00:00 +0000

By using asserts proactively in embedded systems on debug and production builds, developers can both prevent more bugs before shipping and quickly surface and fix them after shipping. Proper assert handling is also the safest way to handle issues and undefined behavior that occur in production. In this post, we’ll go over best practices with asserts, when to use asserts, and then come up with a production ready custom assert implementation for an ARM Cortex-M device, all while keeping the code size usage to a minimum.

Continue reading…

ARM Cortex-M RTOS Context Switching

Wed, 30 Oct 2019 00:00:00 +0000

In this article we will explore how context switching works on ARM Cortex-M MCUs. We will discuss how the hardware was designed to support this operation, features that impact the context switching implementation such as the Floating Point Unit (FPU), and common pitfalls seen when porting an RTOS to a platform. We will also walk through a practical example of analyzing the FreeRTOS context switcher, xPortPendSVHandler, utilizing gdb to strengthen our understanding.

Continue reading…

The Best and Worst GCC Compiler Flags For Embedded

Tue, 22 Oct 2019 00:00:00 +0000

In this article we will explore some of the best and worst compiler flags for GCC (and Clang). Our focus will be on flags used for embedded projects but the reasoning applies to other development environments as well. We will explore the impact each flag has by walking through practical C code examples.

Continue reading…

Embedded C/C++ Unit Testing Basics

Tue, 08 Oct 2019 00:00:00 +0000

In this post, we go into detail on how to properly build abstractions to stub, fake, and mock out implementations of low level embedded software and provide a full real-world example of a unit test using the CppUTest 3.8 unit test framework.

Continue reading…

A Practical Guide to BLE Throughput

Tue, 24 Sep 2019 00:00:00 +0000

In this article, we dive into the factors which influence BLE throughput. We will walk through the BLE protocol stack from version 4.0 to 5.1. We will discuss how to audit what is limiting throughput in a BLE connection and parameters which can be tuned to improve it. Finally, we will walk through a couple practical examples where we evaluate and optimize the throughput of a connection.

Continue reading…

Building Better Firmware with Continuous Integration

Tue, 17 Sep 2019 00:00:00 +0000

In this post, we introduce Continuous Integration as a modern technique to allow larger teams to move fast without breaking things. We’ll explain what Continuous Integration is, why you may want to use it, and walk you through setting up CircleCI on a firmware project step by step.

Continue reading…

A Practical guide to ARM Cortex-M Exception Handling

Wed, 04 Sep 2019 00:00:00 +0000

In this article we will dive into the details of how the ARM Cortex-M exception model supports the handling of asynchronous events. We will walk through different exception types supported, terminology (i.e. NVIC, ISR, Priority), the configuration registers used & common settings, advanced topics to be aware of regarding exceptions and a few examples written in C.

Continue reading…

Building a CLI for Firmware Projects using Invoke

Tue, 27 Aug 2019 00:00:00 +0000

Building a small (or large) command line interface (CLI) for a project is a great way to get an entire team to build, test, debug, and work with a project in the same way using the same set of tools. This post goes into detail about how to think about a project’s CLI and implementing one using the Invoke Python package.

Continue reading…

Code Size Optimization: GCC Compiler Flags

Tue, 20 Aug 2019 00:00:00 +0000

In this post, we will review compiler options that we can use to reduce firmware code size. We will focus on arm-none-eabi-gcc, the GCC compiler used for ARM-based microcontrollers, though most of the compile-time flags we will cover are available in other GCC flavors as well as in Clang.

Continue reading…

From Zero to main(): How to Write a Bootloader from Scratch

Tue, 13 Aug 2019 00:00:00 +0000

In this post, we will explain why you may want a bootloader, how to implement one, and cover a few advanced techniques you may use to make your bootloader more useful.

Continue reading…

A Deep Dive into ARM Cortex-M Debug Interfaces

Tue, 06 Aug 2019 00:00:00 +0000

In this article we will walk up through the hardware and software stack that enables debugging on ARM Cortex-M devices, demystify what is actually happening and go through a step-by-step example, tracing a basic debugger operation end to end using a logic analyzer.

Continue reading…

Bluetooth Low Energy: A Primer

Tue, 30 Jul 2019 00:00:00 +0000

In today’s post, we will be covering one of the most popular low-power IoT technologies: Bluetooth Low Energy (BLE). We will give an overview of how BLE works, dig into each protocol layer, and walk you through an example setting up BLE on a Nordic nRF52 microcontroller.

Continue reading…

Using Python PyPi Packages within GDB/LLDB

Tue, 23 Jul 2019 00:00:00 +0000

In a previous post, we discussed how to automate some of the more tedious parts of debugging firmware using Python in GDB Scripts. To make these commands more powerful, one could use third-party packages from Python’s PyPi repository. In this post, we will discuss how to properly setup GDB, Python, and optionally virtualenv and then modify the uuid_list_dump command from the post mentioned above to make use of a third party package installed through PyPi.

Continue reading…

Fix Bugs and Secure Firmware with the MPU

Tue, 16 Jul 2019 00:00:00 +0000

Many ARM MCUs implement an optional unit, known as the Memory Protection Unit (MPU), which lets you control how regions of memory are accessed. In this article, we will deep dive into the unit and walk through a few practical examples of how it can be used to prevent bad memory accesses and security exploits on Cortex-M devices.

Continue reading…

Get the most out of the linker map file

Tue, 09 Jul 2019 00:00:00 +0000

In this article, I want to highlight how simple linker map files are and how much they can teach you about the program you are working on.

Continue reading…

Automate Debugging with GDB Python API

Tue, 02 Jul 2019 00:00:00 +0000

Previously we discussed how a significant portion of developer time is spent debugging firmware and how GDB can be a powerful utility for this. In this article we will discuss how to become more efficient at debugging by leveraging GDB’s Python API.

Continue reading…

From Zero to main(): Demystifying Firmware Linker Scripts

Tue, 25 Jun 2019 00:00:00 +0000

Last time, we talked about bootstrapping a C environment on an MCU before invoking our main function. One thing we took for granted was the fact that functions and data end up in the right place in our binary. Today, we’re going to dig into how that happens by learning about memory regions and linker scripts.

Continue reading…

Tools for Firmware Code Size Optimization

Thu, 06 Jun 2019 00:00:00 +0000

In this series of posts, we’ll explore ways to save code space and ways not to do it. We will cover compiler options, coding style, logging, as well as desperate hacks when all you need is another 24 bytes.

But first, let’s talk about measuring code size.

Continue reading…

GNU Build IDs for Firmware

Wed, 29 May 2019 00:00:00 +0000

In this post, we demonstrate how to use the GNU Build ID to uniquely identify a build. We explain what the GNU build ID is, how it is enabled, and how it is used in a firmware context.

Continue reading…

Debugging Firmware with GDB

Tue, 21 May 2019 00:00:00 +0000

If I had to choose one significant aspect that I was not aware of before starting my career as a firmware developer, it would be how much time is spent not actually developing, and instead debugging firmware!

Continue reading…

From Zero to main(): Bare metal C

Tue, 14 May 2019 00:00:00 +0000

Throughout the Zero to main() series of posts, we demystify what happens between when power is applied and your main function is called. In the process, we’ll learn how to bootstrap a C environment, implement a bootloader, relocate code, and more!

Continue reading…

Programming the ATSAMD21 with IBDAP

Thu, 25 Apr 2019 00:00:00 +0000

In the process of porting a blog post from the retired Arduino M0 Pro to Adafruit’s excellent Metro M0 Express, I ran into a few issues and scant amount of documentation. I’m writing this for the next poor soul wrestling with these systems.

Continue reading…