atsamd
humility
atsamd | humility | |
---|---|---|
10 | 6 | |
534 | 514 | |
1.3% | 1.0% | |
6.6 | 8.3 | |
14 days ago | 3 days ago | |
Rust | Rust | |
Apache License 2.0 | Mozilla Public 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?
humility
-
Barracuda Urges Replacing – Not Patching – Its Email Security Gateways
A lot of questions in there! Taking these in order:
1. We aren't making standalone servers: the Oxide compute sled comes in the Oxide rack. So are not (and do not intend to be) a drop in replacement for extant rack mounted servers.
2. We have taken a fundamentally different approach to firmware, with a true root of trust that can attest to the service processor -- which can turn attest to the system software. This prompts a lot of questions (e.g., who attests to the root of trust?), and there is a LOT to say about this; look for us to talk a lot more about this
3. In stark contrast (sadly) to nearly everyone else in the server space, the firmware we are developing is entirely open source. More details on that can be found in Cliff Biffle's 2021 OSFC talk and the Hubris and Humility repos.[0][1][2]
4. Definitely not vaporware! We are in the process of shipping to our first customers; you can follow our progress in our Oxide and Friends podcast.[3]
[0] https://www.osfc.io/2021/talks/on-hubris-and-humility-develo...
[1] https://github.com/oxidecomputer/hubris
[2] https://github.com/oxidecomputer/humility
[3] https://oxide-and-friends.transistor.fm/
- Do you use Rust in your professional career?
-
What's the project you're currently working on at your company as a Rust developer?
It's a mix of embedded work and improving the system's tooling (faster builds, debugger support, etc)
-
Oxide on My Wrist: Hubris on PineTime was the best worst idea
Other folks have mentioned this, but it's important to understand the limitations of Rust with respect to safety. In particular: every stack operation is -- at some level -- an unsafe operation as it operates without a bounds check. This isn't Rust's fault per se; non-segmented architectures don't have an architecturally defined way to know the stack base. As a result, even an entirely safe Rust program can make an illegal access to memory that results in fatal program failure. That, of course, assumes memory protection; if you don't have memory protection (or, like many embedded operating systems, you don't make use of it), stack overflows will plow into adjacent memory.
But wait, it gets worse: stack overflows are often not due to infinite stack consumption (e.g., recursion) but rather simply going deep on an unusual code path. If stack consumption just goes slightly beyond the base of the stack and there is no memory protection, this is corrupt-and-run -- and you are left debugging a problem that looks every bit like a gnarly data race in an unsafe programming language. And this problem becomes especially acute when memory is scarce: you really don't want a tiny embedded system to be dedicating a bunch of its memory to stack space that will never ("never") be used, so you make the stacks as tight as possible -- making stack overflows in fact much more likely.
Indeed, even with the MPU, these problems were acute in the development of Hubris: we originally put the stack at the top of a task's data space, and its data at the bottom -- and we found that tasks that only slightly exceeded their stack (rather than running all of the way through its data and into the protection boundary) were corrupting themselves with difficult-to-debug failures. We flipped the order to assure that every stack overflow hit the protection boundary[0], which required us to be much more intentional about the stack versus data split -- but had the added benefit of allowing us to add debugging support for it.[1]
Stack overflows are still pesky (and still a leading cause of task death!), but without the MPU, each one of these stack overflows would be data corruption -- answering for us viscerally what we "need the MPU for."
[0] https://github.com/oxidecomputer/hubris/commit/d75e832931f67...
[1] https://github.com/oxidecomputer/humility#humility-stackmarg...
-
Writing embedded firmware using Rust
In addition to Cliff's talk/blog -- which are absolutely outstanding -- I would recommend listening to the Twitter Space we did on Hubris and Humility last week.[0] It was a really fun conversation, and it also serves as a bit of a B-side for the talk in that it goes into some of the subtler details that we feel are important, but didn't quite rise to the level of the presentation. And of course, be sure to check out the source itself![1][2]
[0] https://www.youtube.com/watch?v=cypmufnPfLw
[1] https://github.com/oxidecomputer/hubris
[2] https://github.com/oxidecomputer/humility
-
Hubris - OS for embedded computer systems
Humility (the debugger)
What are some alternatives?
avr-hal - embedded-hal abstractions for AVR microcontrollers
tock - A secure embedded operating system for microcontrollers
SAMD21 - Library Helpers for the Atmel SAM21D
esp32-hal - A hardware abstraction layer for the esp32 written in Rust.
linux-embedded-hal - Implementation of the `embedded-hal` traits for Linux devices
hubris - A lightweight, memory-protected, message-passing kernel for deeply embedded systems.
riscv-rust-quickstart - A template for building Rust applications for HiFive1 boards
fathom - 🚧 (Alpha stage software) A declarative data definition language for formally specifying binary data formats. 🚧
uf2-samdx1 - USB Mass Storage bootloader (based on UF2) for SAMD21 and SAMD51
xsv - A fast CSV command line toolkit written in Rust.
OpenSK - OpenSK is an open-source implementation for security keys written in Rust that supports both FIDO U2F and FIDO2 standards.
InfiniTime - Firmware for Pinetime smartwatch written in C++ and based on FreeRTOS