Rust Everywhere

Over the December break I decided to start looking at learning Rust, the main reason really is that I have been using "C" for all my embedded controller code and stumbled on some articles mentioning that Rust works great on a lot of micro-controllers and saw that for the controllers I use (Atmega640, ESP32 and Arm Cortex M series) it has good support.

The first step was to look at some online tutorials (https://doc.rust-lang.org/book/) is a good starting place. Having some experience in "C" and "Go" , I thought that after a week or two I should be up to speed, converting a lot of the Go micro-services I have build to Rust and then once that was out the way start seriously on the embedded projects. I also looked at a pile of Youtube videos and tutorials on Rust.

Almost 3 months later and I'm still at beginner level, still learning, still pulling my hair out, Rust is not for the fainthearted, I found an article that states the benefits of Rust "The main purpose of using Rust is enhanced safety, speed, and concurrency, In simple words, Rust is used for three essential purposes in programming; performance, safety, and memory management." Rust does not have a garbage collector, all variables are immutable by default, it has the concept of ownership, the compiler is extremely helpful with its borrow checker, it won't allow your code to compile if you have memory issues, it's frustrating, yet when you see the benefits of "fearless concurrency" and the guarantee that when your code compiles it is memory safe, no race conditions, it does give you a great sense of confidence.

So back to my embedded journey I created an ESP32S3 (16MB of flash memory, 32 bit micro controller running at 40Mhz), using Kicad (an amazing opensource electronics cad program that runs on Linux). I sent the board artifacts to OSHPark for manufacturing and then bought the components from a local electronics distributor (mouser.it). It took me about an hour to solder all the components and do a simple power-on test.

The next step took me a while to get working, I built the rust toolchain for esp from scratch (thanks to Sylvain Kerkour https://kerkour.com/compile-rust-for-esp32-xtensa-on-raspberry-pi-aarch64)

mkdir esp32
$ cd esp32
$ git clone https://github.com/esp-rs/rust.git
$ cd rust        

You need to get the LLVM project as esp32 is not upstream yet

$ git submodule update --init --recursive --remote src/llvm-project        

Then, you can finally build Rust

$ ./configure --experimental-targets=Xtensa
$ python3 x.py dist --stage 2
# still in esp32/rust
$ rustup toolchain link esp `pwd`/build/x86_64-unknown-linux-gnu/stage2        

Build LLVM - both took a while to compile , so if you are this adventurous, be patient :)

$ cd src/llvm-project
$ mkdir build
$ cd build
$ cmake -G Ninja -DLLVM_ENABLE_PROJECTS='clang' -DCMAKE_BUILD_TYPE=Release ../llvm
$ cmake --build .
$ export PATH="$HOME/esp32/rust/src/llvm-project/build/bin:$PATH"        

Once I had my rust environment set, I started on getting the tools to compile and flash my specific ESP32S3 target.

$ cargo install -f ldproxy espflash espmonitor
$ rustup default esp        

I created a simple webserver from the project https://github.com/ivmarkov/rust-esp32-std-demo. Compiled it for the target (set in the .cargo/config.toml file). Then spent about an hour to figure out why the espflash was not working. I found that in my design I needed to pull the GPIO0 (Boot) pin for the ESP32 to ground and press the reset button on the board.

Finally got the espflash to upload and flash the code

I then went into the serial console to verify the messages and boot sequence

Finally executed a curl command (in a loop) to verify it was all working

This was one the hardest "learning objectives", I have tackled, Rust is different, you need lots of time to understand it, practice it and grasp its uniqueness with regards to memory safety.

For me now its Rust everywhere, I'm going to finish off my Arm Cortes M series designs, build and embed Rust and connect them to the ESP32 interface, this will make for a fast robust generic IoT device. I'm looking at WebAssembly next, using a WASM runtime on Kubernetes (the project is called Krustlet), all written in Rust, I honestly think that the future is Rust, my prediction is (like in the Linux kernel now) all high performance and highly scalable enterprise applications will be written in Rust. Its truly going to be "Rust Everywhere"