fix(ws2812): Try opening device multiple times

Author: alixinne

src/instance/device/ws2812spi.rs

@@ -7,7 +7,8 @@ use crate::models;
 pub type Ws2812SpiDevice = Rewriter<Ws2812SpiImpl>;
 
 pub struct Ws2812SpiImpl {
-    dev: Spidev,
+    dev: ImplState,
+    notified_error: bool,
     buf: Vec<u8>,
 }
 
@@ -16,30 +17,78 @@ const SPI_BYTES_PER_COLOUR: usize = 4;
 const SPI_FRAME_END_LATCH_BYTES: usize = 116;
 const BITPAIR_TO_BYTE: [u8; 4] = [0b10001000, 0b10001100, 0b11001000, 0b11001100];
 
+enum ImplState {
+    Pending(models::Ws2812Spi),
+    Ready(Spidev),
+}
+
+impl ImplState {
+    fn as_dev(&self) -> Option<&Spidev> {
+        match self {
+            ImplState::Ready(dev) => Some(dev),
+            _ => None,
+        }
+    }
+
+    fn try_init(&mut self) -> Result<&Spidev, DeviceError> {
+        match self {
+            ImplState::Pending(config) => {
+                // Initialize SPI device
+                let mut dev = Spidev::open(&config.output)?;
+                let options = SpidevOptions::new()
+                    .bits_per_word(8)
+                    .max_speed_hz(config.rate as _)
+                    .mode(SpiModeFlags::SPI_MODE_0)
+                    .build();
+                dev.configure(&options)?;
+
+                info!(path = %config.output, "initialized SPI device");
+
+                *self = Self::from(dev);
+                Ok(self.as_dev().unwrap())
+            }
+
+            ImplState::Ready(dev) => Ok(dev),
+        }
+    }
+}
+
+impl From<&models::Ws2812Spi> for ImplState {
+    fn from(value: &models::Ws2812Spi) -> Self {
+        Self::Pending(value.clone())
+    }
+}
+
+impl From<Spidev> for ImplState {
+    fn from(value: Spidev) -> Self {
+        Self::Ready(value)
+    }
+}
+
 #[async_trait]
 impl WritingDevice for Ws2812SpiImpl {
     type Config = models::Ws2812Spi;
 
     fn new(config: &models::Ws2812Spi) -> Result<Self, DeviceError> {
-        // Initialize SPI device
-        let mut dev = Spidev::open(&config.output)?;
-        let options = SpidevOptions::new()
-            .bits_per_word(8)
-            .max_speed_hz(config.rate as _)
-            .mode(SpiModeFlags::SPI_MODE_0)
-            .build();
-        dev.configure(&options)?;
-
         // Buffer for SPI tranfers
         let buf = vec![
             0;
             config.hardware_led_count as usize * SPI_BYTES_PER_LED
                 + SPI_FRAME_END_LATCH_BYTES
         ];
 
-        info!(path = %config.output, "initialized SPI device");
+        let mut dev = ImplState::from(config);
+
+        // Try to open the device early
+        if let Err(error) = dev.try_init() {
+            warn!(%error, path = %config.output, "failed to initialize SPI device, will try again later");
+        }
 
-        Ok(Self { dev, buf })
+        Ok(Self {
+            dev,
+            notified_error: false,
+            buf,
+        })
     }
 
     async fn set_let_data(
@@ -77,7 +126,21 @@ impl WritingDevice for Ws2812SpiImpl {
     async fn write(&mut self) -> Result<(), DeviceError> {
         // Perform SPI transfer
         let mut transfer = SpidevTransfer::write(&self.buf);
-        self.dev.transfer(&mut transfer)?;
+
+        // Try writing to the device
+        match self.dev.try_init() {
+            Ok(dev) => {
+                self.notified_error = false;
+                dev.transfer(&mut transfer)?;
+            }
+            Err(err) => {
+                if !self.notified_error {
+                    self.notified_error = true;
+                    error!(error = %err, "failed to initialize SPI device");
+                }
+            }
+        }
+
         Ok(())
     }
 }