remove asynch submodule

Author: robamu

esp-hal-smartled/CHANGELOG.md

@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- New `asynch::SmartLedsAdapter` which is an asynchronous, non-blocking version of the driver.
+- New `SmartLedsAdapterAsync` which is an asynchronous, non-blocking version of the driver.
 
 ## 0.14.0
 

esp-hal-smartled/src/lib.rs

@@ -117,6 +117,9 @@ fn convert_rgb_channel_to_pulses(
 
 /// Function to calculate the required RMT buffer size for a given number of LEDs when using
 /// the blocking API.
+///
+/// This buffer size is calculated for the synchronous API provided by the [SmartLedsAdapter].
+/// [buffer_size_async] should be used for the asynchronous API.
 pub const fn buffer_size(num_leds: usize) -> usize {
     // 1 additional pulse for the end delimiter
     num_leds * RMT_RAM_ONE_LED + 1
@@ -225,104 +228,96 @@ where
 }
 
 /// Support for asynchronous and non-blocking use of the RMT peripheral to drive smart LEDs.
-pub mod asynch {
-    use super::*;
-    use esp_hal::{
-        clock::Clocks,
-        gpio::OutputPin,
-        peripheral::Peripheral,
-        rmt::{TxChannelAsync, TxChannelCreatorAsync},
-    };
 
-    /// Function to calculate the required RMT buffer size for a given number of LEDs when using
-    /// the asynchronous API.
-    pub const fn buffer_size(num_leds: usize) -> usize {
-        // 1 byte end delimiter for each transfer.
-        num_leds * (RMT_RAM_ONE_LED + 1)
-    }
+/// Function to calculate the required RMT buffer size for a given number of LEDs when using
+/// the asynchronous API. This buffer size is calculated for the asynchronous API provided by the
+/// [SmartLedsAdapterAsync]. [buffer_size] should be used for the synchronous API.
+pub const fn buffer_size_async(num_leds: usize) -> usize {
+    // 1 byte end delimiter for each transfer.
+    num_leds * (RMT_RAM_ONE_LED + 1)
+}
 
-    /// Adapter taking an RMT channel and a specific pin and providing RGB LED
-    /// interaction functionality.
-    pub struct SmartLedAdapterAsync<Tx, const BUFFER_SIZE: usize> {
-        channel: Tx,
+/// Adapter taking an RMT channel and a specific pin and providing RGB LED
+/// interaction functionality.
+pub struct SmartLedsAdapterAsync<Tx, const BUFFER_SIZE: usize> {
+    channel: Tx,
+    rmt_buffer: [u32; BUFFER_SIZE],
+    pulses: (u32, u32),
+}
+
+impl<'d, Tx: TxChannelAsync, const BUFFER_SIZE: usize> SmartLedsAdapterAsync<Tx, BUFFER_SIZE> {
+    /// Create a new adapter object that drives the pin using the RMT channel.
+    pub fn new<C, O>(
+        channel: C,
+        pin: impl Peripheral<P = O> + 'd,
         rmt_buffer: [u32; BUFFER_SIZE],
-        pulses: (u32, u32),
-    }
+    ) -> SmartLedsAdapterAsync<Tx, BUFFER_SIZE>
+    where
+        O: OutputPin + 'd,
+        C: TxChannelCreatorAsync<'d, Tx, O>,
+    {
+        let channel = channel.configure(pin, led_config()).unwrap();
 
-    impl<'d, Tx: TxChannelAsync, const BUFFER_SIZE: usize> SmartLedAdapterAsync<Tx, BUFFER_SIZE> {
-        /// Create a new adapter object that drives the pin using the RMT channel.
-        pub fn new<C, O>(
-            channel: C,
-            pin: impl Peripheral<P = O> + 'd,
-            rmt_buffer: [u32; BUFFER_SIZE],
-        ) -> SmartLedAdapterAsync<Tx, BUFFER_SIZE>
-        where
-            O: OutputPin + 'd,
-            C: TxChannelCreatorAsync<'d, Tx, O>,
-        {
-            let channel = channel.configure(pin, led_config()).unwrap();
-
-            // Assume the RMT peripheral is set up to use the APB clock
-            let src_clock = Clocks::get().apb_clock.to_MHz();
-
-            Self {
-                channel,
-                rmt_buffer,
-                pulses: led_pulses_for_clock(src_clock),
-            }
-        }
+        // Assume the RMT peripheral is set up to use the APB clock
+        let src_clock = Clocks::get().apb_clock.to_MHz();
 
-        fn prepare_rmt_buffer<I: Into<RGB8>>(
-            &mut self,
-            iterator: impl IntoIterator<Item = I>,
-        ) -> Result<(), LedAdapterError> {
-            // We always start from the beginning of the buffer
-            let mut seq_iter = self.rmt_buffer.iter_mut();
-
-            // Add all converted iterator items to the buffer.
-            // This will result in an `BufferSizeExceeded` error in case
-            // the iterator provides more elements than the buffer can take.
-            for item in iterator {
-                Self::convert_rgb_to_pulse(item.into(), &mut seq_iter, self.pulses)?;
-            }
-            Ok(())
+        Self {
+            channel,
+            rmt_buffer,
+            pulses: led_pulses_for_clock(src_clock),
         }
+    }
 
-        /// Converts a RGB value to the correspodnign pulse value.
-        fn convert_rgb_to_pulse(
-            value: RGB8,
-            mut_iter: &mut IterMut<u32>,
-            pulses: (u32, u32),
-        ) -> Result<(), LedAdapterError> {
-            convert_rgb_to_pulses(value, mut_iter, pulses)?;
-            *mut_iter.next().ok_or(LedAdapterError::BufferSizeExceeded)? = 0;
+    fn prepare_rmt_buffer<I: Into<RGB8>>(
+        &mut self,
+        iterator: impl IntoIterator<Item = I>,
+    ) -> Result<(), LedAdapterError> {
+        // We always start from the beginning of the buffer
+        let mut seq_iter = self.rmt_buffer.iter_mut();
 
-            Ok(())
+        // Add all converted iterator items to the buffer.
+        // This will result in an `BufferSizeExceeded` error in case
+        // the iterator provides more elements than the buffer can take.
+        for item in iterator {
+            Self::convert_rgb_to_pulse(item.into(), &mut seq_iter, self.pulses)?;
         }
+        Ok(())
+    }
+
+    /// Converts a RGB value to the correspodnign pulse value.
+    fn convert_rgb_to_pulse(
+        value: RGB8,
+        mut_iter: &mut IterMut<u32>,
+        pulses: (u32, u32),
+    ) -> Result<(), LedAdapterError> {
+        convert_rgb_to_pulses(value, mut_iter, pulses)?;
+        *mut_iter.next().ok_or(LedAdapterError::BufferSizeExceeded)? = 0;
+
+        Ok(())
     }
+}
+
+impl<Tx: TxChannelAsync, const BUFFER_SIZE: usize> SmartLedsWriteAsync
+    for SmartLedsAdapterAsync<Tx, BUFFER_SIZE>
+{
+    type Error = LedAdapterError;
+    type Color = RGB8;
 
-    impl<Tx: TxChannelAsync, const BUFFER_SIZE: usize> SmartLedsWriteAsync
-        for SmartLedAdapterAsync<Tx, BUFFER_SIZE>
+    /// Convert all RGB8 items of the iterator to the RMT format and
+    /// add them to internal buffer, then start perform all asynchronous operations based on
+    /// that buffer.
+    async fn write<T, I>(&mut self, iterator: T) -> Result<(), Self::Error>
+    where
+        T: IntoIterator<Item = I>,
+        I: Into<Self::Color>,
     {
-        type Error = LedAdapterError;
-        type Color = RGB8;
-
-        /// Convert all RGB8 items of the iterator to the RMT format and
-        /// add them to internal buffer, then start perform all asynchronous operations based on
-        /// that buffer.
-        async fn write<T, I>(&mut self, iterator: T) -> Result<(), Self::Error>
-        where
-            T: IntoIterator<Item = I>,
-            I: Into<Self::Color>,
-        {
-            self.prepare_rmt_buffer(iterator)?;
-            for chunk in self.rmt_buffer.chunks(RMT_RAM_ONE_LED + 1) {
-                self.channel
-                    .transmit(chunk)
-                    .await
-                    .map_err(LedAdapterError::TransmissionError)?;
-            }
-            Ok(())
+        self.prepare_rmt_buffer(iterator)?;
+        for chunk in self.rmt_buffer.chunks(RMT_RAM_ONE_LED + 1) {
+            self.channel
+                .transmit(chunk)
+                .await
+                .map_err(LedAdapterError::TransmissionError)?;
         }
+        Ok(())
     }
 }