floppy-driver-rs VS tock

Interesting and fun project! I found the MFM encoding page particularly enlightening as it explained why you have to write a full sector at a time on a floppy, even though there's nothing physically constraining you to that so far as I could see on the electromechanical/hardware side of things.

And on that page the "make sure the compiler didn't inject 10,000 lines of boundary checks" bit told me everything I needed to know about what language the project was written in :lol: - here's the link to the driver: https://github.com/SharpCoder/floppy-driver-rs

I'm glad to see the Teensy continuing to get love; I adopted it back when it was at v1 and v2 as it was just such a complete no-brainer of a better choice than the Arduino stack everyone was using back then. I think now there's even an Arduino-on-Teensy software stack, but I've moved to just using STM32 directly and have greatly enjoyed coding for that target in rust.

Head on over to the https://floppy.cafe if you want to learn everything about how these ancient disks work. I spent the last few months bit-banging a device from the 90s and documenting my process. Hopefully this information proves useful to somebody. Aliens, technoarcheologists, retro computing geeks? I'm not sure who my target audience is, but it was a lot of fun to throw this together and I hope you can enjoy my little slice of the 90s!

Head on over to the floppy cafe, if you want to learn more! https://floppy.cafe/ and here's my github repo with the full source for my project: https://github.com/SharpCoder/floppy-driver-rs

Hi! This is Daniel from OxidOS Automotive (stating this for disclaimer purposes).

Yes, our OS is based on TockOS, and our CEO (Alex Radovici) is #7 in the contributors list (https://github.com/tock/tock/graphs/contributors), with other colleagues contributing in the past years.

I'm definitely not the best person to answer this, but honestly it's not bad. Here's an example of a moderately complex peripheral, the cortex-m MPU, and how one rust OS handles it:

https://github.com/tock/tock/blob/3a0527d586702b8ae8cb242391...

Reads and writes turn into volatile reads, so everything works out under the hood. You get the benefits of everything having good names, declared sizes, and proper typing on your register accesses. You can extend that to bit accesses as well.

Rust still has a few areas it isn't competitive in, like your hyper limited or obscure chips (e.g. 8051s, XAP), mature tooling around formal methods, and a certification story for safety critical code. People are working on these latter two issues (e.g. ferrocene) and supposedly very close to public delivery, but you know how slow the industry is to adopt new things even then.

There's Tock (https://www.tockos.org/), which is written in Rust (with sprinkles of assembly).

Yeah, and I like I mentioned in the earlier comment, omitting the frame pointer reduces code size by 10% on RISC-V targets, which is huge when dealing with embedded flash: https://github.com/tock/tock/pull/1660

Tock is an excellent embedded OS written in Rust and has some good industrial support. I think Tock gets a lot of stuff right and I highly recommend some of the talks the developers gave on it.

Unfortunately, it increases the code size by 10%. I was looking into this just last week, and can confirm that it's still a problem on the latest version of Rust nightly: https://github.com/tock/tock/pull/1660

I wish we could have frame pointers, because they would make working in embedded land so much easier and more reliable, but a 10% increase in code size just isn't worth it.

TockOS was the first rust RTOS I found. Coincidentally, it has had support for the esp32c3 for over a year now.