David Bunting

Embedded Systems Get Rusty

Whilst C and C++ remain the king of low-level languages, Rust has disrupted the status quo and is quickly moving from New Kid On The Block to industry standard in its own right, from kernels to robotics, Rust might just be the future.

As an embedded systems developer and lover of all things C, it's hard to admit when there might be a better alternative, but in the interest of integrity (and maybe a little future proofing), I need to see what all the fuss is about.

Installation and Tooling

To kick off, Rust is an incredibly simple and lightweight install. For Mac and Linux users, it's a simple terminal install with Curl:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

you can find this command and all the docs you might need at Rust's installation page. For Windows users, there's and installer available here.

A great little quality of life improvement in the installer is that it automatically updates the PATH variable to include Rustup. It's a little thing, but they matter.

After installation, you're going to have to pick your editor of choice. JetBrains has Rust Rover because of course they do, and the latest and greatest Zed is available for Mac users, but I'll be sticking with my tried-and-tested VS Code.

Hello World

For Hello World, things couldn't be simpler. We invoke a new main function and use the built-in println macro (remember in Rust, a macro ends in a !).

fn main() {
        println!("Hello World);
}

After generating a binary using our Rust Compiler:

rustc yourdocname.rs

Bob's your mother's brother, we have successfully made the terminal say hello, go us!

Now, println isn't actually 'built in', Rust is just assuming that we are going to build using our host operating system and is including the std library ahead of our main function. Should you want to go bare metal (and I do) we're going to want to ensure we don't include those default libraries, as well as retarget for our chosen hardware.

#![no_std]
#![no_main]

fn main() {
        println!("Hello World);
}

As a complete amateur in Rust, there's something about the hash-bang syntax that immediately makes me feel like I'm going to like this language.

One of the aspects of Rust that immediately piqued my interest was it's dependency management. All ye who enter here rejoice, for there is a package manager, and its name is Cargo! Cargo allows developers to manage dependencies (like compilation targets) with a Python-style manager in the terminal. For my target, the Seeeduino Xiao RP-2040, we'll need the thumbv6m-none-eabi. This can easily be installed with the command:

rustup target add thumbv6m-none-eabi

First Steps

Now we can have a crack at our first bare metal Rust project!

to start a new project in Rust, the following command:

cargo new rustyseeduino

This creates a new directory with a git repository, a source folder and a cargo.toml file, and in the source file we are given a main.rs with the Hello World base code.

Now comes some research. You see, Rust is still relatively new in the embedded world and, depending on your chosen board, you may have to do some research before being able to boot to anything. I struggled somewhat, although that is in all likelihood down to me. Just keep in mind, your mileage may vary.

I won't dig too deep into my trials and tribulations here. Needless to say, I'm incredibly grateful for the open- source community around Rust, and the seeeduino-xiao-rp2040 crate and RP-RS Github Organisation were my saving grace. Although I still feel like a baby giraffe taking its first steps, at least now I'm not a blind baby giraffe.

Conclusions

I'm not going to lie, I struggled with Rust a little more than I thought I would. It was certainly interesting, and I feel I'm starting to see the forest for the trees, but here's what I learned:

  • Start with Rust on your home operating system to get to grips with the language's idiosyncrasies.
  • When you do jump into the embedded side, be sure to choose a platform with plenty of support and maybe a starter project, you'll spend less time scratching your head.
  • Be ready for some growing pains. It's easy to forget how complex embedded can be, especially if you're used to working within a certain toolchain or method.

I very much enjoyed my little Rust experiment, even though I barely scratched the surface of what this language can do. After playing around on my host OS, the promises of memory integrity and dependency management are quite real, and very promising for the future.

For now though, I think I'll stick with C... probably.