awesome-embedded-rust

awesome-embedded-rust is a really good curated list of embedded Rust learning resources: https://github.com/rust-embedded/awesome-embedded-rust?tab=r...

Can the developer or any Rust users comment on using Sonatino with the Rust ESP32-S3 toolchain? Is there an SVD file defining the Sonatino's specialized peripherals so one can use rust2svd to create a Peripheral Access Crate (PAC) specific to the Sonatino? I'm interested in the other ergonomic Rust HAL representations as well. https://github.com/esp-rs/esp-pacs/tree/main/esp32s3 https://github.com/rust-embedded/svd2rust https://github.com/rust-embedded/awesome-embedded-rust?tab=r...

The overall argument that Rust's use in embedded has a long way to go is fairly accurate. A foundational crate like embedded-hal reached 1.0 only 2 months ago, 8 years after Rust 1.0. On the other hand, this crate reaching 1.0 means the rest of the ecosystem can now mature alongside it. The paper could use a few minor corrections and improvements. For example, they go through thousands of crates in crates.io to give the impression of completeness, but it would have been better to go though a more curated source like https://github.com/rust-embedded/awesome-embedded-rust. It doesn't matter if the quality of random one off crates that someone hacked over a weekend is poor, it does matter if the crates recommended by the community are poor. But I suppose their analysis would look impressive then. The other nit is that they think that the exi

This fits as a "list of links by topic": https://github.com/rust-embedded/awesome-embedded-rust

I agree with a sibling comment point that Arduino's main strength is that it simplifies the installation of tooling, not that the code is particularly easy. But, on the code side, I think that embedded-hal is excellent https://docs.rs/embedded-hal/latest/embedded_hal/ Here are the supported boards https://github.com/rust-embedded/awesome-embedded-rust#hal-i... There's a book on rust on esp https://esp-rs.github.io/book/ Here's how to blink a led using esp-idf-hal, targetting espressif https://github.com/esp-rs/esp-idf-hal/blob/master/examples/b... /! Blinks an LED //! //! This assumes that a LED is connected to GPIO4. //! Depending on your target and the board you are using you should change the pin. //! If your board doesn't have on-board LEDs don't forget to add an appropriate resistor. //! use esp_idf_hal::

Thanks! I knew no Rust at all before starting. Yikes was it frustrating to learn a completely new language. I had to go through the whole rust book, not skipping any basics, in order to get there. I also assigned myself a homework assignment to get used to the concepts. See the other blog post on wyldcard.io/blog Honestly, by the time I got to the finished prototype, I could have just done the whole thing with Javascript. Although intending to use an SDM32F7 for the finished project, it was really convenient to use a raspberry pi for development. Using VS Code, I could program remotely on the pi from my Mac and iterate really quickly. the awesome-embedded-rust[1] repo was very helpful. TBH, embedded rust really feels like it's not ready for hobbysists who aren't embedded experts already. [1] https://github.com/rust-embedded/awesome-embedd

I don't think the poor quality code is due to Rust itself. I think manpower is a big part of it. Rust doesn't inherently lead to good quality code, which the article implies. Re code examples - Here's the Rust Awesome Embedded List - a collection of tools (especially hardware support drivesr) - https://github.com/rust-embedded/awesome-embedded-rust Most of them aren't suitable for use in practical projects; they're missing important features like non-blocking operation, low-power modes, DMA etc - these are all things that will come up in embedded projects, but aren't needed for the "hello world" examples they include. Part of this is from attempting to conform to embedded-HAL traits, which support only the broadest feature sets.

Another alternative is rust. https://github.com/rust-embedded/awesome-embedded-rust I intend to have a try of both rust and tinygo. Micropython is only ok on an esp32 with psram.

See Tock OS https://www.tockos.org/ for another Rust-based embedded OS with a fairly comparable design to Hubris. The debugging capabilities of Humility make an interesting comparison to what's provided by cargo-embed https://probe.rs/docs/tools/cargo-embed/ and the Knurling Tools https://knurling.ferrous-systems.com/tools/ by Ferrous Systems. Ultimately, the embedded space (including all sorts of low-level, retro, "bare-metal", remote etc. programming) has common needs and it would be convenient to see more widespread cooperation among these projects, improving reliability and avoiding wasteful duplication of work. More resources at https://github.com/rust-embedded/awesome-embedded-rust

Take a look at the well maintained Awesome Embedded Rust GitHub page here https://github.com/rust-embedded/awesome-embedded-rust There is a section called no-std crates which lists a couple of useful crates like bbqueue and heapless. I find it insightful to browse through the public repos of the authors of popular embedded rust crates and see what crates they use most often.

If you are supporting Windows or Linux, and are supporting the x86 platform, then for me the only reasons to use C++ over Rust are for compatibility with existing code/libraries, or lack of Rust expertise on the team and no time to learn Rust. If you are working in an embedded environment Rust is still very capable, but the tooling for Rust does not seem at the level of the embedded tooling for C and C++. You can still use Rust for embedded, and there are success stories to be found in the links below. [1] https://www.rust-lang.org/what/embedded [2] https://rust-embedded.github.io/book/ [3] https://github.com/rust-embedded/awesome-embedded-rust [4] https://github.com/rust-embedded/cortex-m-quickstart

> Perhaps the Rust team should make their compiler work on reasonable resources, like 32 bit processors Rust compiles for and runs on STM32, a 32-bit microcontroller: https://docs.rust-embedded.org/discovery/ And here's an index of supported embedded hardware: https://github.com/rust-embedded/awesome-embedded-rust#drive...

I'm definitely on super thin ice with C -- C++ is the surer bet. To be fair, there are also people who have been working tirelessly to improve C++ so they're not getting left behind either. I do think eventually it could replace C though -- because rust with `unsafe` blocks still has the possibility of being safer than C. This could be a boon to security critical software, as long as the performance margin isn't too hard. Shops that have found ways to write safe C will likely never move (they don't need to), but new ones might pick rust where they might have picked C otherwise. BTW, the embedded support in rust is really impressive for such a young language: https://github.com/rust-embedded/awesome-embedded-rust

Probably because of snippets like this one: "the idea of putting "Embedded" on the front page and trying to advertise Rust as a useful embedded language isn't just laughable--it's dangerous. Rust is so far from useful in embedded that people who try to use it will NEVER come back" Embedded is still at its early development stages, just like WASM and just like asynchronous network programming. Still, all those are on the front page. WASM a year ago and wasm todays is a tremendous difference. A year ago, in my opinion, WASM was something for experimentation. Now, a lot of the ecosystem "just works" and is developing really quickly. You can write a working JS library and upload it to NPM without even touching a line of JavaScript code. Async (network) programming in Rust with async/await is promising but still in flux, so the ecosystem hasn'