bluepill-rs/src/dmx.rs

@@ -2,15 +2,18 @@ use cortex_m::singleton;
 use stm32f1xx_hal::{dma, pac, prelude::*, rcc, serial};
 
 type _TxDma = dma::TxDma<serial::Tx<pac::USART1>, dma::dma1::C4>;
-type _DMXUniverse<const DMX_LEN: usize> = &'static mut [u8; DMX_LEN];
-type _DMXTransfer<const DMX_LEN: usize> = dma::Transfer<dma::R, _DMXUniverse<DMX_LEN>, _TxDma>;
 
-pub enum DMX<const DMX_LEN: usize = 512> {
+pub struct DMXIdle {
-    Idle(Option<_TxDma>, Option<_DMXUniverse<DMX_LEN>>),
+    tx: Option<_TxDma>,
-    Busy(Option<_DMXTransfer<DMX_LEN>>),
+    txbuffer: Option<&'static mut [u8; 512]>,
 }
 
-impl<const DMX_LEN: usize> DMX<DMX_LEN> {
+pub enum DMX {
+    Idle(DMXIdle),
+    Busy(Option<dma::Transfer<dma::R, &'static mut [u8; 512], _TxDma>>),
+}
+
+impl DMX {
     pub fn new<PINS>(
         mut serial: serial::Serial<pac::USART1, PINS>,
         channel: dma::dma1::C4,
@@ -21,34 +24,34 @@ impl<const DMX_LEN: usize> DMX<DMX_LEN> {
     {
         serial.reconfigure(250_000.bps(), &clocks).unwrap();
 
-        Self::Idle(Some(serial.tx.with_dma(channel)), None)
+        Self::Idle(DMXIdle {
+            tx: Some(serial.tx.with_dma(channel)),
+            txbuffer: None,
+        })
     }
 
-    pub fn send(&mut self, data: &[u8; DMX_LEN]) {
+    pub fn send(&mut self, data: &[u8; 512]) {
-        if let Self::Busy(_) = self {
+        if let Self::Idle(idle) = self {
-            self.wait();
+            let txbuffer = idle
-        }
+                .txbuffer
-
+                .take()
-        let Self::Idle(tx, txbuffer) = self else {
+                .unwrap_or_else(|| singleton!(: [u8; 512] = [0; 512]).unwrap());
-            panic!("Broken DMX State!")
+            let tx = idle.tx.take().unwrap();
-        };
-
-        let txbuffer = txbuffer.take().unwrap_or_else(|| {
-            let foo = singleton!(: [u8; 512] = [0u8; 512]).unwrap();
-            (&mut foo[..DMX_LEN]).try_into().unwrap()
-        });
-        let tx = tx.take().unwrap();
 
             txbuffer.copy_from_slice(data);
             *self = Self::Busy(Some(tx.write(txbuffer)));
         }
+    }
 
     pub fn wait(&mut self) {
-        let Self::Busy(xfer) = self else { return };
+        if let Self::Busy(xfer) = self {
-
             let xfer = xfer.take().unwrap();
             let (txbuffer, tx) = xfer.wait();
 
-        *self = Self::Idle(Some(tx), Some(txbuffer));
+            *self = Self::Idle(DMXIdle {
+                tx: Some(tx),
+                txbuffer: Some(txbuffer),
+            });
+        }
     }
 }

bluepill-rs/src/main.rs

@@ -9,7 +9,7 @@ mod dmx;
 // extern crate panic_halt;
 extern crate panic_semihosting;
 
-#[rtic::app(device = stm32f1xx_hal::pac, dispatchers = [SPI1, SPI2, SPI3])]
+#[rtic::app(device = stm32f1xx_hal::pac, dispatchers = [PVD])]
 mod app {
     use cortex_m::singleton;
     use stm32f1xx_hal::{gpio, pac, prelude::*, serial, timer};
@@ -29,7 +29,7 @@ mod app {
 
     #[local]
     struct Local {
-        dmx: DMX<512>,
+        dmx: DMX,
         led: gpio::gpioc::PC13<gpio::Output>,
     }
 
@@ -87,9 +87,7 @@ mod app {
 
                 // Configure gpio C pin 13 as a push-pull output. The `crh` register is passed to the function
                 // in order to configure the port. For pins 0-7, crl should be passed instead.
-                led: gpioc
+                led: gpioc.pc13.into_push_pull_output(&mut gpioc.crh),
-                    .pc13
-                    .into_push_pull_output_with_state(&mut gpioc.crh, gpio::PinState::High),
             },
             init::Monotonics(mono),
         )
@@ -109,7 +107,7 @@ mod app {
         cx.local.led.toggle();
         cx.shared.delay_us.lock(|d| d.delay(1.secs()));
 
-        // cx.local.dmx.wait();
+        cx.local.dmx.wait();
         foo::spawn().unwrap();
     }
 }