stm32f4xx-hal
humility
stm32f4xx-hal | humility | |
---|---|---|
11 | 6 | |
506 | 514 | |
2.8% | 1.4% | |
8.4 | 8.3 | |
7 days ago | 5 days ago | |
Rust | Rust | |
BSD Zero Clause License | 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.
stm32f4xx-hal
- Rust newcomers are 70x less likely to create vulnerabilities than C++ newcomers [pdf]
-
1.5st project: Rusty Stopwatch
I would personally use the abstractions provided by the stm32f4xx-hal crate more. See https://github.com/stm32-rs/stm32f4xx-hal/tree/master/examples/ for examples.
-
[Media] To get familiar with embedded Rust, I wrote a Tetris clone! It's running on an STM32. I repurposed a board I designed for another project
For this project, the audio ended up being the biggest challenge. I spent a few days on-and-off working on it because it would stop working as I modified the PWM frequency. I was eventually able to track it down to a bug in the HAL and opened a PR accordingly: https://github.com/stm32-rs/stm32f4xx-hal/pull/555
-
Hey Rustaceans! Got a question? Ask here! (30/2022)!
For my specific issue, I'm using the stm32f4xx-hal library to control a bunch of RGB leds, each with a pwm output. Since I have to get pins and timers where I can find them, each component of the led is made by something like
-
STM32F4 Embedded Rust at the HAL: PWM Buzzer
At the time of writing this post, I noticed that if going with option 1 stated earlier that returns a PWMChannel can prove to be quite problematic. In navigating the documentation, the PWMChannel implementations do not include methods that allow to get and set the period of the peripheral. There is an issue that I submitted here for that.
-
blink sketch for stm32f411?
Maybe check out this example from the stm324xx-hal repo?
- How to setup CLion for programming AVR microcontrollers?
-
can u reccommend a microcontroller for my protorypes needs?
Here is an example for stm32f407 (trivial to change to stm32f411) that gets random numbers from the rng peripheral and displays them on an ssd1306 display: https://github.com/stm32-rs/stm32f4xx-hal/blob/master/examples/rng-display.rs although this uses Rust, which you may or may not like. Arduino will have you covered as well, obviously.
- Huge binary size when using usbd_device SerialPort on stm32
-
Learn a new language after C. Rust or C++?
A major benefit of Rust in embedded is how easy it is to use libraries. This example implements USB serial communication on an STM32 in under 80 lines. You add some libs and if it compiles it works.
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?
stm32-rs - Embedded Rust device crates for STM32 microcontrollers
tock - A secure embedded operating system for microcontrollers
meta-raspberrypi - Yocto/OE BSP layer for the Raspberry Pi boards
esp32-hal - A hardware abstraction layer for the esp32 written in Rust.
embassy - Modern embedded framework, using Rust and async.
hubris - A lightweight, memory-protected, message-passing kernel for deeply embedded systems.
cargo-binutils - Cargo subcommands to invoke the LLVM tools shipped with the Rust toolchain
fathom - 🚧 (Alpha stage software) A declarative data definition language for formally specifying binary data formats. 🚧
bare-metal-stopwatch-rust - Bare-metal interrupt-driven stopwatch on STM32F439ZI, written in Rust
xsv - A fast CSV command line toolkit written in Rust.
InfiniTime - Firmware for Pinetime smartwatch written in C++ and based on FreeRTOS