Lightweight C++ Error-Codes Handling
The traditional C++ approach to error handling tends to distinguish the happy path from the unhappy path. This makes handling errors hard (or at least boring) to write and hard to read. In this post, I present a technique based on chaining operations that merges the happy and the unhappy paths. Thanks to C++ template and inlining the proposed technique is lightweight and can be used proficiently for embedded software.
Use DPLL to Lock Digital Oscillator to 1PPS Signal
Introduction There are occasions where it is desirable to lock a digital oscillator to an external time reference such as the 1PPS (One Pulse Per Second) signal output from a GPS receiver. One approach would be to synchronize a fixed frequency...
FSM - Let 'em talk
No state machine is an island. State machines do not exist in a vacuum, they need to "talk" to their environment and each other to share information and provide synchronization to perform the system functions. In this conclusive article, you will find what kind of problems and which critical areas you need to pay attention to when designing a concurrent system. Although the focus is on state machines, the consideration applies to every system that involves more than one execution thread.
Boot sequence for an ARM based embedded system -2
In the last post, we discussed about the startup execution sequence on an ARM based embedded system in broader terms. In this post, we are going to cover the details of a startup code.These details are also available through various ARM resources...
There are 10 kinds of people in the world
It is useful, in embedded software, to be able to specify values in binary. The C language lacks this facility. In this blog we look at how to fix that.
Learning Rust For Embedded Systems
The Motivational PortionBased on recommendations from Kevin Nause, the VolksEEG project is considering using Rust as the embedded system programming language. So I've been off on a tear skimming books and e-books and watching videos at 2x to...
nRF5 to nRF Connect SDK migration via DFU over BLE
This writeup contains some notes on how I was able to migrate one of my clients projects based on the nRF5 SDK, to nRF Connect SDK (NCS) based firmware, via a DFU to devices in the field over BLE.
Ten Little Algorithms, Part 5: Quadratic Extremum Interpolation and Chandrupatla's Method
Today we will be drifting back into the topic of numerical methods, and look at an algorithm that takes in a series of discretely-sampled data points, and estimates the maximum value of the waveform they were sampled from.
Introduction to Microcontrollers - More On Interrupts
[quicklinks] A Little More Detail About The Interrupt Mechanism It's time to look a little closer at what happens in an interrupt request and response. Again this is in general terms, and different microcontroller designs may do...
Elliptic Curve Cryptography - Security Considerations
The security of elliptic curve cryptography is determined by the elliptic curve discrete log problem. This article explains what that means. A comparison with real number logarithm and modular arithmetic gives context for why it is called a log problem.
Handling Translations in an Embedded Project
A brief walkthrough on how to handle human language translations in a low level C application. Some options are listed, each with advantages and disadvantages laid out.
Elliptic Curve Cryptography - Basic Math
An introduction to the math of elliptic curves for cryptography. Covers the basic equations of points on an elliptic curve and the concept of point addition as well as multiplication.
What does it mean to be 'Turing complete'?
The term "Turing complete" describes all computers and even some things we don't expect to be as powerful as a typical computer. In this article, I describe what it means and discuss the implications of Turing completeness on projects that need just a little more power, on alternative processor designs, and even security.
Mastering Modern FPGA Skills for Engineers
In the rapidly evolving tech industry, engineers must acquire proficiency in modern FPGA skills. These skills empower engineers to optimize designs, minimize resource usage, and efficiently address FPGA design challenges while ensuring functionality, security, and compliance.
Open-Source Licenses Made Easy with Buildroot and Yocto for Embedded Linux
In this article I will try to explain what are the copyrights/copyleft, what are the popular opensource software licenses, and how to make sure that your Embedded Linux system complies with them using popular build systems ; Buildroot or YOCTO projec
There are 10 kinds of people in the world
It is useful, in embedded software, to be able to specify values in binary. The C language lacks this facility. In this blog we look at how to fix that.
Getting Started With Zephyr: Devicetree Overlays
In this blog post, I show how the Devicetree overlay is a valuable construct in The Zephyr Project RTOS. Overlays allow embedded software engineers to override the default pin configuration specified in Zephyr for a particular board. In this blog post, I use I2C as an example. Specifically, I showed the default I2C pins used for the nRF52840 development kit in the nominal Zephyr Devicetree. Then, I demonstrated how an overlay can be used to override this pin configuration and the final result.
Embedded Developers, Ditch Your IDEs – Here’s Why!
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.
C to C++: Using Abstract Interfaces to Create Hardware Abstraction Layers (HAL)
In C to C++, we've been exploring how to transition from a C developer to a C++ developer when working in embedded system. In this post, we will explore how to leverage classes to create hardware abstraction layers (HAL). You'll learn about the various inheritance mechanisms, what an virtual function is, and how to create an abstract class.
Getting Started With Embedded Linux - From Nothing To A Login Prompt
One of the famous observations that have been made related to embedded systems is referred to as “Moore’s Law”, which states that the number of transistors in integrated circuits doubles every year. This observation has held mostly true...
Scorchers, Part 3: Bare-Metal Concurrency With Double-Buffering and the Revolving Fireplace
This is a short article about one technique for communicating between asynchronous processes on bare-metal embedded systems. Q: Why did the multithreaded chicken cross the road? A: to To other side. get the — Jason Whittington There...
The Other Kind of Bypass Capacitor
There’s a type of bypass capacitor I’d like to talk about today. It’s not the usual power supply bypass capacitor, aka decoupling capacitor, which is used to provide local charge storage to an integrated circuit, so that the...
Coding Step 2 - Source Control
Articles in this series:Coding Step 0 - Development EnvironmentsCoding Step 1 - Hello World and MakefilesCoding Step 2 - Source ControlCoding Step 3 - High-Level RequirementsCoding Step 4 - DesignWhen I first started out in programming,...
Using a RTLSDR dongle to validate NRF905 configuration
I am currently working on a system to monitor the garage door status from my flat. Both places are 7 floors apart, and I need to send the data wirelessly. I chose to operate on the 433MHz carrier, and I ordered 2 PTR8000...
An overview of Linux Boot Process for Embedded Systems
This Text provides an insight in to the Embedded Linux Boot Process. Reader should have a basic Knowledge of Boot Process in general and should be familiar with Embedded Linux Boot Process..................PART-A................(1) Software...
Designing for Humans: Viewing DFM and Industrialization Through the Lens of the Fitts MABA–MABA List
"Operator’s fault" and "Inadequate Training" are the phrases you typically hear when yield loss and stubborn manufacturing issues are discussed. While these factors may play a role, they rarely tell the whole story. This article views DFM and industrialization through the lens of a classic human factors principle; the Fitts MABA-MABA list, and highlights a critical, yet less-discussed factor: the lack of manufacturing-focused human factors considerations in product design. It explores practical examples like Proprioceptive Fatigue and Visual SNR, and shows how lots of chronic manufacturing issues are results of bad upstream design decisions, echoing the fact that in many cases, inspection exists not because it is inherently valuable, but because the design failed to encode correctness directly into the product or process. If you’ve ever wondered why "retraining" never seems to fix a recurring defect, this take on industrialization and manufacturing might explain why.
Static or static
The keyword static in C and C++ has multiple uses, which are not always well understood.
Optimizing Hardware Design: Reducing Iterations with DSM
Often, product teams curate feature roadmaps that fail to account for the interdependencies in product components. For this article, I wrote about how system architecture tools like Design(dependency) Structure matrix (DSM) can be used to evaluate feature roadmaps to avoid the purgatory of change propagation and accompanying endless Iteration loops. These iteration loops are sometimes affordable (manageable) in software development (Agile saves lives), but for hardware teams - especially small product teams and startups - the lost time, and money is the stuff of which product graves are made.
