Welcome to the October 2018 edition of the Embedded Artistry Newsletter! This is a monthly newsletter of curated and original content to help you build superior embedded systems. This newsletter is intended to supplement the website and covers topics not mentioned there.
This month we'll cover:
- Embedded Artistry's C++ Framework Project
- Three more projects embedded developers should be aware of
- Embedded articles from around the web
- Website updates
Embedded Artistry Framework Project
Over the past two years in San Francisco, I’ve had the opportunity to consult with dozens of companies and to work on a wide variety of embedded products. Most teams and projects seem to struggle with the same issues, especially with hiring firmware engineers and keeping projects on schedule.
Why is everyone running into the same roadblocks?
In order to find solutions, I've been immersing myself in the software engineering corpus, reflecting on the coupling between firmware and hardware, learning software architecture, practicing Test Driven Development, and researching embedded libraries and frameworks that can help firmware developers move faster.
What I’ve noticed is that the software industry has learned a lot of lessons over the past fifty years, but we’ve failed to incorporate many of them in the embedded community. We are building products in less time, with minimal teams, and generally using poorly tested vendor SDKs. We aren’t decoupling our software from the underlying hardware. Many embedded teams still don’t utilize modern development practices such as static analysis, unit testing, and continuous integration.
What if we actually leveraged the lessons we’ve learned as an industry? What if we built our embedded software in such a way that we minimized coupling with the underlying hardware and RTOS?
- We could begin developing and testing our embedded software before we have hardware in house
- We could write device drivers on our host machine (talking to real parts) and port them over to our target hardware with full confidence that they will work
- We could defend against the inevitable changes in components and processors that trigger software rewrites and massive schedule delays
- We could leverage proven libraries and frameworks to save time and avoid reinventing any wheels
- We could automate our testing and check our code often for preventable bugs
Embedded Artistry is building an embedded C++ framework which will help us accomplish these goals. We want to provide embedded teams with a solid foundation that incorporates our lessons learned and supports modern development practices.
Our primary goal is to support decoupling firmware from hardware at various levels of abstraction (platform, circuit board, processor). Rather than aim for universal abstractions and interfaces, we want to provide a minimal foundation which teams can expand to meet their product’s specific goals and requirements.
We are currently building our basic framework structures on a host machine to ensure we can develop software off-target. Later this fall we’ll bring the framework up on a couple of common embedded platforms.
I’ll be sharing more about the framework as it evolves over the coming months. In the mean time, I’d love to hear from you if you think your team could benefit from a system like this.
Three More Useful Embedded Projects
I always have my eyes open for interesting embedded projects. I want to share three more projects that I've discovered, two of which are being actively used in our framework:
- Embedded Template Library
For other embedded projects, libraries, and frameworks which we've shared, check out the following editions:
- September 2018: Testing Embedded Systems
- May 2018: C++ Embedded Frameworks
- April 2018: C & C++ Libraries We Like
Embedded Template Library
A common concern with using C++ and the STL on embedded systems is the reliance on exceptions and dynamic memory allocation. For many embedded systems, use of these features is disallowed. Working around this limitation is possible, but often more difficult than project schedules allow for.
John Wellbelove of Aster Consulting Ltd created the Embedded Template Library (ETL) to address these issues. The ETL provides fixed-capacity STL container alternatives and requires no dynamic memory allocation, no RTTI, and no exceptions. The ETL also provides additional container types, helpful utilities, algorithms (such as CRC), reusable framework components (FSM, state chart, scheduler, callback timer), and an abundance of documentation.
If your embedded compiler doesn't support modern C++ standards, you're in luck - the library is compatible with C++03, and many of the C++11 features have been backported through the ETL.
The ETL is an becoming an essential tool for our embedded C++ development. We've adopted the ETL in our current framework project to take advantage of fixed-capacity containers and other useful features.
printf is one of those commands that every developer relies on. However, using
printf on many embedded systems can be a challenge due to the size of the library (20kB+ is not uncommon). Perhaps you do not want to link with
libc for your platform, or the implementation you're using requires you to implement esoteric system functions for each platform.
The mapaland/printf implementation addresses these problems. The implementation is ~600 lines and has no external dependencies. The library is reentrant and all of the useful flags (including floating point and precision/width specifiers) are supported. All you have to do to get up and running on your platform is define a
_putchar() function which outputs a character over your chosen communication bus (UART, USB, BLE, etc.).
If you're working with C++ on embedded systems, chances are that you've come across the Practical Guide to Bare Metal C++. This free e-book is an excellent starting point for applying C++ to embedded systems, and the author walks through the creation of many useful embedded systems constructs.
The concepts presented in the book are fleshed out in the companion
embxx is written in C++11 and targeted for bare metal and embedded Linux systems. The library doesn't use RTTI or exceptions, and most of the constructs presented in the library utilize static memory allocation.
Sadly, the project is no longer active, but it still serves as an excellent resource for embedded C++ developers. Many of the utilities, such as
StaticPoolAllocator, are always useful for embedded systems. The project also serves as a great reference for how we can utilize template meta-programming and static memory allocation schemes when writing embedded C++ software.
Around the Web
Mohammad Afaneh at Novel Bits published a four-part tutorial on Bluetooth Mesh. If you want to learn about Bluetooth Mesh, start with this series.
- Part 1: BT Mesh Concepts
- Part 2: Models, Scenes, Nodes, and BT Mesh Architecture
- Part 3: Provisioning and Security
- Part 4: nRF5 SDK for BT Mesh
Mohammad also shared an interesting white paper in his weekly Bluetooth newsletter: Bluetooth Angle Estimation for Real-Time Locationing. The paper discusses using Bluetooth Angle of Arrival and Angle of Departure for indoor locationing.
Jack Ganssle continues to publish his "Top 10 Reasons Embedded Projects Get Into Trouble". We've worked our way to Number 3:
- 10: Not Enough Resources Allocated to a Project
- 9: Jumping into Coding Too Quickly
- 8: The Undisciplined Use of C and C++
- 7: Bad Science
- 6: Crummy analog/digital interfacing
- 5: Weak managers or team leads
- 4: Writing optimistic code
- 3: Poor resource planning
Our Glossary page has been expanded. If you notice any terms or acronyms that are missing, let us know!
We've restructured our Libraries page and added more of our own open-source projects to the list.
Our Technology Radar has been updated:
- We are now using TDD and recommend it for adoption
- We are recommending the Embedded Template Library for adoption after completing our trial period
- We are experimenting with automated clang-tidy checks on our framework project
- We have moved away from Doctest and are now trying out Catch for our C++ unit testing because it supports
The following article was published on our website in September:
These were our most popular articles in September:
- Circular Buffers in C/C++
- Jenkins: Configuring a Linux Slave Node
- Installing LLVM/Clang on OSX
- C++ Casting, or: "Oh No, They Broke Malloc!"
- An Overview of C++ STL Containers
- Jenkins: Running Steps as sudo
- Migrating from C to C++: NULL vs nullptr
- Implementing an Asynchronous Dispatch Queue
- Jenkins: Kick off a CI Build with GitHub Push Notifications