update esp-hal-smartled for esp-hal 1.0.0-rc.1

This replaces esp-hal-embassy with esp-rtos and updates deps. It makes backwards-incompatible changes for updates to the esp-hal rmt api:

- https://docs.rs/esp-hal/1.0.0-rc.0/esp_hal/rmt/index.html
- https://docs.rs/esp-hal/1.0.0-rc.1/esp_hal/rmt/index.html

Author: badamson

esp-hal-smartled/Cargo.toml

@@ -14,37 +14,37 @@ targets  = ["riscv32imac-unknown-none-elf"]
 [dependencies]
 defmt             = { version = "1.0.1", optional = true }
 document-features = "0.2.10"
-esp-hal           = { version = "1.0.0-rc.0", features = ["requires-unstable"] }
+esp-hal           = { version = "1.0.0-rc.1", features = ["unstable"] }
 rgb = "0.8.52"
 smart-leds-trait  = "0.3.1"
 
 [dev-dependencies]
 cfg-if = "1.0.0"
-esp-backtrace = { version = "0.17.0", features = [
-    "exception-handler",
+esp-backtrace = { version = "0.18.0", features = [
     "panic-handler",
     "println",
 ] }
-esp-hal-embassy = "0.9.0"
-esp-bootloader-esp-idf = "0.2"
-embassy-executor = "0.7"
-embassy-time = "0.5"
-esp-println = "0.15.0"
+# Use esp-rtos for embassy support instead of esp-hal-embassy
+esp-rtos = { version = "0.1.1", features = ["embassy"] }
+esp-bootloader-esp-idf = "0.3.0"
+embassy-executor = { version = "0.9.0" }
+embassy-time = { version = "0.5.0" }
+esp-println = "0.16.0"
 smart-leds = "0.4.0"
 
 [features]
 ## Implement `defmt::Format` on certain types.
 defmt = ["dep:defmt", "esp-hal/defmt"]
 #! ### Chip Support Feature Flags
 ## Target the ESP32.
-esp32 = ["esp-backtrace/esp32", "esp-hal/esp32", "esp-println/esp32", "esp-hal-embassy/esp32", "esp-bootloader-esp-idf/esp32"]
+esp32 = ["esp-backtrace/esp32", "esp-hal/esp32", "esp-println/esp32", "esp-bootloader-esp-idf/esp32", "esp-rtos/esp32"]
 ## Target the ESP32-C3.
-esp32c3 = ["esp-backtrace/esp32c3", "esp-hal/esp32c3", "esp-println/esp32c3", "esp-hal-embassy/esp32c3", "esp-bootloader-esp-idf/esp32c3"]
+esp32c3 = ["esp-backtrace/esp32c3", "esp-hal/esp32c3", "esp-println/esp32c3", "esp-bootloader-esp-idf/esp32c3", "esp-rtos/esp32c3"]
 ## Target the ESP32-C6.
-esp32c6 = ["esp-backtrace/esp32c6", "esp-hal/esp32c6", "esp-println/esp32c6", "esp-hal-embassy/esp32c6", "esp-bootloader-esp-idf/esp32c6"]
+esp32c6 = ["esp-backtrace/esp32c6", "esp-hal/esp32c6", "esp-println/esp32c6", "esp-bootloader-esp-idf/esp32c6", "esp-rtos/esp32c6"]
 ## Target the ESP32-H2.
-esp32h2 = ["esp-backtrace/esp32h2", "esp-hal/esp32h2", "esp-println/esp32h2", "esp-hal-embassy/esp32h2", "esp-bootloader-esp-idf/esp32h2"]
+esp32h2 = ["esp-backtrace/esp32h2", "esp-hal/esp32h2", "esp-println/esp32h2", "esp-bootloader-esp-idf/esp32h2", "esp-rtos/esp32h2"]
 ## Target the ESP32-S2.
-esp32s2 = ["esp-backtrace/esp32s2", "esp-hal/esp32s2", "esp-println/esp32s2", "esp-hal-embassy/esp32s2", "esp-bootloader-esp-idf/esp32s2"]
+esp32s2 = ["esp-backtrace/esp32s2", "esp-hal/esp32s2", "esp-println/esp32s2", "esp-bootloader-esp-idf/esp32s2", "esp-rtos/esp32s2"]
 ## Target the ESP32-S3.
-esp32s3 = ["esp-backtrace/esp32s3", "esp-hal/esp32s3", "esp-println/esp32s3", "esp-hal-embassy/esp32s3", "esp-bootloader-esp-idf/esp32s3"]
+esp32s3 = ["esp-backtrace/esp32s3", "esp-hal/esp32s3", "esp-println/esp32s3", "esp-bootloader-esp-idf/esp32s3", "esp-rtos/esp32s3"]

esp-hal-smartled/examples/hello_rgb.rs

@@ -65,7 +65,7 @@ fn main() -> ! {
 
     // Each devkit uses a unique GPIO for the RGB LED, so in order to support
     // all chips we must unfortunately use `#[cfg]`s:
-    let mut led: SmartLedsAdapter<_, 25> = {
+    let mut led = {
         cfg_if::cfg_if! {
             if #[cfg(feature = "esp32")] {
                 SmartLedsAdapter::new(rmt_channel, p.GPIO33, rmt_buffer)

esp-hal-smartled/examples/hello_rgb_async.rs

@@ -34,12 +34,22 @@ use smart_leds::{
 
 esp_bootloader_esp_idf::esp_app_desc!();
 
-#[esp_hal_embassy::main]
+#[esp_rtos::main]
 async fn main(_spawner: Spawner) -> ! {
     // Initialize the HAL Peripherals
     let p = esp_hal::init(Config::default());
-    let timg0 = TimerGroup::new(p.TIMG0);
-    esp_hal_embassy::init(timg0.timer0);
+    #[cfg(target_arch = "riscv32")]
+    {
+        let timg0 = TimerGroup::new(p.TIMG0);
+        let sw_interrupt =
+            esp_hal::interrupt::software::SoftwareInterruptControl::new(p.SW_INTERRUPT);
+        esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
+    }
+    #[cfg(target_arch = "xtensa")]
+    {
+        let timg0 = TimerGroup::new(p.TIMG0);
+        esp_rtos::start(timg0.timer0);
+    }
 
     // Configure RMT (Remote Control Transceiver) peripheral globally
     // <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/peripherals/rmt.html>
@@ -61,11 +71,11 @@ async fn main(_spawner: Spawner) -> ! {
     // We use one of the RMT channels to instantiate a `SmartLedsAdapterAsync` which can
     // be used directly with all `smart_led` implementations
     let rmt_channel = rmt.channel0;
-    let rmt_buffer = [0_u32; buffer_size_async(1)];
+    let rmt_buffer = [esp_hal::rmt::PulseCode::default(); buffer_size_async(1)];
 
     // Each devkit uses a unique GPIO for the RGB LED, so in order to support
     // all chips we must unfortunately use `#[cfg]`s:
-    let mut led: SmartLedsAdapterAsync<_, 25> = {
+    let mut led = {
         cfg_if::cfg_if! {
             if #[cfg(feature = "esp32")] {
                 SmartLedsAdapterAsync::new(rmt_channel, p.GPIO33, rmt_buffer)

esp-hal-smartled/examples/hello_rgbw.rs

@@ -63,7 +63,7 @@ fn main() -> ! {
 
     // Each devkit uses a unique GPIO for the RGB LED, so in order to support
     // all chips we must unfortunately use `#[cfg]`s:
-    let mut led: SmartLedsAdapter<_, 33, rgb::Rgba<u8>> = {
+    let mut led: SmartLedsAdapter<'_, { esp_hal_smartled::buffer_size_rgbw(1) }, rgb::Rgba<u8>> = {
         cfg_if::cfg_if! {
             if #[cfg(feature = "esp32")] {
                 SmartLedsAdapter::new_with_color(rmt_channel, p.GPIO33, rmt_buffer)

esp-hal-smartled/src/lib.rs

@@ -45,10 +45,7 @@ use esp_hal::{
     Async, Blocking,
     clock::Clocks,
     gpio::{Level, interconnect::PeripheralOutput},
-    rmt::{
-        Channel, Error as RmtError, PulseCode, RawChannelAccess, TxChannel, TxChannelAsync,
-        TxChannelConfig, TxChannelCreator, TxChannelInternal,
-    },
+    rmt::{Channel, Error as RmtError, PulseCode, Tx, TxChannelConfig, TxChannelCreator},
 };
 use rgb::Grb;
 use smart_leds_trait::{SmartLedsWrite, SmartLedsWriteAsync};
@@ -81,7 +78,7 @@ impl From<RmtError> for LedAdapterError {
     }
 }
 
-fn led_pulses_for_clock(src_clock: u32) -> (u32, u32) {
+fn led_pulses_for_clock(src_clock: u32) -> (PulseCode, PulseCode) {
     (
         PulseCode::new(
             Level::High,
@@ -108,8 +105,8 @@ fn led_config() -> TxChannelConfig {
 
 fn convert_to_pulses(
     value: &[u8],
-    mut_iter: &mut IterMut<u32>,
-    pulses: (u32, u32),
+    mut_iter: &mut IterMut<PulseCode>,
+    pulses: (PulseCode, PulseCode),
 ) -> Result<(), LedAdapterError> {
     for v in value {
         convert_rgb_channel_to_pulses(*v, mut_iter, pulses)?;
@@ -119,8 +116,8 @@ fn convert_to_pulses(
 
 fn convert_rgb_channel_to_pulses(
     channel_value: u8,
-    mut_iter: &mut IterMut<u32>,
-    pulses: (u32, u32),
+    mut_iter: &mut IterMut<PulseCode>,
+    pulses: (PulseCode, PulseCode),
 ) -> Result<(), LedAdapterError> {
     for position in [128, 64, 32, 16, 8, 4, 2, 1] {
         *mut_iter.next().ok_or(LedAdapterError::BufferSizeExceeded)? =
@@ -148,7 +145,7 @@ pub const fn buffer_size(num_leds: usize) -> usize {
 /// Function to calculate the required RMT buffer size for a given number of RGBW LEDs when using
 /// the blocking API.
 ///
-/// For RGB leds use [buffer_size_rgb].
+/// For RGB leds use [buffer_size].
 ///
 /// This buffer size is calculated for the synchronous API provided by the [SmartLedsAdapter].
 /// [buffer_size_async] should be used for the asynchronous API.
@@ -167,10 +164,10 @@ pub const fn buffer_size_rgbw(num_leds: usize) -> usize {
 #[macro_export]
 macro_rules! smart_led_buffer {
     ( $num_leds: expr ) => {
-        [0u32; $crate::buffer_size($num_leds)]
+        [::esp_hal::rmt::PulseCode::default(); $crate::buffer_size($num_leds)]
     };
     ( $num_leds: expr; RGBW ) => {
-        [0u32; $crate::buffer_size_rgbw($num_leds)]
+        [::esp_hal::rmt::PulseCode::default(); $crate::buffer_size_rgbw($num_leds)]
     };
 }
 
@@ -185,44 +182,37 @@ macro_rules! smartLedBuffer {
 
 /// Adapter taking an RMT channel and a specific pin and providing RGB LED
 /// interaction functionality using the `smart-leds` crate
-pub struct SmartLedsAdapter<TX, const BUFFER_SIZE: usize, Color = Grb<u8>>
-where
-    TX: RawChannelAccess + TxChannelInternal + 'static,
-{
-    channel: Option<Channel<Blocking, TX>>,
-    rmt_buffer: [u32; BUFFER_SIZE],
-    pulses: (u32, u32),
+pub struct SmartLedsAdapter<'ch, const BUFFER_SIZE: usize, Color = Grb<u8>> {
+    channel: Option<Channel<'ch, Blocking, Tx>>,
+    rmt_buffer: [PulseCode; BUFFER_SIZE],
+    pulses: (PulseCode, PulseCode),
     color: PhantomData<Color>,
 }
 
-impl<'d, TX, const BUFFER_SIZE: usize> SmartLedsAdapter<TX, BUFFER_SIZE, Grb<u8>>
-where
-    TX: RawChannelAccess + TxChannelInternal + 'static,
-{
+impl<'ch, const BUFFER_SIZE: usize> SmartLedsAdapter<'ch, BUFFER_SIZE, Grb<u8>> {
     /// Create a new adapter object that drives the pin using the RMT channel.
-    pub fn new<C, O>(channel: C, pin: O, rmt_buffer: [u32; BUFFER_SIZE]) -> Self
+    pub fn new<C, O>(channel: C, pin: O, rmt_buffer: [PulseCode; BUFFER_SIZE]) -> Self
     where
-        O: PeripheralOutput<'d>,
-        C: TxChannelCreator<'d, Blocking, Raw = TX>,
+        O: PeripheralOutput<'ch>,
+        C: TxChannelCreator<'ch, Blocking>,
     {
         Self::new_with_color(channel, pin, rmt_buffer)
     }
 }
 
-impl<'d, TX, const BUFFER_SIZE: usize, Color> SmartLedsAdapter<TX, BUFFER_SIZE, Color>
+impl<'ch, const BUFFER_SIZE: usize, Color> SmartLedsAdapter<'ch, BUFFER_SIZE, Color>
 where
-    TX: RawChannelAccess + TxChannelInternal + 'static,
     Color: rgb::ComponentSlice<u8>,
 {
     /// Create a new adapter object that drives the pin using the RMT channel.
     pub fn new_with_color<C, O>(
         channel: C,
         pin: O,
-        rmt_buffer: [u32; BUFFER_SIZE],
-    ) -> SmartLedsAdapter<TX, BUFFER_SIZE, Color>
+        rmt_buffer: [PulseCode; BUFFER_SIZE],
+    ) -> SmartLedsAdapter<'ch, BUFFER_SIZE, Color>
     where
-        O: PeripheralOutput<'d>,
-        C: TxChannelCreator<'d, Blocking, Raw = TX>,
+        O: PeripheralOutput<'ch>,
+        C: TxChannelCreator<'ch, Blocking>,
     {
         let channel = channel.configure_tx(pin, led_config()).unwrap();
 
@@ -238,10 +228,9 @@ where
     }
 }
 
-impl<TX, const BUFFER_SIZE: usize, Color> SmartLedsWrite
-    for SmartLedsAdapter<TX, BUFFER_SIZE, Color>
+impl<'ch, const BUFFER_SIZE: usize, Color> SmartLedsWrite
+    for SmartLedsAdapter<'ch, BUFFER_SIZE, Color>
 where
-    TX: RawChannelAccess + TxChannelInternal + 'static,
     Color: rgb::ComponentSlice<u8>,
 {
     type Error = LedAdapterError;
@@ -266,9 +255,9 @@ where
         }
 
         // Finally, add an end element.
-        *seq_iter.next().ok_or(LedAdapterError::BufferSizeExceeded)? = 0;
+        *seq_iter.next().ok_or(LedAdapterError::BufferSizeExceeded)? = PulseCode::end_marker();
 
-        // Perform the actual RMT operation. We use the u32 values here right away.
+        // Perform the actual RMT operation.
         let channel = self.channel.take().unwrap();
         match channel.transmit(&self.rmt_buffer)?.wait() {
             Ok(chan) => {
@@ -311,44 +300,37 @@ pub const fn buffer_size_async_rgbw(num_leds: usize) -> usize {
 
 /// Adapter taking an RMT channel and a specific pin and providing RGB LED
 /// interaction functionality.
-pub struct SmartLedsAdapterAsync<Tx, const BUFFER_SIZE: usize, Color = Grb<u8>>
-where
-    Tx: RawChannelAccess + TxChannelInternal + 'static,
-{
-    channel: Channel<Async, Tx>,
-    rmt_buffer: [u32; BUFFER_SIZE],
-    pulses: (u32, u32),
+pub struct SmartLedsAdapterAsync<'ch, const BUFFER_SIZE: usize, Color = Grb<u8>> {
+    channel: Channel<'ch, Async, Tx>,
+    rmt_buffer: [PulseCode; BUFFER_SIZE],
+    pulses: (PulseCode, PulseCode),
     color: PhantomData<Color>,
 }
 
-impl<'d, Tx, const BUFFER_SIZE: usize> SmartLedsAdapterAsync<Tx, BUFFER_SIZE, Grb<u8>>
-where
-    Tx: RawChannelAccess + TxChannelInternal + 'static,
-{
+impl<'ch, const BUFFER_SIZE: usize> SmartLedsAdapterAsync<'ch, BUFFER_SIZE, Grb<u8>> {
     /// Create a new adapter object that drives the pin using the RMT channel.
-    pub fn new<C, O>(channel: C, pin: O, rmt_buffer: [u32; BUFFER_SIZE]) -> Self
+    pub fn new<C, O>(channel: C, pin: O, rmt_buffer: [PulseCode; BUFFER_SIZE]) -> Self
     where
-        O: PeripheralOutput<'d>,
-        C: TxChannelCreator<'d, Async, Raw = Tx>,
+        O: PeripheralOutput<'ch>,
+        C: TxChannelCreator<'ch, Async>,
     {
         Self::new_with_color(channel, pin, rmt_buffer)
     }
 }
 
-impl<'d, Tx, const BUFFER_SIZE: usize, Color> SmartLedsAdapterAsync<Tx, BUFFER_SIZE, Color>
+impl<'ch, const BUFFER_SIZE: usize, Color> SmartLedsAdapterAsync<'ch, BUFFER_SIZE, Color>
 where
-    Tx: RawChannelAccess + TxChannelInternal + 'static,
     Color: rgb::ComponentSlice<u8>,
 {
     /// Create a new adapter object that drives the pin using the RMT channel.
     pub fn new_with_color<C, O>(
         channel: C,
         pin: O,
-        rmt_buffer: [u32; BUFFER_SIZE],
-    ) -> SmartLedsAdapterAsync<Tx, BUFFER_SIZE, Color>
+        rmt_buffer: [PulseCode; BUFFER_SIZE],
+    ) -> SmartLedsAdapterAsync<'ch, BUFFER_SIZE, Color>
     where
-        O: PeripheralOutput<'d>,
-        C: TxChannelCreator<'d, Async, Raw = Tx>,
+        O: PeripheralOutput<'ch>,
+        C: TxChannelCreator<'ch, Async>,
     {
         let channel = channel.configure_tx(pin, led_config()).unwrap();
 
@@ -382,21 +364,20 @@ where
     /// Async sends one pixel at a time so needs a delimiter after each pixel
     fn convert_to_pulses(
         value: &[u8],
-        mut_iter: &mut IterMut<u32>,
-        pulses: (u32, u32),
+        mut_iter: &mut IterMut<PulseCode>,
+        pulses: (PulseCode, PulseCode),
     ) -> Result<(), LedAdapterError> {
         for v in value {
             convert_rgb_channel_to_pulses(*v, mut_iter, pulses)?;
         }
-        *mut_iter.next().ok_or(LedAdapterError::BufferSizeExceeded)? = 0;
+        *mut_iter.next().ok_or(LedAdapterError::BufferSizeExceeded)? = PulseCode::end_marker();
         Ok(())
     }
 }
 
-impl<Tx, const BUFFER_SIZE: usize, Color> SmartLedsWriteAsync
-    for SmartLedsAdapterAsync<Tx, BUFFER_SIZE, Color>
+impl<'ch, const BUFFER_SIZE: usize, Color> SmartLedsWriteAsync
+    for SmartLedsAdapterAsync<'ch, BUFFER_SIZE, Color>
 where
-    Tx: RawChannelAccess + TxChannelInternal + 'static,
     Color: rgb::ComponentSlice<u8>,
 {
     type Error = LedAdapterError;