* RMT: avoid dropping/recreating peripheral guards in into_async
regression from https://github.com/esp-rs/esp-hal/pull/4174 (arguably,
before that, the code was just wrong)
* RMT: CHANNEL_INDEX_COUNT -> ChannelIndex::MAX
this seems slighly cleaner, since it more clearly indicates how the two
are related
* RMT: rename RmtTxFuture, RmtRxFuture -> TxFuture, RxFuture
removing the redundant prefix
this isn't breaking API, since both types are private
* RMT: rename SingleShotTxTransaction -> TxTransaction
the previous name was quite unwieldy, and this also better shows the
symmetry between RxTransaction and TxTransaction
* RMT: more consistent code formatting in low-level methods
Note that it's important how the closures for PAC register `modify` and
`write` calls are layed out. Compare
```rust
pub fn clear_tx_interrupts(&self) {
let rmt = crate::peripherals::RMT::regs();
rmt.int_clr().write(|w| {
let ch_idx = self.ch_idx as u8;
w.ch_tx_end(ch_idx).set_bit();
w.ch_tx_err(ch_idx).set_bit();
w.ch_tx_loop(ch_idx).set_bit();
w.ch_tx_thr_event(ch_idx).set_bit()
});
}
```
and
```rust
pub fn clear_tx_interrupts(&self) {
let rmt = crate::peripherals::RMT::regs();
let ch_idx = self.ch_idx as u8;
rmt.int_clr().write(|w| {
w.ch_tx_end(ch_idx).set_bit();
w.ch_tx_err(ch_idx).set_bit();
w.ch_tx_loop(ch_idx).set_bit();
w.ch_tx_thr_event(ch_idx).set_bit()
});
}
```
In the first example, the cast from `self.ch_idx: ChannelIndex` to `u8`
happens in the closure, whereas in the second case, the closure will be
built without the information about the restricted range of
`ChannelIndex` and assume `ch_idx` to be any `u8`. That leads to bounds
check being present (from the PAC register writer), which greatly
increases the closure size, and might push it above the compiler's
threshold for inlining. However, we generally rely quite a bit on
inlining with these methods to generate efficient code here and in
similar methods.
* RMT: merge two register modifications
* RMT: consistently inline(always) low-level methods
In practice, this happened anyway, but better enforce this:
- many of these methods are designed to allow for optimizations after
inling (e.g. removing conditionals due to compile-time known
values)
- if they end up being not inlined, the place_rmt_driver_in_ram feature
doesn't take full effect
* RMT: change method receivers for DynChannelAccess from &self to self
Since it is Copy. We expect all of this to be inlined, so there
shouldn't be a difference in the final code. This should however
simplify the compiler's job a tiny bit and more importantly prevent
pointer indirection and spilling to stack if one of these methods ends
up being not inlined for whatever reason.
* RMT: Ensure that all pub types derive Debug
* RMT: rename set_generate_repeat_interrupt -> set_loopmode
more consistent with the new LoopMode type, and avoids suggesting that
this method might do anything like enabling an interrupt (which it
doesn't)
* RMT: Channel configuration returns channel and pin on failure
instead of permanently consuming them.
This requires quite a bit of refactoring since we must not call
pin.into() before verifying all inputs in order to be able to return the
original pin type on error.
* RMT: ensure that all rx/tx methods return the channel on error
instead of consuming it, which gives no way to recover/recreate the
channel
* RMT: Update HIL tests to account for return type changes
* RMT: With place_rmt_driver_in_ram, also place the interrupt handler in RAM
* RMT: Merge interrupt flag reset methods into clear_?x_interrupts
By adding an EnumSet argument. This nicely mirrors the listen/unlisten
functions, which take the same type of argument. It also helps to avoid
proliferation of a large number of methods when using more interrupts
(such as the loopcount interrupt, which I intend to do in a later PR).
There should be no performance negative, since these methods are always
inlined with compile-time known arguments, such that the compiler can
remove all conditionals.
* RMT: also #[inline(always)] closures for PAC modify and write calls
* RMT: rewrite clear_*x_interrupt in obviously branch-free manner
This make the code slightly more concise and obviously branch-free
(although the compiler seems to make that optimization on it's own, as
well).
This code remains equivalent, because int_clr has only a write-to-clear
bits and the register writer will be initialized to all zeroes before
the closure is invoked.
* RMT: refactor channel configuration
- move configure_tx, configure_rx out of Channel again so that they
don't end up being duplicated via monomorphization of Dm = Blocking and Async
in spite of being virtually identical.
It's probably a bit of an edge case to have both Blocking and Async
channels in one binary (the HIL test do, though), so it's not really
an important optimization, but it still seems cleaner this way.
- both methods take the configuration by reference instead of by value
(it ended up being passed on the stack anyway, so this doesn't really
change the generated code, but allows the caller to re-use the
configuration)
* RMT: changelog and migration guide
* fixup! RMT: With place_rmt_driver_in_ram, also place the interrupt handler in RAM
* RMT: also implement defmt::Format for Debug types
Previously, not all types that implemented Debug also implemented
defmt::Format.
For RmtState, this removes the Debug derive, since it's purely internal
and there's no need for it.
* Partially revert "RMT: also #[inline(always)] closures for PAC modify and write calls"
This partially reverts commit 53da105c85fc771f185c1f30772b77466b50f04c.
This retains the #[inline(always)] for closures realated to `int_ena`
and `int_clr` accesses: These tend to generate relatively large code,
but are expected to optimize substantially due to their compile-time
known arguments. Without explicit inlining, compiler behavior is
somewhat brittly in their case.
* Partially revert "RMT: consistently inline(always) low-level methods"
This partially reverts commit d845e7bc3e3ee249268c0c2e10b16be1e27117f5.
It retains explicit inline hints for methods that strongly rely upon
inlining to optimize either
- the method based on compile-time known arguments
- the caller dispatching based on an Event result to avoid constructing
the event entirely and fully inline bit tests
The relevant methods are also on the larger side, such that inlining
might otherwise not reliably happen, leading to unexpectedly large code
for simple operations.
* RMT: don't rely on inlining to eliminate dead code
stop_tx isn't reliably inlined depending on optimization settings, but
we relied on propagation of the bool return value to eliminate code that
is not relevant on all targets
* RMT: split pin assignment out of configure_*x methods
Such that assigning a pin is an infallible operation, and the pin won't
be permanently consumed if configuration fails.
* RMT: add PinGuard
* RMT: be sure that there's no extraneous pulse when connecting a pin
similar to other drivers
* RMT: validate idle_threshold in RxChannelConfig setter
to remove one reason why ChannelCreator::configure_rx can fail. For now,
this methods remains fallible, but it would eventually be nice to make
it infallible to avoid the inconvenient return type on error.
The only remaining error case is due to invalid memsize, which can be
avoided by refactoring such that extra channel memory can be assigned by
consuming another Channel(Creator)
* RMT: make zero loopcount test more reliable
for some reason, this started to be flaky recently...
* RMT: update changelog & migration guide
* RMT: Revert idle_threshold changes; add apply_config instead
As highlighted in review, validating idle_threshold in the
RxChannelConfig setter is a bit awkward, and counter to what other
drivers do.
The standard solution in esp-hal to deal with possibly invalid configs
seems to be `apply_config`, which the RMT driver was missing, so add
that.
* RMT: update changelog + migration guide
* doc + migration guide fixes
* remove unnecessary trait bound
* Extract magic constant
* Clean up a bit
* Make sure PS is appropriate
* Use FROM_CPU0 on ESP32 to yield
* Add a test case
* Undo esp-hal change
* Fix build on S2
* Fix esp-radio doc example
* Fix build
* Integrate embassy bits, delete eh-embassy
* I2C: Check for errors when everything is done
* Fix multicore examples
* Prevent deleting a task that is currently running on another cpu
* Save some memory on wait queues
* Remove the yield event concept
* Modify pins to let the example run on ESP32
* Clean up
* Make sure a task does not execute instructions after deleting itself
* Use cargo-batch
* Run CI on mac runner
* Rely on MSRV and nightly jobs to lint
* Build docs separately
* Don't copy examples - fix builds on stable
* Run everything by default, set CI env var in ci command
* Run batched commands with RUSTC_BOOTSTRAP enabled
* Force cargo-batch to correctly ignore unstable option
* Test with nightly
* Use a persistent target folder, remove cache
* Don't delete the lp examples
* Restore target dir
* Build with stable again
* Fix rebase fail
* Remove handling tests
* Remove redundant code
* Restore repeated test run option
* Add simpler cargo check
* Introduce check-packages
* Remove stabilized -Zdoctest-xcompile
* Clean up commented code
* Remove more stuff
* Fix uart_uhci test
* No badger for us
* RMT: add HIL test that exercises all channels
to ensure that there are no issues with channel/register indexing; see
also the code comments.
no user-facing changes
* RMT: store ch_idx instead of channel number
`ConstChannelAccess` and `DynChannelAccess` used to store the channel number
and have a `Direction` generic parameter.
However, there are invalid combinations of `Direction` and the channel
number on some chips (e.g. on esp32c3, there is no channel with (Tx, 2),
because channel 2 and 3 only support Rx).
In constrast, the tuple `(Dir, ch_idx)` also uniquely identifies a
channel and its configuration, and any combination of it is valid as long as the
channel index is in bounds.
This makes it somewhat easier to work with; in particular, it will allow
removing bounds checks on ch_idx in a later commit by replacing
`ch_idx: u8` with an enum type.
This also refactors the `async_interrupt_handler` accordingly.
This is user-visible via the `ConstChannelAccess` type, however a later
commit in this PR will remove that entirely.
* RMT: elide bounds checks via ChannelIndex enum
If the channel index is not known at compile time in a given function,
the compiler will insert bounds checks on
- indexing the STATE global
- register access via the PAC
The compiler seems to be able to deduplicate them since low-level
functions are mostly inlined, but each function will retain at least one
bounds check.
This change helps the compiler to elide these checks by using a custom
type for channel indices that can only take values for which a channel
exists.
Specifically, this uses an enum to serve as a refinement of u8 to help
the compiler restrict value ranges. Due to inlining, this restricted
value range is propagated by the compiler until the potential bounds checks,
even if there's intermediate cast to u8,
cf. https://github.com/rust-lang/rust/issues/109958
There are no user-facing changes. (`ChannelIndex` is `pub` because it
appears in a `[doc(hidden)]` trait member.)
* RMT: always type-erase channels
- remove the `Raw` generic on `Channel`: This simplifies the types,
should have negligible performance impact (helped by elided bounds
checks via the recently introduced `ChannelIndex` enum), and greatly
reduce code size if several channels are used (by avoiding
monomorphization per channel)
- this also changed the arguments to configure_(tx,rx)_channel such that
they don't contain generics, again avoiding code bloat due to
monomorphization
This requires user code to change type annotations for channels and
transactions, and remove any manual type erasure (via `channel.degrade()`).
* RMT: impl blocking tx/rx methods directly on Channel
There's now only a single type that should implement these methods due
to erasing the channel index const generic, so the indirection via a
trait serves no purpose. Implementing methods directly on the channel
probably also helps to make the docs more discoverable.
This requires user code to remove the `TxChannel` and `RxChannel`
imports.
* RMT: impl async tx/rx methods directly on Channel
There's now only a single type that should implement these methods due
to erasing the channel index const generic, so the indirection via a
trait serves no purpose. Implementing methods directly on the channel
probably also helps to make the docs more discoverable.
This requires user code to remove the `TxChannelAsync` and `RxChannelAsync`
imports.
* RMT: impl *ChannelInternal traits only on DynChannelAccess
rather than as a blanket impl for RawChannelAccess, which includes
ConstChannelAccess: We don't intend to perform any accesses via
ConstChannelAccess anymore, so enforce that.
We could also get rid of the traits entirely and directly impl their
methods for DynChannelAccess, but it seems somewhat useful to keep them
around to guarantee that the interfaces in both chip_specific modules
are consistent.
There are no user-facing changes here.
* RMT: remove `pub` on various internal types
that used to be visible somewhere in the API's trait bounds, but are not
part of the API themselves
This is user-visible, but user code should not have used these types in
the first place.
* RMT: rm ConstChannelAccess, RawChannelAccess, private DynChannelAccess
now that Channel has no `Raw: RawChannelAccess` type parameter:
- we don't need low-level channel methods to be implemented for
ConstChannelAccess, since all accesses go through DynChannelAccess.
Thus, remove the *ChannelInternal traits and implement their methods directly
on DynChannelAccess
- none of these types need to be public (although one might consider
actually making them public with an unsafe constructor to provide an
unsafe low-level interface to the hardware)
This is user-visible (imports need to be removed; they're not used
anymore since the previous commit that always type-erased the `Raw`
parameter of `Channel`)
* RMT: changelog and migration guide for type-erased channels
* RMT: (review) remove stray comment
* RMT: (review) remove is_tx() from Direction trait
we can simply use the const item directly
* Move all `embassy` examples to `async` and convert to individual projects
* Move all peripheral examples to `peripheral` and convert to individual projects
* Move all interrupt examples to `interrupt` and convert to individual projects
* Move all `ble` examples to `ble` and convert to individual projects
* Move all `esp-now` examples to `esp-now` and convert to individual projects
* Move all Wi-Fi examples to `wifi` and convert to individual projects
* Move all `ieee802154` examples to `ieee802154` and convert to individual projects
* Move all OTA examples to `ota` and convert to individual projects
* Remove files which are no longer required
* Update `xtask` to handle new examples project layout
* Update `examples/README.md`
* Don't hide TOML parsing error in `is_published`
* Update `fmt-packages` subcommand to handle new examples project layout
