atsamd
stm32-rs
atsamd | stm32-rs | |
---|---|---|
10 | 8 | |
534 | 1,174 | |
1.3% | 2.2% | |
6.6 | 8.7 | |
14 days ago | 6 days ago | |
Rust | Python | |
Apache License 2.0 | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
atsamd
-
Rust in Automotive
It’s definitely used for “nonsafety” stuff like infotainment. The ATSAMD HAL/PACs are probably the most complete embedded microcontroller family as far as Rust support goes, and that’s a part with heavy intent toward automotive use.
-
Looking for a highly resource constrained target to run Rust on. Any ideas?
The Rust ATSAMD community has been very helpful getting me going. I've really become fond of RTIC as a way to get a little structure in my programs.
- Code Rust in Aurdino??
-
Are there any ways to use rust for the Arduino MKR WiFi 1010?
The atsamd-rs rust folks (https://github.com/atsamd-rs/atsamd) have made this way easier! Check out my top level comment!
-
Hello, Microcontroller! Intro to video codecs and the "hello, world" of microcontrollers implemented in ~100 lines of dependency-free Rust
I'm obviously biased, but as a starting point I would recommend getting an Arduino and following the process in the article. Once you have a blinking LED, try it again using a HAL like atsamd-rs/atsamd. Then try making it more complex: configure the clock and replace the delay implementation with something that takes a proper duration argument, add serial IO via the USB port so you can communicate with your program as it runs, connect some more LEDs or buttons and interact with them, or make some network requests.
-
Writing embedded firmware using Rust
The embedded-hal project supplies these for a wide variety of controllers, for SAMD specifically, https://github.com/atsamd-rs/atsamd .
-
First steps with Embedded Rust: Selecting a board
No love for Microchip nee Atmel? https://github.com/atsamd-rs/atsamd
-
Want to Learn Programming and Microcontrollers?
Am admittedly too inexperienced to properly weigh the pros and cons of various platforms, but I find the Rust support for certain embedded platforms to be particularly compelling.
https://github.com/atsamd-rs/atsamd
I have at least managed to get some literal blinkenlights doing what I want on various Adafruit boards with very little effort.
- I’d like to learn rust to make a USB device that enumerates as a mouse to the OS and shakes the pointer every once in a while. I’m a web developer by trade. How realistic is this project?
stm32-rs
-
STM32F4 Embedded Rust at the PAC: svd2rust
Developing code at the PAC, well, requires a PAC crate for the targeted controller. For the STM32 there exists a repo for all the supported PACs. These PACs are all generated using a command line tool called svd2rust. svd2rust grabs what is called an svd file and converts it into a PAC exposing API allowing access to peripheral registers. An SVD file is an Extensible Markup Language (XML) formatted file describing the hardware features of a device, listing all the peripherals and the registers associated with them. SVD files typically are released by microcontroller manufacturers.
-
Next Rust Compiler
In real world software, 99% of code is gluing preexisting lower-level functions together. In C/C++, the unsafe is implicit and needlessly covers everything. In Rust, the unsafe is only needed for the 1%.
You can safely implement a doubly-linked list in Rust, using unsafe, and that list can offer a safe interface so that the next higher level of code does not need to use unsafe. In fact, one doubly-linked list implementation that provides a safe interface is in the Rust standard library: https://doc.rust-lang.org/std/collections/struct.LinkedList.... . Most people do not rewrite std::list in C++ either.
Much of the Linux kernel really is the same: normal C code (maybe slightly more complicate than average userspace code, and definitely more carefully reviewed, but definitely not magic), that depends on extra carefully written lower level primitives that are _much_ more complicated internally than they appear from the outside (like the memory allocator, printk, RCU, etc.).
Rust is powerful enough to have libraries for register level access to micro-controllers (e.g. https://github.com/stm32-rs/stm32-rs), that encode moderately complex access rules safely in the type system (e.g. which specific set of bits is read-only or write-only, with which particular values (with nice human-readable names, even!), in which particular states of a state machine depending on other bits), all while allowing bypassing the restrictions with a simple unsafe keyword without even giving up on the nice API.
On the C/C++ side, I've used libopencm3, MBED, CMSIS, and everyone's favorite toy, Arduino. They're, in different ways, all much more mature and complete than anything Rust has today, but nothing comes even remotely close to Rust in terms of safety and long term potential.
-
NVIDIA Security Team: “What if we just stopped…
Packages: Where would I start with e.g. running Ada on a stm32? Resources are just a bit tough to find, and there's only a single stm32 package on Alire (which was inspired by cargo). But Rust has easy to find PACs and HALs for everything in the family, plus an official guide to setting up a project, including HIL debugging and unit testing on qemu, that takes about 15 minutes.
-
Cloning a Rare ISA Card to Use a Rare CD Drive
> (I threw out all my C/C++ books about 15 years ago - oops!).
The future is here for STM32: https://github.com/stm32-rs/stm32-rs
- Is there a database of peripheral implementations for different STM32 MCU parts?
-
Writing embedded firmware using Rust
Specifically these Rust register definitions are being auto-generated using SVD files published by the chip vendors (https://www.keil.com/pack/doc/CMSIS/SVD/html/index.html). For stm32 for example there are the auto-generated register definitions: https://github.com/stm32-rs/stm32-rs and then the HAL layers on top that try to build easy to use tools on top of the registers (e.g. an SPI or USART type with write and read functions). e.g. https://github.com/stm32-rs/stm32f4xx-hal for the stm32f4xx line
-
Any frameworks in Rust for developing on SiFive / ST / NXP boards?
For STM32, check out the Peripheral Access Crates by the stm32-rs ream. For higher-level access, I wrote This HAL library for STM32. Works on most newer variants, and includes examples for specific peripherals, and simple applications.
-
CMSIS libraries
Patches: https://github.com/stm32-rs/stm32-rs/tree/master/devices
What are some alternatives?
avr-hal - embedded-hal abstractions for AVR microcontrollers
libopencm3 - Open source ARM Cortex-M microcontroller library
SAMD21 - Library Helpers for the Atmel SAM21D
stm32-hal - This library provides access to STM32 peripherals in Rust.
linux-embedded-hal - Implementation of the `embedded-hal` traits for Linux devices
stm32f4xx-hal - A Rust embedded-hal HAL for all MCUs in the STM32 F4 family
riscv-rust-quickstart - A template for building Rust applications for HiFive1 boards
probe-run - Run embedded programs just like native ones
uf2-samdx1 - USB Mass Storage bootloader (based on UF2) for SAMD21 and SAMD51
hubris - A lightweight, memory-protected, message-passing kernel for deeply embedded systems.
OpenSK - OpenSK is an open-source implementation for security keys written in Rust that supports both FIDO U2F and FIDO2 standards.
esp32 - Peripheral access crate for the ESP32