EmbeddedRelated.com
Jacob Beningo
Live online course · Jacob Beningo
AI for Embedded Developers
$100 off for EmbeddedRelated readers until Dec 6 · 5 live sessions, Dec 7-11
Discount ends in
26days 00hrs 55min 57sec
Learn More →

Cortex-M Exception Handling (Part 1)

Ivan Cibrario BertolottiIvan Cibrario Bertolotti ● November 28, 2015●2 comments

This article describes how Cortex-M processors handle interrupts and, more generally, exceptions, a concept that plays a central role in the design and implementation of most embedded systems.


Coding Step 4 - Design

Stephen FriederichsStephen Friederichs ● November 24, 2015

Good embedded software design is about more than making code work, it is about making it readable, reusable, testable, debuggable, robust, and efficient. In this installment of the Coding Step series, Stephen Friederichs uses an AVR-based “Hello World” example to show how those goals shape naming, file structure, UART buffering, watchdog use, and heartbeat LEDs. The result is a practical design walkthrough that turns style and architecture choices into engineering advantages.


Handling latency in data acquisition systems

Fabien Le MentecFabien Le Mentec ● November 8, 2015

In recent projects, I found myself working with data acquisition systems. For instance: PCIe/10GbE readouts for 2D XRay detectors (RASHPA slides, RASHPA paper) instruments mixing 1D signal acquisition and triggering, microcontroller based system for audio transmission: (NRF spearker)


Developing software for a safety-related embedded system for the first time

Michael J. PontMichael J. Pont ● October 31, 2015●1 comment

Developing a safety-related embedded product is not the same as writing ordinary firmware, and this article lays out eight practical steps to get you started. Using a washing-machine controller as a running example, it covers scoping, key requirements, hazard analysis, applicable standards, platform and MCU choices, runtime monitoring, and prototyping. The checklist helps teams prepare for verification, testing, and later certification work.


Practical CRCs for Embedded Systems

Stephen FriederichsStephen Friederichs ● October 20, 2015●3 comments

Stephen Friederichs shows a practical way to get correct CRC code quickly by using PyCRC to generate C implementations, then verifying them on the desktop and an AVR ATMega328P. The post walks through the common generation algorithms, how to self-test with the standard "123456789" check value, and a real timing comparison that exposes the speed versus memory tradeoffs for embedded systems.


Trust, but Verify: Examining the Output of an Embedded Compiler

Jason SachsJason Sachs ● September 27, 2015

Jason Sachs argues embedded engineers should read their compiler's assembly even if they rarely write assembly. He walks through Microchip XC16 output for dsPIC33 devices, showing how simple C variants and optimization flags produce very different code. The article demonstrates practical verification techniques and a tiny Python helper, pyxc16, to quickly inspect assembly for timing-sensitive firmware without rewriting everything in assembly.


Coding Step 3 - High-Level Requirements

Stephen FriederichsStephen Friederichs ● August 17, 2015●2 comments

Stephen Friederichs turns the series toward embedded code by showing how to write a single high-level requirement for an embedded Hello World. He explains when requirements pay off, how they support testing and scope control, and why you should not write them for every small script. He then lays out five practical rules and applies them to a concrete EHW-001 serial transmission requirement.


Lessons Learned from Embedded Code Reviews (Including Some Surprises)

Jason SachsJason Sachs ● August 16, 2015●2 comments

Jason Sachs recounts a round of motor-controller code reviews and the practical lessons his team learned about quality and tooling. He explains how a simple "ready for review" checklist and automated style checks kept meetings focused on substantive issues, and why choosing the right review tool matters after discovering lost comments in Stash. Read for concrete tips on process, subgit mirroring, vera++, and Upsource.


Dark Corners of C - The Comma Operator

Stephen FriederichsStephen Friederichs ● July 23, 2015●8 comments

Ever seen a line like if (!dry_run && ((stdout_closed = true), close_stream(stdout) != 0)) and wondered what that comma means? Stephen Friederichs unpacks the rarely-discussed C comma operator, shows a circular-buffer example where it seemed to simplify looping, then demonstrates how precedence and readability problems (and even MISRA C bans) make it dangerous in practice. Read on for practical uses and cautionary lessons.


Important Programming Concepts (Even on Embedded Systems) Part VI : Abstraction

Jason SachsJason Sachs ● June 16, 2015●3 comments

Abstraction is essential, but it is not free. Jason Sachs walks through the many faces of abstraction—pattern recognition, generalization, simplification, and indirection—and shows how each helps and hurts real projects. Using examples from math, API design, UI toolkits, schematics, and embedded C, he gives practical context so firmware engineers can apply abstractions without causing maintenance or debugging headaches.


Tenderfoot: Recommended Reading

Matthew EshlemanMatthew Eshleman ● June 28, 2017●1 comment

Twenty years on, these are the books that turned an electrical engineer into an embedded software pro. Matthew Eshleman walks through influential reads from Code Complete to Practical Statecharts and Test Driven Development, explaining how each shaped his design, estimation, and testing practices. This short list is a practical starting point for 'tenderfoots' launching an embedded firmware career.


Picowoose: The Raspberry Pi Pico-W meets Mongoose

Sergio R CaprileSergio R Caprile ● October 6, 2024

This example application describes the way to adapt the George Robotics CYW43 driver, present in the Pico-SDK, to work with Cesanta's Mongoose. We are then able to use Mongoose internal TCP/IP stack (with TLS 1.3), instead of lwIP (and MbedTLS).


Embedded Systems - free EdX course by UT-Austin!

Lonnie HoneycuttLonnie Honeycutt ● October 29, 2013●1 comment

Lonnie shares a free edX Embedded Systems course from UT Austin that teaches hands-on firmware using the TI Tiva Launchpad. The class centers on practical projects, culminating in an arcade-style shooter built with an 80 MHz ARM Cortex-M4 board and inexpensive peripherals like the Nokia 5110 display. It’s a low-cost path to move from hobby tools to industry-style microcontroller development.


What is “real time”?

Colin WallsColin Walls ● November 7, 2024●5 comments

The post clarifies the technical meaning of “real time” for embedded systems and contrasts it with the colloquial sense of immediacy. It presents a precise definition: a real-time system’s correctness depends on both logical results and the time at which those results are produced, so missing timing constraints constitutes failure. The article emphasizes determinism — low variance in operation timing — as the key property of real-time systems, and contrasts classic RTOS behavior with general-purpose Linux’s higher timing variance. It also notes that raw CPU overprovisioning can mask nondeterminism in some designs, but is not always practical, reinforcing that real time means predictable timing sufficient for the application, not simply “fast.”


When a Mongoose met a MicroPython, part I

Sergio R CaprileSergio R Caprile ● March 31, 2024

This is more a framework than an actual application, with it you can integrate MicroPython and Cesanta's Mongoose.
Mongoose runs when called by MicroPython and is able to run Python functions as callbacks for the events you decide in your event handler. The code is completely written in C, except for the example Python callback functions, of course. To try it, you can just build this example on a Linux machine, and, with just a small tweak, you can also run it on any ESP32 board.


3 Overlooked Embedded Software Elements

Jacob BeningoJacob Beningo ● July 9, 2022●3 comments

Jacob Beningo points out three often-overlooked elements that can make embedded projects less painful and faster to ship. He highlights model-generated code for off-target iteration, configuration-generated code to manage SKUs and avoid fragile conditional compilation, and automated test harnesses to catch regressions early. The post gives practical reasons to consider each approach and how they fit into modern embedded DevOps.


The Hardest Bug I Never Solved

Matthew EshlemanMatthew Eshleman ● December 27, 2018●9 comments

A single overlooked sentence in the STM32 datasheet turned intermittent startup resets into a major time-leach. Senior engineers chased DMA buffers and overflows for hours until Unni discovered the ISR vector table had been relocated to RAM with only 256 byte alignment while the MCU required 512 bytes. The misalignment caused interrupts to jump to the reset handler, and fixing the alignment stopped the reboot loop for good.


Embedded Developers, Ditch Your IDEs – Here’s Why!

Amar MahmutbegovicAmar Mahmutbegovic ● September 25, 2023●1 comment

Ditching your Integrated Development Environment (IDE) temporarily can be a transformative learning experience in embedded development. This post invites you to explore the underpinnings of IDEs by delving into alternative tools and processes like Makefile, CMake, Vim, GDB, and OpenOCD. Understanding these tools can demystify the background operations of IDEs, revealing the intricacies of compiling, linking, and debugging. This journey into the “under the hood” aspects of development is not just about learning new tools, but also about gaining a deeper appreciation for the convenience and efficiency that IDEs provide. By stepping out of your comfort zone and experimenting with these alternatives, you can sharpen your skills, enhance your knowledge, and possibly discover a more tailored and streamlined development experience. Whether you're a novice or a seasoned developer, this exploration promises insights and revelations that can elevate your embedded development journey.


Embedded Firmware Refactoring, Optimisation and Migration

Ian SmithIan Smith ● March 29, 2016

Legacy embedded products often hit CPU, memory, or power limits long before customers stop wanting new features. This article lays out three practical paths: squeeze more from the current build with optimisation, make the codebase maintainable through refactoring, or port firmware to new hardware when constraints demand it. Read on for a pragmatic view of when each approach makes sense and how to reduce risk.


Getting Started With CUDA C on an Nvidia Jetson: Hello CUDA World!

Mohammed BillooMohammed Billoo ● March 13, 2024

In this blog post, I introduce CUDA, which is a framework designed to allow developers to take advantage of Nvidia's GPU hardware acceleration to efficiently implement certain type of applications. I demonstrate an implementation to perform vector addition using CUDA C and compare it against the traditional implementation in "regular" C.