What happens if you accidentally write to address 0x00000000 on an STM32 microcontroller? Answer: usually almost nothing, because most linker scripts by default map a bank of flash there, and you can’t write to flash normally. The flash controller does notice and sets an error flag, but most applications aren’t exactly checking the flash peripheral’s error flags on a regular basis.
However, if you use the HAL to try and perform a flash operation, it doesn’t bother checking the error flags *before* trying to perform an operation. It just tries, and reports any errors it observes at the end. So, if you have an application that occasionally makes a spurious write to the zero address, and also performs flash operations, it will manifest as spurious failures of the flash operations.
How might one go about discovering which part of a large application is accidentally writing to address 0? The debug hardware on the STM32 is unable to use a watchpoint for peripheral addresses, like the flash controller’s error status. What I ended up doing was using the SYSCFG_MEMRMP register to make address zero be an alternate mapping of SRAM after the application has started. After which, you can set a data watchpoint on address 0 to get a break exactly when the spurious write occurs.
For me, that puts the ISR table there, but that isn’t a problem because I only needed to do this temporarily to use a watchpoint.
As part of some experimentation in native Windows tools for moteus, I’ve created a dirt simple rules_wix repository in github. It provides a minimal wrapper around the WiX Toolset for creating Window’s installers from within bazel. There’s nothing fancy there yet, but it can at least make an installer with a single executable in it!
I used Dear Imgui for the simple Mech Warfare control application I built earlier and was relatively impressed with the conciseness with which one could develop effective (although not necessarily the prettiest), interactive and response user interfaces in C++. For some time I had been planning on developing a new diagnostic application for the mjbots quad that would allow plotting like the original tplot.py, but would also integrate recorded video and 3D rendering and diagnostics. I had assumed I would use HTML/JS because it is the cool new thing, but I never got up the energy to make it happen, because every technical step along the way had big hurdles. I figured I would give Dear Imgui a try, but the big thing it was missing was plotting support.
In the original tplot.py, I used matplotlib for plotting integration. It is a high quality python library that can make interactive plots in nearly every imaginable form as well as production quality static plots. It integrates with a number of GUI toolkits, in tplot I used it along with PySide. The downside is, that given that it supports nearly anything under the sun, the code itself is relatively complex and hard to tweak. In order to make tplot.py support multiple axes I had to do some careful source inspection to figure out which undocumented things could be poked.
Dear ImGui itself has a bare bones plotting system, but that doesn’t have anywhere near the feature set I would need. The next system I seriously considered is implot. It is very new, as in its repository is only a few weeks old, but already supported most of what I needed for a diagnostic tool. The biggest thing it didn’t have was support for multiple Y axes.
So I took a stab at adding them!
One weekend later, I was largely successful:
Only a day after that and Evan had fixed up a few remaining problems and got it merged into master: https://github.com/epezent/implot/commit/5eb4b713849
A previous simulator I had built for Super Mega Microbot was based on the “DART” robotics toolkit. It is a C++ library with python bindings that includes kinematics, dynamics, and graphical rendering capabilities under a BSD license. I wanted to use some of its dynamics capabilities for future gait work on the quad A0, and eventually re-incorporate its simulation capabilities, so integrated a subset of it into mjbots/bazel_deps.
For many years now on and off I’ve played in the programming contest associated with the International Conference on Function Programming. Each time it has been fun, exhilarating, and definitely humbling! www.icfpcontest.org
This year, the competition runs from Friday June 21st through Monday June 24th. Once again we’ll be competing as “Side Effects May Include…”. Look for us on the leaderboard and cheer on!
While updating the mjmech code-base to interoperate with the moteus servos, I simultaneously was updating it to use C++17. C++ rarely removes or deprecates features, but one of those which actually was removed in C++17, after being deprecated in C++11, was auto_ptr. unique_ptr is strictly superior in all regards, and so there is no real reason not to switch.
However, mjmech depends upon a large amount of third party software. Amazingly, only one package actually was broken by this removal of auto_ptr, log4cpp. It actually saw some updates for C++17 compliance back in 2017, but otherwise hasn’t been updated since then. I went ahead and forked it, and got it compiling with clang in C++17 mode at least:
After doing that, I discovered that someone had already posted a similar patch 2 years ago to the sourceforge page, but which was never applied. Oh well, it wasn’t that much duplicated effort.
When I initially created rpi_bazel, I set it up to use a host provided clang. I decided to update that so that the rpi_bazel rules themselves download a binary version of an arbitrary clang. This lets you decouple the version of clang from what is available in any given Linux distribution and improves the reproducibility of builds, since you are no longer dependent on whatever PPA you used to grab clang from.
To make that work in a cross compilation environment, the rules also cross compile libcxx and libcxxapi. However, since bazel’s support for C++ toolchains is still in flux, for now binaries must explicitly depend upon the C++ standard library if they want it. On the plus side, that now makes it trivial to fully support C++17 on the raspberry pi. It should also be easy to update this to clang 8, although I haven’t gotten around to doing so yet.