bluepill-rust-blinky/bluepill-rs/src/dmx.rs

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 struct DMXIdle<const DMX_LEN: usize> {
    tx: Option<_TxDma>,
    txbuffer: Option<_DMXUniverse<DMX_LEN>>,
}

pub enum DMX<const DMX_LEN: usize = 512> {
    Idle(DMXIdle<DMX_LEN>),
    Busy(Option<_DMXTransfer<DMX_LEN>>),
}

impl<const DMX_LEN: usize> DMX<DMX_LEN> {
    pub fn new<PINS>(
        mut serial: serial::Serial<pac::USART1, PINS>,
        channel: dma::dma1::C4,
        clocks: &rcc::Clocks,
    ) -> Self
    where
        PINS: serial::Pins<pac::USART1>,
    {
        serial.reconfigure(250_000.bps(), &clocks).unwrap();

        Self::Idle(DMXIdle {
            tx: Some(serial.tx.with_dma(channel)),
            txbuffer: None,
        })
    }

    pub fn send(&mut self, data: &[u8; DMX_LEN]) {
        if let Self::Busy(_) = self {
            self.wait();
        }

        let Self::Idle(idle) = self else {
            panic!("Broken DMX State!")
        };

        let txbuffer = idle.txbuffer.take().unwrap_or_else(|| {
            let foo = singleton!(: [u8; 512] = [0u8; 512]).unwrap();
            (&mut foo[..DMX_LEN]).try_into().unwrap()
        });
        let tx = idle.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 };

        let xfer = xfer.take().unwrap();
        let (txbuffer, tx) = xfer.wait();

        *self = Self::Idle(DMXIdle {
            tx: Some(tx),
            txbuffer: Some(txbuffer),
        });
    }
}