Overview
The popularity of the Arduino programming platform has increased to the point where most people are familiar with basic Arduino architecture and its various supporting networks. As a result, getting started with Arduino-based circuits is easy without understanding what’s happening under the hood or how to become acquainted with concepts like performance analysis. But are you a proficient programmer in Rust?
Learning Rust is a significant and complex step, even for developers that are used to developing codes using other programming languages. The development experience is quite different from language to language, but the fundamentals are easy enough to understand with just several books and virtual learning. While the first few days might seem confusing and frustrating, they’ll be more than worth the effort.
But what does the Rust programming language entail?
Rust Programming Language
Rust is a programming language that’s been around for about a decade. However, it’s much more than just a programming language. It’s an ecosystem consisting of tooling with the potential to offer much more than before. Rust offers several advantages over other programming languages, such as being memory-safe, highly concurrent, and parallelizable.
It also provides object-oriented features that fall short of the usual procedural languages like C or C++.
Additionally, Rust-embedded systems have expanded and include several exciting libraries. You can have a lot of fun with embedded systems by taking advantage of these libraries. These are among the many reasons most developers prefer to adopt Rust as a suitable programming language.
Rust Use Cases
Rust is used in programming situations centered around safety when dealing with memory management and concurrency. This is an essential piece of software in today’s world of programming. Rust is essential in programming in instances where resources are limited, especially when handling sensitive data or programs that could potentially cause harm if they misbehave.
By incorporating the most loved language by programmers, Rust, into Arduino, you’ll get to see so many advantages provided by Rust that will benefit your projects in ways you didn’t know were possible. But first, let’s get a deeper understanding of Arduino.
About Arduino
Arduino is an open-source hardware platform based on a simple microcontroller board. It’s intended for artists, designers, and hobbyists, with several official boards offering different features and capabilities. If you’re familiar with the Arduino platform, you may have thought it to be just another electronics prototyping tool. However, that couldn’t be further from the truth. The Arduino community has grown to become a large part of what is known as the Internet of Things (IoT).
The Arduino ecosystem consists of much more than hardware in how it’s used. It even supports several programming languages, including C++ and C. However, if you’re just starting with Arduino, you’re most likely to use the Arduino IDE for most of your development work.
In this context, we’ll have to deal with a new programming language, Rust. Understanding what Rust is and how to work with it will require some research and familiarity with explicit memory management and how the compiler can infer information about the program at compile time rather than runtime (for instance, in a dynamic-typed language like Python).
Learning Rust for Arduino
For the most part, getting started with Rust for Arduino is similar to learning any other programming language. You’ll have to do some reading and learning of basic syntax and concepts, so you’ll have to take your time with it.
The most important thing to note is that Rust doesn’t provide a helpful mechanism for handling failure (at least not the way you’d expect from languages like Java or Python), and many errors are considered programmer errors. Therefore, learning Rust will require more care regarding data parsing, input sanitization, and similar tasks.
How to Run Arduino Code
When writing an Arduino program, the first thing to consider is how the board should be used. The process of running code on Arduino is very different from other languages. First, you have to create a sketch using the Arduino IDE. Afterward, place the sketch on a board. This sketch needs to have all the features required for it to run, including executable code, embedded variables, and setup functions that are called during execution.
After the code has been compiled, it needs to be uploaded to the board. The programmer needs to connect a wire from pin A through a series of resistors to GND (ground). If the code is being executed as an application on a computer, it will first compile and upload the program before running.
Let’s Write Some Arduino Rust Code
The process will be almost identical if you’ve used Arduino. You’ll have to create a new sketch, connect your circuit to the board, and compile and upload it. We’ll not worry about this one step since we can’t do anything about errors. Therefore, let’s start writing some code!
Rust for Arduino comes with a rust/rustc-serialize that manages the serialization of Rust data structures. Therefore, let’s use it!
|
1 2 3 |
extern crate rustc_serialize; ... let hello_str = serialize_str!(Hello from Rust on the Arduino board); print!("Hello {}!", hello_str); |
We can use the serialize_str! Macro to convert our Rust data structure into an ASCII string representation that can be printed out later. The serde library does this by traversing the structure and looking for a special kind of marker called tags. This will be familiar if you’ve ever developed a similar code using C++ or C#.
What if we wanted greater flexibility by allowing users to provide their struct? If we were using another language, we’d probably make it a global variable and allow access from anywhere. To do this, we’ll have to create a new file named rust_program.rs and define a single struct that will be allowed to pass by the module.
|
1 2 3 4 |
// rust_program.rs struct ArduinoStr { } ... let hello_str = serialize_str!(ArduinoStr { name: "Arduino"}); print!("Hello {}!", hello_str); // |
Rust for Arduino is not fully-featured, so we have to provide accessor methods. This is not necessary for other programming languages due to their strict type-checking. Rust for Arduino reads Rust data structures in a very non-standard way. It also doesn’t provide tools to transform Rust data structures into other formats, such as Prolog or JSON.
In this case, we just want to print the data out. Therefore, we’ll use println! instead of println!(ArduinoStr f).
That’s it! We’ve created and run our first Rust program on the Arduino board. But why would we want to serialize a Rust struct first? This is just a convenience, just like using IO.puts!(String s) when you want to print a string from a file.
Conclusion
This article aims to teach programmers about Rust, reasons to adopt this programming language, and Rust use cases including Arduino projects. Also here you can find tips on how to write a simple Rust program, which can then be compiled and uploaded to the Arduino board.
The process of writing codes using Rust is identical to any other programming language on the Arduino platform, with some minor differences in error handling or data structures. Serializing Rust data structures is simple and intuitive due to the use of tags.
And that’s it! By using Rust on the Arduino platform, you can run Rust project ideas frequently and improve your programming skills over time.
1 Comment
Hi, Thank you for sharing. I have found an interesting
Arduino projectsfor you.