safely

@@alexdubois6585 and it cannot race anymore!

Only direct short circuits and then also with a clear path e.g. between the 5V section and sensitive 3V logic and with a correspondingly high current flow can seriously endanger your board/parts. This basically happens when measuring or when trying around on the breadboard. In the water this is very unlikely. Of course, there are sensitive components where water damage in and of itself affects the function, but a little patience will probably suffice for you. It's best to use a few dry cloths and not even a (hot-air) hair dryer or the oven ... because you can damage more with them than with water. Have fun bathing and crafting! :)

🤣🤣🤣

😂😂😂

Yup. You can only have one mutable reference OR multiple read-only references.

erratum to your comment, errata is plural already

@@r.pizzamonkey7379 In rust speech, & implements Copy and &mut doesn't

@@rumplstiltztinkerstein sort of but not quite. I'm pretty sure it's a different system which supercedes traits.

@@r.pizzamonkey7379 maybe they're just special pointers

More to come!

Check out videos on my channel. I have 6 videos on Rust embedded and more to come.

I second this

Specially for knowledge hoarders like ourselves.

@@selfscience yesir 🤙🤙🤙

to make it more clear, other type of output is open drain in which you need to add pullup resistor to keep it high

Wanted to say the same. Thanks!

Good tip!

What's wrong with proper commenting? Do you have to add pointless jump commands around your low-level instructions, complicate the things happening in stack, etc?

Glad it was helpful!

No problem!

Thank you for the reminder! Done.

Thanks for the sub!

Gotta setup those clocks :) DMA usage is currently same as C or C++: write to registers and make sure no races etc. can happen. Some HAL implementations make this ridiculously easy, see e.g. h7 hal. In the future, some efforts such as embedded-dma and bbqueue might standardise this, but it's hard.

Yes, it's very verbose. The Rust style is to encode as much as possible into the type, so the compiler can check it for you. But that means you need ownership of a lot of pieces of data, and that means a lot of source code (which may boil down to very little code at runtime). For example, you'd need a separate variable for each GPIO pin you want to use, and you have to pass those variables to any function that needs to access that pin. You can hide some of that complexity by putting that initialization and extraction of variables into your own library function. The downside there is that your function has to return a lot of pieces of data. It would certainly be possible to create a much simpler API (similar to Arduino, for example) that is in some sense less safe. For example, if you pass pin numbers as integers, you end up having to do runtime sanity checking of that number, and it's easier to accidentally type the wrong number or have two routines manipulating the same pin when they should be manipulating different pins.

In C or C++ (or any language, really) you generally have to do all this stuff to setup the hardware. Some environments like Arduino hide much more if it. This usually means you have less ability to customize, but you have less boilerplate in your code, too. All the setup code is still being called for you, though. The level of detail exposed is a trade off of simplicity vs. control. I think what we've seen here looks like a pretty reasonable level of detail, at least in my opinion.

Is there a similar thing for --release ?

@@soumen_pradhan cargo b --release and cargo r --release

Great to hear!

The HAL itself has unsafe parts that it does for you. From what I can tell reading the HAL source though, they are beyond what a c dev would consider "good enough" about how they manage their memory though.

Same HAL but it has a different flash chip so you need to change the boot2 line. The bit that says W25Q80 is actually telling you the part number of the flash chip that particular boot2 supports. Or use the Nano Connect 2040 BSP which sets this up for you.

I had build issues on Linux (Ubuntu) and after using those commands, my code worked. Thanks for your help.

You really *do* need a 2nd stage bootloader for RP2040 if you want to access flash or want a program larger than 256 bytes - regardless of the language you use. This is one of the trade-offs of using external SPI flash for program storage on a microcontroller, and is not unique to RP2040 - other flashless micros have similar requirements. We just don't hide them from you in an SDK that only works for one board.

Try typing "cargo docs --book" into your terminal. That's the official rust book and it's quite well written.

There is both a gcc and llvm implementation now. They are almost always around the same +/- a few precent.

Realistically, a rust binary compiled with default settings will be rather large. But by setting a few options in Cargo.toml you can get it much smaller. Also by avoiding formatting code and using something like defmt you can get it even much lower.

Check out videos on my channel. I have 6 videos on Rust embedded and more to come.

I plan on doing FPGA content in the future but I still have a lot of work to do, purchases to make. Stay tuned!

@@LowLevelLearning thanks a lot

Hi, I got the same problem, just tell the build system to include additional dependencies to support critical sections: cargo build --release --example blinky --features="critical-section-impl" you'll probaly need to install additional components i.e.: rustup target add thumbv6m-none-eabi and cargo install elf2uf2-rs

@@bartoszk.6451 YOU ARE AWESOME!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! That worked. Thank you sooooooo much!!!!!!!!!!!!!!

Basically, you need all this code to initialize your board properly (the joy of embedded code). On the other hand since most of this doesn't change and the "real" code specific to your purpose here is only a few line, there are templates that already have all the boilerplate and you can just reuse when needed.

You certainly don't need both type annotations. In fact, you probably don't need either of them, since that constant gets passed to a function, and Rust should be able to infer the correct type based on the types of the function's arguments. As for what's good practice, I don't have enough Rust experience to help with that. Coming from a C background, there's a part of me that likes seeing an explicit type where the variable is declared, because my poor human brain does a worse job of type inference than the compiler does. I really like the rust_analyzer plug in for VS Code. It will show the type information it has inferred, displayed inline with the source. Using that plug in, I'm much more comfortable leaving out type declarations and letting the compiler infer them.

@@markday3145 Yeah I'am fully with you on that, it's a great tool to help you remember or even learn what types are there to use in Rust! Unfortunately it can become very long and explicit with more complicated types and make your code less readable than it would need to. Anyway thanks for sharing your experience and stand point coming from a C background, appreciate it :)

@@markday3145 As far as I know constants in rust have to be always annotated, though the postfix annotation is definitely not needed.

The first type is required because it's a const. The suffix is redundant and can be removed.