Workshop

Rust for C Programmers

Watch Now

02:19:55

EOC 2023

Login to Watch

Jacob Beningo

Jacob Beningo is an embedded software consultant, founder of Beningo Embedded Group, creator of the Embedded Software Academy, and co-founder of the Embedded Online Conference. He helps developers and teams maintain and modernize their embedded software skills and processes so they can deliver better firmware faster. His expertise spans automotive, defense, medical, and space industries. He’s even developed software systems that have propelled systems to the Moon and beyond. He has authored three books, including Embedded Software Design, sharing insights that guide engineers toward industry best practices and streamlined development approaches. Jacob also hosts the Embedded Frontier podcast, delving into cutting-edge trends and techniques that empower teams to continuously improve. Additionally, Jacob lectures, consults, and contributes articles (including for embeddedrelated.com, Design News, and embedded.com) on modern, real-time embedded software development. He holds two bachelor’s degrees from Central Michigan University in Electronics Engineering, and Physics and Mathematics. He also has a Master’s in Space Systems Engineering from the University of Michigan.

View full profile

Topics Covered

Microcontroller Rust Design Cycle

Workshop

Rust for C Programmers

Jacob Beningo

02:19:55 EOC 2023

Jacob Beningo

02:19:55

If you plan to attend and work through the hands-on materials, we recommend that you set up the following tools prior to the class:

1) Visit https://rustup.rs/ and follow the instructions to install Rust

2) Visit https://docs.rust-embedded.org/discovery/f3discovery/03-setup/index.html and follow the instruction in each of the following sections:

itmdump
cargo-binutils
arm-none-eabi-gdb
OpenOCD

The C programming language has been a staple of embedded software development for 50 years. Many languages like Ada, C++, and others have attempted to usurp it, only to fail. Rust is a memory-safe systems programming language that has been gaining interest across a wide variety of industries. This workshop will introduce the Rust programming language for experienced C programmers.

The focus will be on highlighting the similarities and differences between the two languages, with an emphasis on showing how Rust can provide improved memory safety and performance without sacrificing the low-level control that C programmers are accustomed to. Attendees will learn the basics of Rust's syntax and standard library, as well as best practices for writing safe and efficient code in Rust. By the end of the workshop, participants will have a solid understanding of Rust and will be able to start using it in their own projects.

Example topics covered in this workshop include:

Similarities and differences between C and Rust
An introduction to the Rust toolchain
Memory mapped I/O
How to utilize peripheral access crate (PAC) and HAL crate
Best practices for developing embedded applications in Rust

Examples and code walk throughs will use the STM32F3 Discovery board

1 / 6

Please log in or create an account to test your knowledge and see the answers.

What core language feature did Jacob identify as the primary reason Rust is attractive for embedded systems compared with C?

A Because Rust's built-in ownership and borrowing plus bounds checks provide stronger memory safety for embedded systems.

B Because Rust automatically garbage-collects memory at runtime, eliminating manual memory management.

C Because Rust's syntax is identical to C, allowing C code to run unchanged.

D Because Rust forces all variables to be immutable and prevents any mutable state at compile time.

E Because Rust eliminates the need for any runtime error handling on microcontrollers.

What warning did Jacob give about mixing Rust modules with existing C code?

A You cannot link Rust and C code; they are incompatible.

B You can compile Rust modules and link them into C, but calling into C can break Rust's safety guarantees.

C Linking Rust with C automatically converts unsafe C code into safe Rust code.

D Linking requires rewriting all C code as Rust before building.

E When linked, Rust's compiler enforces C's memory model so you keep Rust's safety guarantees unchanged.

Why does Jacob recommend using no_std when building embedded Rust firmware?

A no_std is used to exclude the standard library so embedded binaries are small and avoid features like heap and run-init code.

B no_std enables the full standard library and dynamic allocation for embedded targets.

C no_std only disables input/output macros like println!, but otherwise leaves the standard library intact.

D no_std tells the compiler to ignore all safety checks to improve performance.

E no_std is only necessary when running under QEMU, not on real hardware.

In Jacob's explanation of how embedded Rust projects are organized, what is the correct role of PAC, HAL, and board crates?

A PAC crates provide low-level peripheral register access, HAL crates provide higher-level hardware abstractions, and board crates compose board-specific features.

B PAC crates are high-level drivers, HAL crates contain only board pinouts, and board crates replace the need for a linker script.

C PAC, HAL, and board crates are alternative names for the standard library in embedded Rust.

D HAL crates auto-generate SVD files from C headers at compile time.

E Board crates are only used to host examples and are unrelated to hardware configuration.

What practical benefit of Cargo and the Cargo.lock file did Jacob highlight for team development?

A Cargo and the Cargo.lock file let Cargo resolve exact dependency versions so builds are reproducible and avoid "everyone on different versions" problems.

B Cargo.lock contains compiled binaries and must be executed to run the program.

C Cargo replaces rustc entirely and runs code without compiling.

D Cargo.lock prevents any dependency updates forever and must be manually edited to change versions.

E Cargo is only a package registry; it doesn't handle building or dependency resolution.

If you don't have an MCU board handy, what approach did Jacob recommend to start experimenting with embedded Rust?

A Use QEMU to emulate the target CPU and run embedded Rust when you don't have hardware, enabling fast testing and debugging.

B Always wait to get the physical MCU before trying Rust; emulation is unsupported for embedded targets.

C Use a full desktop build (no_target) and expect it to behave identically to the microcontroller hardware.

D Only use unit tests on the host; emulators like QEMU are slower and less reliable than running on actual hardware.

E Replace the microcontroller code with a Python simulation to validate embedded behavior.

Formatting help

italics	surround text with asterisks
bold	surround text with two asterisks
hyperlink	[hyperlink](https://example.com) or just a bare URL
code	surround text with `backticks`
~~strikethrough~~	surround text with ~~two tilde characters~~
quote	prefix with >

Upvotes Newest Oldest

JohnS

Score: 0 | 3 years ago | no reply

Thanks for presenting this session. I was able to get to the point where I have some code running on the STM32F3 discovery board, and so am now up and running with Rust!
I'd agree with your reflection that for future sessions it would be better to have a Docker container with all the tools loaded. I'm a big fan of vscode & docker containers for development environments.

Partners & Sponsors

STMicroelectronics

Amazon AWS

Golioth

The Qt Company

Memfault

NXP

SEGGER Microcontroller

PE Micro

PX5

Become a Sponsor