defmt
probe-run
Our great sponsors
defmt | probe-run | |
---|---|---|
17 | 6 | |
713 | 646 | |
5.0% | - | |
8.8 | 0.0 | |
7 days ago | 3 months ago | |
Rust | Rust | |
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.
defmt
-
I built a column staggered keyboard with firmware written in Rust!
As someone who had only done embedded programming in the Arduino IDE, utilizing the defmt crate for logging with OpenOCD and GDB was an amazing experience. Although I still had no idea on to implement USB-HID for actually sending the key reports, until I discovered the usbd-human-interface-device crate and everything became so much easier. I just needed to create an iterator over Keyboard events and the crate would handle the rest as an added benefit the crate also supports multiple devices, so adding mouse support was as easy as creating a separate iterator over WheelMouseReport.
-
Testing a no_std crate with QEMU and defmt-test?
I think I want to use the QEMU emulator (as suggested in the Embedded Rust Book) and tests created with defmt-test. But I can't figure out how to get them to work together.
-
Are there any `no_std` logging or printing libraries (for Wasm targets, or even embedded devices)
On embeded defmt is often used https://github.com/knurling-rs/defmt
-
Debugging and profiling embedded applications.
defmt is a great framework for general logging.
- Print From a Multi-Platform no_std Embedded Library
-
Native Reflection in Rust
Great writeup! The defmt logging crate uses a linker script to extract debug symbols so that you get nicely formatted stack traces on embedded systems. It works on linux, macos and windows. I wonder if the same technique can be applied to this project. It needs a runner though so may not be the right approach.
https://github.com/knurling-rs/defmt
- Smallest logging implementation?
-
From arduino to rust via avr-hal
Just played with embedded stuff today. defmt can be used for logging instead of println since there's not really a stdout when running on bare metal.
-
Are costly debuggers from vendors necessary?
yYeah. For example, instead of printf("Variable X = %d, y=%f", x, y), where the micro then formats the string and pushes it out a serial port, blocking until its sent, I can write LOG("Variable X = %d, Y=%f, x, y), and what actually happens is a unique pointer to the string, and a tagged raw int and float get pushed onto a buffer, which takes about 15 instructions and takes up 16 bytes in the buffer. The buffer is then asynchronously sent out over the serial port, and the PC knows how to map the string ID to the actual string (this can by dynamically fetched from the micro or stored like debug info if there's not enough flash for the strings), and applies the formatting. There's an added bonus that it's super easy to take any variable which is logged and plot it live over time. There's also stuff like if the system crashes and the watchdog resets it, the buffer can be read out from memory to catch anything which wasn't sent out yet. It's a bit more of a complex system to set up but it really makes printf feel like the stone age when you get to using it. For an example of a similar system in rust, https://github.com/knurling-rs/defmt is implementing the same ideas (I don't know of any publicly available equivalent in C or C++, but you can implement it the same, though C++ is easier and it helps to know your way around a linker script to make something properly ergonomic).
-
Creating formatted strings with no_std on embedded
If the build constraints are amenable for your project, you might also enjoy knurling-rs' defmt logging framework.
probe-run
-
blink sketch for stm32f411?
Install probe-run (this is optional, but makes flashing easier)
-
This Year in Embedded Rust: 2021 Edition
This made me want to try getting some of these tools running. Probe run looked so handy, but it just doesn't work for me.
-
Any frameworks in Rust for developing on SiFive / ST / NXP boards?
For flashing, Check out Kurling's Probe-run, and related tools like defmt, as well as their app template.
- Writing embedded firmware using Rust
-
Rust community should go all in on supporting Raspberry Pi RP2040 Microcontrollers
You don't need a USB file system for a convenient dev experience. In fact you can achieve an even more integrated experience with Rust today, on essentially any Cortex-M microcontroller if you set up probe-run. It makes cargo run flash and run the code on your microcontroller and can even be invoked with rust-analyzer's run button or an IDE command.
-
How can I use probe-run and still debug application
I've been looking for a way to debug my application like I would from GDB (ie: set breakpoints, inspect registers, step, etc.) but I haven't found any documentation on how to accomplish this with probe-run.
What are some alternatives?
cargo-embed - a cargo extension for working with microcontrollers
trice - 🟢 super fast 🚀 and tiny 🐥 embedded device 𝘾 printf-like trace ✍ code, works also inside ⚡ interrupts ⚡ and real-time PC 💻 logging (trace ID visualization 👀)
stm32-rs - Embedded Rust device crates for STM32 microcontrollers
flip-link - Adds zero-cost stack overflow protection to your embedded programs
stm32f7xx-hal - A Rust embedded-hal HAL for all MCUs in the STM32 F7 family
nanoprintf - The smallest public printf implementation for its feature set.
svd2nim - Convert CMSIS ARM SVD files to nim register memory mappings
itm - ARMv7-M ITM packet protocol decoder library crate and CLI tool.
stm32-hal - This library provides access to STM32 peripherals in Rust.
egboard - Ergonomic Keyboard with custom firmware in Rust.
rust-raspberrypi-OS-tutorials - :books: Learn to write an embedded OS in Rust :crab: