Resolve #3182 extend RMT memory

[enelson1001]

Thank you for your contribution!

We appreciate the time and effort you've put into this pull request.
To help us review it efficiently, please ensure you've gone through the following checklist:

Submission Checklist 📝

• I have updated existing examples or added new ones (if applicable).
• I have used cargo xtask fmt-packages command to ensure that all changed code is formatted correctly.
• My changes were added to the CHANGELOG.md in the proper section.
• I have added necessary changes to user code to the Migration Guide.
• My changes are in accordance to the esp-rs developer guidelines

Extra:

• I have read the CONTRIBUTING.md guide and followed its instructions.

Pull Request Details 📖

Add the ability to extend RMT memory on a RMT channel

Description

Added changes to rmt.rs to allow the user to use extended RMT memory on a channel. This allows a user to have more pulse codes than the default of 64, 48 pulse codes depending upon the device used.
My uses case was to receive pulse codes from a weather station sensor that exceeded one RMT memory block of 64 (for ESP32).

Testing

I tested on an ESP32 and a ESP32S3 using the examples/embassy_rmt_rx. I also wrote my own example that would transmit and receive a 207 pulsecodes on an ESP32. I sent 207 pulsecodes from the ESP32 to a ESP32S3. The 207 pulsecodes contained 3 duplicate messages and I was able to receive 2 of the 3 message on the ESP32S3 since the ESP32S# max receive memory is 192.

[bugadani]

We'll need some way to prevent multiple channels accidentally using the same memory blocks. I didn't see anything related in this PR, did I miss something?

[enelson1001]

We'll need some way to prevent multiple channels accidentally using the same memory blocks. I didn't see anything related in this PR, did I miss something?

I would think we would have to add a variable to maybe new_internal that has information if a block of memory is used or available. Does this sound like a good approach?

Never mind I think I have an idea how to solve.

[enelson1001]

I would like some feedback to the approach that I was thinking of using. The implementation would be the same in the configure_tx_channel. Not sure how to handle ESP32S3 for receive since it uses ch_index.

fn configure_rx_channel<'d, P: PeripheralInput, T: RxChannelInternal>(
    pin: impl Peripheral<P = P> + 'd,
    config: RxChannelConfig,
) -> Result<T, Error> {
    cfg_if::cfg_if! {
        if #[cfg(any(esp32, esp32s2))] {
            let threshold = 0b111_1111_1111_1111;
        } else {
            let threshold = 0b11_1111_1111_1111;
        }
    }

    if config.idle_threshold > threshold {
        return Err(Error::InvalidArgument);
    }

    let config_memsize = config.memsize;

    if config_memsize > NUM_CHANNELS as u8 {
        return Err(Error::InvalidMemsize);
    }

    if config_memsize > NUM_CHANNELS as u8 - T::CHANNEL {
        return Err(Error::InvalidMemsize);
    }

    // If config_memsize is greather than 1 then the user wants to use extended
    // memory for this channel
    if config_memsize > 1 {
        // If a channel's memory block is used by another channel then its memory size
        // will be set to 0. If a channel's memory block is available then its
        // memory size will be 1

        // Check to see if any the memory blocks requested in config_memsize are taken
        // (ie memsize != 1), if so throw an error
        let rmt = crate::peripherals::RMT::regs();
        for i in T::CHANNEL..T::CHANNEL + config_memsize {
            if rmt.chconf0(i as usize).read().mem_size().bits() != 1 {
                info!("RMT memory block is taken");
                return Err(Error::InvalidMemsize);
            }
        }

        // If the memory blocks are available then set the extended memory blocks size
        // to 0 to indicate they are taken. Setting the memsize for this channel will
        // be set further down in the code
        for i in T::CHANNEL + 1..T::CHANNEL + config_memsize {
            rmt.chconf0(i as usize)
                .modify(|_, w| unsafe { w.mem_size().bits(0) });
        }
    }

    crate::into_mapped_ref!(pin);
    pin.init_input(crate::gpio::Pull::None);
    T::input_signal().connect_to(pin);

    T::set_divider(config.clk_divider);
    T::set_carrier(
        config.carrier_modulation,
        config.carrier_high,
        config.carrier_low,
        config.carrier_level,
    );
    T::set_filter_threshold(config.filter_threshold);
    T::set_idle_threshold(config.idle_threshold);
    T::set_memsize(config.memsize);

    Ok(T::new())
}

[enelson1001]

my fork is completely broken will start over with new fork.