I’ve had a confusing mismash of development tools for the moteus servos for a while now. My original development tool was in python, which worked just fine. Coroutines allowed me to express complex asynchronous logic succinctly, the program itself was rather simple, and I could easily integrate it with matplotlib for plotting. However, when looking to run this on the raspberry pi, I needed a newer python version than came with raspbian, which turned out to be a royal pain to get installed in a repeatable manner. Thus I rewrote a portion of the moteus_tool in C++ and just used my normal cross-compiling toolchain to generate the binaries. What I didn’t do was port the calibration logic, as the state machine required with standard boost::asio would have bloated the logic size by 5x, and I didn’t really need to calibrate servos from the raspberry pi ever.
Still, I’ve wanted to consolidate these tools for a while now, and while working towards other telemetry and development tool goals, I decided to make another pass at removing the duplicity. I figured it was time to try using the new C++20 coroutines to implement the asynchronous logic in C++ and see if I could get rid of the python tool. Since I’m currently vendoring all the compilers and libraries for the C++ applications, I am already running clang-9.0 with libc++ and boost 1.72 for all the host side tools which theoretically should all support coroutines just fine.
Why coroutines?
To recap, typical callback based boost::asio code looks something like this:
void DoSomething() {
boost::asio::async_write(
*stream_,
boost::asio::buffer("command to send"),
std::bind(&Class::DoneWriting, this, pl::_1));
}
void DoneWriting(boost::system::error_code ec) {
FailIf(ec);
boost::asio::async_read_until(
*stream_,
response_,
"\n",
std::bind(&Class::HandleRead, this, pl::_1));
}
void HandleRead(boost::system::error_code ec) {
FailIf(ec);
// Do something with the result.
}
This gets even worse if you have embedded control flow. Typically the best you can do is construct an object to hold the state, and bind it around to keep track of things:
struct Context {
int iteration_count = 0;
};
void Start() {
auto ctx = std::make_shared<Context>();
Write(ctx);
}
void Write(std::shared_ptr<Context> ctx) {
message_ = fmt::format("{}", ctx->iteration_count);
boost::asio::async_write(
*stream_,
boost::asio::buffer(message_),
std::bind(&Class::HandleWrite, this, pl::_1, ctx));
}
void HandleWrite(boost::system::error_code ec,
std::shared_ptr<Context> ctx) {
FailIf(ec);
ctx->iteration_count++;
if (ctx->iteration_count >= kLoopCount) {
Done();
} else {
Write(ctx);
}
}
Now, when coroutines are used, you can relinquish control with a simple “co_await”, and all the logic can be written out as if it were purely procedural:
boost::asio::awaitable<void> Start() {
for (int i = 0; i < kLoopCount; i++) {
auto message = fmt::format("{}", i);
co_await boost::asio::async_write(
*stream_,
boost::asio::buffer(message),
boost::asio::use_awaitable);
}
}
Not only is this significantly shorter, it more directly expresses the intent of the operation, and lifetime of the various values is easier to manage. No longer do we have to keep around the buffer as an instance variable or a shared ptr to ensure it lives beyond the write operation. It stays in scope until it is no longer needed like any other automatic variable.
moteus_tool
Switching moteus_tool to coroutines was straightforward, and resulted in a big reduction in the verbosity required.
