* Implements methods to allow presetting the pin state & direction
Enabling those methods allows to save a few valuable instructions
in the PIO's memory.
* Use IntoIterator rather than Iterator.
* Use proper types instead of bool to be more idiomatic.
* Change set_pindirs_with_mask to a more idiomatic rust approach.
* Update pio_proc_blink with new set_pindirs_with_iter
* Force reset on startup to guaranty consistency with type-states.
* Expose more accessors to allow more advanced driver to be implemented.
* Add the ability to restart the state machine from its wrap point.
This method also clears the ISR/OSR to give the state machine a clean
restart.
* Add a comment about the impact of autopull on OUT & PULL instructions
* Fix broken internal doc reference & add an important note on Tx<SM>::has_stalled
* rename block methods to register_block.
This change is made to avoid confusion with "block" as a verb.
* Implements methods to allow presetting the pin state & direction
Enabling those methods allows to save a few valuable instructions
in the PIO's memory.
* Update pio_proc_blink with new set_pindirs
Without the --locked option, cargo currently tries to compile it using
clap v3.0.0-beta.5, which fails:
```
[...]
Compiling clap v3.0.0-beta.5
Compiling elf2uf2-rs v1.3.5
error[E0432]: unresolved import `clap::Clap`
-->
/home/jan/.cargo/registry/src/github.com-1ecc6299db9ec823/elf2uf2-rs-1.3.5/src/main.rs:3:5
|
3 | use clap::Clap;
| ^^^^^^^^^^ no `Clap` in the root
[...]
```
With --locked, it uses clap v3.0.0-beta.4, which works.
Eventually, the read and write FIFOs need to be split into separate
objects for DMA. To be able to safely rejoin them only when they belong to
the same state machine, the state machine index needs to be encoded into
the type.
Some operations must only be performed in a specific state. For example,
pin directions must not be changed while the state machine is running, as
the operation modifies PINCTRL. The new API makes wrong usage a lot harder.
Also, the code now supports uninitializing state machines to free
instruction space or to select a different function.
Multiple state machines may want to execute the same program (e.g., two
state machines are used to implement two I2C buses), in which code sharing
saves space.
One PIO block often implements multiple functions that are used in
different parts of the codebase. Previously, that would be impossible, as
PIO contained all StateMachine instances.
Now, StateMachine instances use atomic operations whenever accessing shared
registers, so they can be used concurrently.
