* Move macros to new crate
* Generate a single file
* Pre-generate esp-metadata-generated
* Move saving code to xtask
* Format with both rustfmt and prettyplease
* Fix doc build
* Unhide macros
* Fix doc string
* Update semver-check baseline
* Move ROM function definitions to esp-hal-rom crate
* Patch ESP32 ROM-functions, use it in esp-storage
* Allow placing additional code in IRAM
* esp-storage depends on esp-hal-rom
* Move ROM function wrappers from esp-hal to esp-hal-rom
* Make bootloader-support crate use CRC ROM function
* Minor polishing
* changelogs
* Make CI green
* Define (some) spiflash ROM functions in esp-hal-rom
* Lint
* Avoid duplicate definition of `__assert_func`
* Rename to `esp-rom-sys`
* Mention versioning this crate in the README
* Fixes
* Check self-version
* Docs
* Clippy
* Check if version bump is allowed
* Unconditionally place spiflash ROM function patches (if present) in rwtext
* Cleanup
* Change how unacceptable version bump requests are detected
* Initial version 0.1.0
* Docs
* Use correct version
* Force esp-rom-sys bumps to patch
* Fix
* RMT: Move some methods from (Tx|Rx)ChannelInternal to ChannelInternal
Adds a new `ChannelInternal` trait implemented on `Channel`s, which
bundles some methods that conceptually make sense for both rx and tx
channels (whether the implementation is exactly the same is
chip-specific).
This avoids a small amount of code duplication.
* RMT: Define input/output signals via a const array
Allowing a default implementation of the getter functions in the ChannelInternal
trait, and more importantly, paving the way for type-erased channels
(where it will become necessary to map Channel number to signal at runtime).
The array is indexed by ch_index, i.e. the index of the channel among
channels of the same type (for devices with separate rx/tx channels).
* RMT: move some `Sized` bounds from methods to trait
To avoid repetition. There's no downside, since the trait is only
implemented for a single type anyway, which is Sized.
These traits are user-visible, but since they can't be implemented by users,
and this only makes the bounds stricter, it should require not changes
to user code.
* RMT: Use composition with ConstChannelAccess, reduces macro usage
instead of an extension trait implemened via the impl_*_channel macros.
This reduces macro usage, making the code easier to reason about, and it also
paves the way for type-erased channels by adding a second implementation
of RawChannelAccess.
This touches many lines, but is a fairly mechanical change that should
be easier to review by ignoring whitespace changes.
Previously, channel architecture was as follows:
- `Channel` is parameterized by a const generic `CHANNEL: u8` number
- low-level hardware operations are implemented via the
*ChannelInternal traits directly on `Channel`. This is done via the
`impl_*x_channel` macros to account for the different channel
capabilities (rx/tx only or rx+tx)
This PR changes this to:
- `Channel` contains an `Raw: RawChannelAccess<Dir=Rx|Tx>` where `Rx`
and `Tx` are ZSTs used as markers for a channel configured for a given
direction.
- low-level operations are implemented on the `Raw` type, depending on
a bound on RawChannelAccess::Dir
- the `Raw` types can only be constructed safely from the
`ChannelCreator`, which ensures that only valid combinations of channel
number and `Dir=Rx|Tx` can exist.
- currently, the only implementation of `RawChannelAccess` is
`ConstChannelAccess`, which has a `CHANNEL: u8` const generic
parameter, just as `Channel` did before. Thus, the compiler should be
able to inline and const-propagate code just as before.
These new types are user-visible. Thus, if code directly names `Channel`
types, it needs to be adapted. If it just uses a method chain such as
`rmt.channelX.configure(...).transmit(...)`, no changes should be
required.
* RMT: rm (Rx|Tx)ChannelCreatorAsync, use mode generic on (Rx|Tx)ChannelCreator
this de-duplicates some code,
and may be useful to implement user code (e.g. setup functions) that is
independent of DriverMode
* RMT: Rewrite pending_interrupt_for_channel using indexed PAC accessors
This deduplicates some code. I've also changed the return type
(usize -> u8) for better consistency, since channel indices are generally
typed as u8.
* RMT: add DynChannelAccess as basis for type-erased channels
Channels can now be `degrade`d to their type-erased variants.
* RMT: Move around some code
The channel definition used to be somewhere in the middle of channel
implementation. There's no change to the code other than its location.
* RMT: slightly more readable subsclicing
* RMT: Move some chip-specific code to a cfg_if! switch
There's no reason for these to reside in separate modules, and this
restructuring meshes well with moving the Rmt definition to a macro as
well, which will be done next.
* RMT: Declare Rmt struct via macro to avoid repetition
Reduces boilerplate at the cost of a somewhat complex macro.
* RMT: Move RmtState
Which was previously in the middle of channel implementation, but
conceptually is more global to the module, thus more natural define
earlier.
* RMT: explicity mark a few private functions in submodule as pub(super)
* RMT: use DynChannelAccess::conjure to simplify async_interrupt_handler
If the compiler decides to unroll the loops, the resulting code should
be essentially the same. Otherwise, it should be more compact. In any
case, from a developer point of view, this is much more concise and
removes one chip-specific case.
* RMT: Use type-erased channels for some HIL tests
* RMT: don't reset clock divider in start_tx
This seems to fix flaky loopback tests where tx/rx pulse code length
differs by 1.
This matches IDF, which also doesn't reset channels on each transmit
operation, but only once on channel creation, and when a sync_manager is
used (which the Rust driver doesn't support, and which would also need
to be handled differently anyway).
* RMT: implement degrade() even if the channel is already type-erased
This makes wrapping channels in custom structs slightly more convenient
since it allows taking any channel and type-erasing it in that structs
constructor.
* RMT: rename (Rx|Tx)ChannelCreator methods to avoid trait disambiguation problems
For devices with channels that support both Rx and Tx, Rust cannot
disambiguate the trait at the call site (because it doesn't look at the
argument types to do so).
Renaming the methods avoids that. The alternative is to use
fully-qualified names to call the trait methods (i.e. left-side
turbofish), or to import the traits only in a limited scope. Both are
much more verbose than the _rx/_tx suffixes to method names.
* RMT: add basic async HIL test
* RMT: remove overcomplicated WithMode trait from tests
according to a suggestion by @bugadani
---------
Co-authored-by: Scott Mabin <scott@mabez.dev>
* Reduce use of iter::chain
* Cache all symbols
* Trim xtensa-lx-rt deps
* Remove unused dep
* Replace chrono with jiff
* Yeet minijinja
* Save a bit on toml_edit
* Disable some default features
* Disable regex log filters
* Reduce xtensa-lx-rt build script
* Remove unnecessary dependencies
* Remove darling
* Update embedded-test
* lol
* Clean up
* Only validate loaded config once
* fmt
* Changelog
* Fix esp-bootloader-esp-idf
* Use OTA enabled partition table for examples
* Add simple OTA example
* CHANGELOG.md
* Create a dummy `ota_image` in CI
* mkdir
* Remove unnecessary details from CHANGELOG
* Make non-Window's users life easier
* Test ROM function in esp-bootloader-esp-idf
* Fix
* Add failing test
* Reset FSM when cancelling a transaction
* Refactor clear_bus_blocking to avoid duplicating the logic
* Extract timeout from ClearBusFuture
* Clear bus immediately when cancelling an async transfer
* Add HW and SW flow control option
* Fmt + warnings
* changelog entry
wrong unstable macro
* address reviews
* get away with using 1 pin only
* unnecessary function call
* Address reviews + use "byte" instead of misleading "character" (at_cmd)
* RMT: simplify/avoid a few cfg attributes
* RMT: factor address calculation into new function channel_ram_start()
* RMT: don't repeatedly read *ChannelInternal::memsize()
Moving this into separate variable greatly increases readability of the
code. It also avoids unnecessary repeated volatile reads of the
corresponding register.
* RMT: rework SingleShotTxTransaction offset calculation
This is not a big simplification yet, but will help will help with
simplifying the somewhat obscure `ram_index` calculation.
* RMT: rework SingleShotTxTransaction offset calculation, part 2
This removes the somewhat hard to parse
let ram_index = (((self.index - memsize) / (memsize / 2)) % 2) * (memsize / 2);
calculation, by resorting to the ping-pong method also used by the idf
code.
Importantly, even with the previous code, ram_index cannot in fact assume any
possible in-range value in channel RAM, but only either 0 or memsize / 2
(except at the end of a transaction, when there's no data left).
Thus we can update it via
ram_index = memsize / 2 - ram_index
such that will alternate ("ping-pong") between 0 and memsize / 2.
* RMT: error out on config.memsize == 0
* RMT: fix bogus cfg attributes
This is inside of a #[cfg(any(esp32, esp32s2))] block, so esp32s3 can
never happen: The result of nested cfg attributes was still correct, but
writing it like this doesn't make any sense.
* RMT: remove unnecessary integer literal type annotation
* RMT: remove spurious code from clear_interrupts()
- update() is known to be a no-op here
- For other chips, resetting pointers and setting mem_owner is not done
in clear_interrupts(), but in start_rx. clear_interrupts() is only used in
situations where either the channel was unused before (i.e. should be
stopped), or we explicitly called Self::stop() before. Thus, match
other chips here.
* RMT: clear mem_owner in start_tx
While I haven't seen this happen, it appears to be possible that one of
the subsequent channels (or even the current channel) was used for RX before.
Thus, ensure that mem_owner is set correctly for TX.
* RMT: small refactoring
There should be no functional change, but this should make it even more
obvious that the return value is exactly the number of codes written.
* RMT: in SingleShotTxTransaction, improve error handling
I haven't seen any error here in practise, but it seems that this could
have locked up in the `while !is_threshold_set()` loop before in case of
an error or early stop code in the data.
* RMT: avoid one register access
* RMT: update HIL tests to use wrapping and extended RAM
* RMT: address review regarding data-writing loops
Make the code less startling by performing writes to the hardware in a
more imperative style via the for-loop; slightly refactor slice
splitting.
* RMT: Update changelog
* Group optional dependencies
* Separate version from crate name
* Restore defmt-log mutual exclusivity
* Gate ufmt
* Remove usb-device
* Feature-gate unsable dependencies behind unstable
* S2: assume single core for portable-atomic
* Clean up feature flag docs
* Sack debug
* Fix clippy
* Update examples
* Fix usb-otg feature
* Fix fmt
* Add version to log dep
* Also mark bluetooth private
* Correct changelog/MG
* Clean up esp-hal-embassy
* Clean up ieee802154
* Clean up esp-println
* Move the timestamp function up
* Move info from readme to feature docs
* Clean up esp-storage
* Clean up esp-wifi
* Fix examples
* Add a note for the private features
* Add test case
* Split into files
* Do not clear interrupt status bits in handler
* Document changes
* Refactor gpio tests to test the default interrupt handler by default
* Fix typo
* Extract mk_static
* Write a bit about interrupt handling
* Various fixes
* Test that the future doesn't resolve for a preceding interrupt
* Add multi-core test
* ESP32: handle GPIO interrupt on the listening core
* Fix multi-core edge case
* WIP
* Clean up init_gpio
* Expand docs a bit
* Remove Input/OutputConnection
* Not everything has PCNT and it's not important for the example
* Remove Frozen, enable input when creating the signal
* Hide fields, add getters
* Update MG
* Add force GPIO matrix fns
* Fix formatting
* Mention latency in the docs
* Rename number to gpio_number
* Deduplicate pin setup code
* Reword associated peripheral
* Rename with_inverted_input/output
* Remove link to doc-hidden OutputSignal
* Fix link syntax
* Make sure to enable relevant interrupts
* Fix more
* Make `current_runlevel` public
* Check that interrupts are enabled when initializing
* Try to be more honest in `is_in_isr`
* Adjust log levels
* Really fix ESP32 COEX
* Improve COEX example
* fmt
* CHANGELOG
* CHANGELOG
* Clarify on `esp_bt_controller_config_t`
* Take INTENABLE into account
* Test esp-wifi init fails
* Simplify test code
* Clarify comment
* fmt
* Rename
* Adapt the test
* Revert unrelated changes (esp_bt_controller_config_t)
* Align Xtensa (current_runlevel)
* Additional test
* Change test
