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

We hope you enjoy these links, and we look forward to hearing what you’ve been reading in the comments or on the Interrupt Slack.

Articles & Learning

• Debugging Arm Cortex-M MCU’s Webinar - April 22nd by Chris Coleman
  We haven’t linked our webinars on the blogroll before, but we’ve had many people in the community sad that they missed them, so here it is! Memfault’s own Chris Coleman is going to give a webinar on debugging Arm Cortex-M MCU’s. It’s going to be technical and complete with stories and intricate bugs. They’be been a fun time in the past, and this shouldn’t be an exception!
• Professional CMake - A Practical Guide (E-Book)
  This e-book came up in the Interrupt Slack channel and was believed to be one of the best resources for learning CMake. It’s $30, which is well worth it.
• Why I rewrote my Rust keyboard firmware in Zig: consistency, mastery, and fun by Kevin Lynagh
  A software engineer and designer with a hobby in building keyboards writes about his experience porting his keyboard firmware from Rust to Zig. Also be sure to check out another page on the blog, Notes from a year of building keyboards as well, especially if you are interested in building your own keyboards! Good stuff.
• Embedding Rust Into Zephyr Firmware Using C-bindgen by Jared Wolff
  Trials and tribulations and a well-written tutorial on writing a Rust CBOR serialization library and make it work alongside a C project.
• Writing our own Cheat Engine: 6 Part Series by Lonami
  Every so often, you come across a blog or series and you wonder why no one sent it your way. This is one of those. A well-written, detailed, and fun read on building an application to help you find exploits and cheats in Windows games. Many topics are touched on, including the basics of writing a debugger in Rust.
• Notes for beginning with STM32 by Avatar Zamir SUN
  Our Best - Worst MCU SDK post continues to get link-backs, and we’ll continue publishing follow-ups to this post. Zamir found that the STM32 ecosystem along with STM32CubeIDE was a good place for him to start as a beginner embedded developer.
• Learning C xor C++ Programming (Cheat Sheet)
  Simple, to-the-point cheat sheet for developers transition to or from C to C++, all built in a Google doc and complete with godbolt references too.
• Pulling Bits From ROM Silicon Die Images: Unknown Architecture by Ryan Cornateanu
  Not quite firmware, but interesting none-the-less. Ryan dives many layers deep into silicon to extract the firmware directly from a die. I appreciate the amount of chemistry in the article.
• Microcontroller Firmware Recovery Using Invasive Analysis by Mikhail Davidov
  Similar to the above article, this article also talks about extracting the firmware from silicon using a well-equipped garage.
• Actual Examples of RAII in embedded C++ by Stratify Labs
  The title pretty much says it all! A short and sweet post. (What is RAII?)
• Nordic DFU Like a Rockstar by Dojo Five
  A good overview of the Nordic nRF52 DFU mechanism.
• How to implement a hash table (in C) by Ben Hoyt
  I have a soft spot for short and sweet algorithm posts. In this one, Ben go through the various data structures to build for searching, starting with lists and ending with a hash map.
• A Practical Approach to Attacking IoT Embedded Designs (Part 2) by Ruben Santamarta
  Ruben covers various security vulnerabilities in popular RTOS’s and libraries, such as stack and buffer overflows and memory corruption. Do note that all of these issues were patched at the time the article was written.
• A survey of concurrency bugs by Matthew Eshleman
  An article that covers the most common concurrency and threading issues that happen on embedded systems.
• Using Rust for a simple hardware project by Brian Schwind
  A blog post by Tonari that tells the story from start to finish on building out a simple firmware using Rust (open-source too!) and an STM32 and ESP32.
• Running hardware-in-the-loop tests on GitHub Actions by Ferrous Systems
  By hooking up a “self-hosted runner” to Github Actions and then attaching a few hardware devices to this machine, you can run hardware-in-the-loop tests for your firmware, mostly orchestrated via the cloud!

Neat Projects

• Sourcetrail
  A local, open-source application that assists you in searching and visualizing code and dependencies. Works with C, C++, Python, and more! We are fans of OpenGrok and Sourcegraph at Memfault, but they do accomplish different goals (and are cloud-based).
• Lizard Code Complexity Analyzer
  Lizard is python-based cyclomatic complexity analyzer for C/C++ and many other languages. It counts lines of code, complexity of code, and number of tokens and parameters per function, as well as detects copy-paste within code-bases. Could be a useful thing to throw into your CI system and print the results in a Github Pull-Request comment.
• Zephyr Scientific Library (zscilib)
  A scientific library targeted at embedded systems, specifically the Zephyr platform. I don’t know any consumers of the library, but it looks like a fun project! Includes function for help with chemistry, physics, and complex math operations. Includes unit tests, which is a big plus in my book.
• Mutable Instruments
  A synthesizer company built upon the STM32 with most (if not all) of the firmware open-sourced and written in C++! I’m surprised this project does not come up often when people ask for good open-source firmware projects. So many build targets, hardware, and different products are built upon the same firmware repo. It makes me so happy.
• The PocketGlitcher by LimitedResults
  An in-depth article detailing the creation of the PocketGlitcher, a voltage glitching device, built with a BeagleBone.
• CortexProg
  An open-source hardware and firmware project by Dmitry which attempts to replace your J-Link and other debuggers. Check out the manual to read more about the various features. V4 went up on Kickarter but was unsuccessful in funding, and V5 is now open-sourced. ZeroWireTrace sounds especially cool.
• Embox
  Another RTOS on the block. Embox is POSIX compliant and tries to be more like Linux without being Linux (which sounds similar to the goal behind NuttX). I’ve personally never heard of any projects using this RTOS.
• I2C Device Library by Jeff Rowberg
  I attended last week’s NY Firmware/Embedded Systems Meetup and learned about this project! It is a library, collection of tools, web applications, and growing database built to help developers integrate with the growing list of I2C devices.
• peplin/pygatt
  A Python library built to interface with Bluetooth devices over the BLE GATT protocol. I could see this being useful in automated testing systems interacting with devices over BLE.

Random!

• Wait, What? MIPS Becomes RISC-V by EE Journal
  Turns out MIPS will start making chips based on the RISC-V architecture! That was a wild ride.
• GCC Rust Weekly Status Report 9 by Philip Herrons
  Rust will soon come to GCC. Here, the author details the progress being made with weekly updates.
• A Look at the Fragmented Landscape of IoT Connectivity by Tobias Goebel
  One of the better articles detailing the various protocols used by today’s IoT devices.