The third annual Embedded Online Conference did an important thing first and foremost: it was better than the prior one. It hasn’t replicated the entirety of the Embedded Systems Conference, which many of us miss (presently company included), but by having great sessions, it has a big part of what the old conference had, and that alone makes it worthwhile.
Organizers Stephane Boucher and Jacob Beningo continue to pull in the best of the best to present at this event, and they added to it with a couple of shorter MicroTalks as well. This year’s set of sessions was certainly the best yet, as indicated by how I found myself adding a large number of sessions to My Agenda, their excellent tool for noting the sessions you prioritize to check out.
A good number of those sessions were released ahead of the main conference dates, so attendees could get a head start. I checked out a few and have more to go, with the early ones whetting my appetite for the ones still to come.
The first on-demand sessions I checked out were Troubleshooting Embedded Applications with Runtime Visualizations, an excellent look at how far real-time trace has come with Percepio’s Tracealyzer and the great detail one can gain with it as opposed to some other debug methods, and Electromagnetic Fault Injection Made Easy with PicoEMP by Colin O’Flynn, who gave an excellent and similarly eye-opening presentation last year. O’Flynn’s presentation can be of interest to a range of audiences; as a software engineer it’s eye-opening to see how something physical can impact a device and code running on it, and while not discussed here, it is something to consider in software development when it comes to reliability and, more importantly, security.
Later, I checked out Linux on RISC-V, which was more of an informational talk around the growing ecosystem with the RISC-V instruction set architecture (ISA). Drew Fustini’s talk, in many ways an update of the one he gave on the subject at the Embedded Linux Conference just a few months ago, was full of information on what is now happening there, as well as places to look for more information on it. One interesting tidbit was seeing that one of the bibles of computer architecture – Computer Organization and Design by Patterson and Hennessy – now has a RISC-V edition.
Firmware Co-Design & Development for IP Cores in C++/SystemC using Verilator was an interesting look into SystemC later on. I have heard and occasionally read about it over the years, but never used it or known of it being used where I work, but I came away more intrigued as this got as in-depth with it as anything I have read or seen on it. Before getting into it in detail, Amir Alavi talked about the co-design process and the advantages it has over a more traditional process.
The last of these last sessions I checked out prior to writing were The Modern UX is Mine: How Personalizing the Embedded GUI Unlocks the User Experience of Tomorrow, where Harrison Donahue talked about the challenges of personalizing software for embedded devices and how Qt is helping to solve them, and Timing, Scheduling, Latencies – Model-Based Approach to Design, Optimization, Analysis and Test, where Olaf Schmidt went through the benefits of simulation in this model-based approach and showed a couple of examples, including finding early timing issues.
Colin Walls has been at this for a long time, having recently retired. While especially known for his work on real-time operating systems, including his recent book RTOS Design, he is more than qualified for a presentation like the one he did to get Tuesday’s slate started, C – The Language of Embedded. After running down many programming languages, including ones designed for embedded development, he zoomed in on C and the aspects of the language that are of most interest to embedded developers like pointers, switch statements and how the compiler comes into play. It’s worth noting that over a decade ago, he wrote what I consider to be one of the must-read books as an embedded software engineer, Embedded Software, and included is an excellent section and quiz on dealing with structures in C and how much memory they use.
Beningo was up next with Successful Embedded Software Design. Having attended many talks by him and taken a couple of his trainings, there was not much in this session I had not seen before, but what I recognized from past presentations, I largely saw in a different light from seeing a different juxtaposition as in this session. There was a good flow of material, including starting off with the modern agile development process and the benefits of a good software architecture (most of which will not be apparent right away) and going on to considerations that come up in implementation as well as DevOps, the latter an increasingly important part of software development. Later in the presentation, he talks about automating your configuration and the benefits of it at every step of development. Included is a helpful example of how to generate starter task source and header files for a FreeRTOS-based project using YAML, Python and C template files.
Johan Kraft, the CEO and founder of Percepio, was up next with How to Detect Anomalies in RTOS Applications. He went over several techniques to find anomalies, from asserts to check parameters to software instrumentation and how to contain the performance hit from it, as well as the benefits of hardware trace when available. Percepio makes Tracealyzer, one of the best tools for embedded software out there.
After that, the legendary Jack Ganssle gave a keynote entitled Learning From Disasters. The theme was similar to one he gave at ESC Boston a long time ago, but this was no repeat – it was what anyone who knows Jack’s work has come to expect, and over 100 attendees took it in live. He looked at failed bridge and space projects to talk about the lessons we must learn from them, from tired engineers working too many hours and making mistakes as a result to not using a version control system to testing being insufficient on multiple levels. They included schedules ruling the day – a big no-no – as well as dismissing failures as a glitch or something similar. He noted how the Pathfinder had a priority inversion problem that was said to be simply a glitch; it also could have been nipped in the bud by a watchdog timer, which it did not have. He showed a great graph of successful and failed projects and how much time they took, and not surprisingly, the failures had one thing in common: all were below the trendline of how much time the project took.
It is noteworthy that insufficient testing was a common theme of the failures he talked about. Many of these failures came before DevOps came into practice, and if nothing else, these make the case for the practice since DevOps done right means more and earlier feedback on problems in software. One wonders if some of the problems that led to these failures may have been caught in such a scenario.
During the Q&A portion, which ran past the start time of the next session, a lively discussion among participants ensued as well. All of it speaks to the high esteem in which Jack is rightly held.
The next session on tap was OpenPLC: A Unique Approach to Programming Microchip ATMega 328 Microcontrollers by Don Wilcher, who in contrast to many presenters has made his mark in part as an educator and researcher on this subject. He ran down the traditional approach to programming microcontrollers, which was text-based languages, then worked his way to Blockly, an open source library, and OpenPLC. He went over versions 1.0 and 1.2b of OpenPLC, then showed the environment for it and an example along with some references for further investigation.
From there, it was on to Live Hack: Demonstrating Common IoT Security Weaknesses by Joe Hopper. As was the case with Colin O’Flynn’s presentation, this was eye-opening, as it showed just how easily one can get a wide variety of information to get into many systems, including flash once it is found, and even see your firmware and steal it. Hopper doesn’t stop with that, though, as he mentions some things we can take from this like keeping key ports (JTAG, UART, SPI) closed off outside of development and securing the boot process as part of having security in depth.
A really interesting presentation, Adventures in Debugging, followed. Alvaro Prieto took us through a few interesting debugging experiences he had and lessons learned from them. One involved jumping through numerous hoops and ruling out everything in the software and the hardware he got into, before finally finding that the problem involved the drive level of a crystal – ironically, a crystal he had issues with before. Another of note involved logging to an SD card, which was interesting because some of the lessons learned regarding file size and the size of individual writes, have parallels elsewhere in software.
Thursday began with Xilinx FPGA guru Adam Taylor’s presentation Why Your FPGA Design Might Need a Softcore Processor. After talking about the two major classes of control structures and then looking at hard processors vs. softcore processors, he went more in-depth on common softcores like MicroBlaze, RISC-V and some Arm Cortex processors. He also went in-depth on AXI, which is a big part of Xilinx designs as they are committed to AXI AMBA 4.0, and it’ no small part of the MicroBlaze.
Kate Stewart then gave a little different talk, SBOMs: Essential for Embedded Systems, too! We’ve all heard of a bill of materials (BOM), but they have long been connected with hardware. Software is a different beast, and this presentation showed that while progress is being made there, it hasn’t been easy because of things like terminology (different ideas on what a component is, for example) and a lack of standards. She went into how Zephyr and Yocto, two prominent open source embedded projects, are now including this.
The crown jewel of Thursday came in the afternoon with Dan Saks presenting a four-hour workshop entitled What C++ Can Do For Embedded Systems. Having read a lot of his work over the years in great publications of a bygone era like C/C++ User’s Journal and Embedded Systems Design, as well as keynotes and workshops he gave at the Embedded Systems Conference, I came in well-acquainted with his top-notch work. He didn’t disappoint, going right into the weeds on many aspects of C that are a challenge for embedded developers, and right off the bat he educated us well in talking about lvalues and rvalues. The best summary came from one attendee who said that this was the best description of those he ever encountered, and that alone made it worth the cost of registering for the conference.
The day wasn’t over after that, as the second MicroTalk of the event saw informative and interesting brief presentations by Frida Gail Rojas Contreras on CRC algorithms, Clive “Max” Maxfield on switch debouncing, Glenn Kirilow on migrating to another FPGA device vendor in this time of chip shortages and Steven Graves on why real-time systems need a real-time database. All had lively Q&A for several minutes after the presentations.
The conference has come and gone, and registered attendees have access to the presentations for some time to come. It’s a good thing we do, because there are plenty more still to check out from a conference that had a lot to offer attendees. At the time of this writing, there are over 20 presentations still unseen on my agenda, including two workshops, and I intend to check them all out in due time.