chore: even less expect's

Author: filipton

src/bluetooth.rs

@@ -359,14 +359,14 @@ async fn load_bonding_info(nvs: &esp_hal_wifimanager::Nvs) -> Option<BondInforma
         return None;
     }
 
-    let bd_addr = BdAddr::new(buf[..6].try_into().expect("Cannot fail"));
+    let bd_addr = BdAddr::new(buf[..6].try_into().expect(""));
     let security_level = match buf[22] {
         0 => SecurityLevel::NoEncryption,
         1 => SecurityLevel::Encrypted,
         2 => SecurityLevel::EncryptedAuthenticated,
         _ => return None,
     };
-    let ltk = LongTermKey::from_le_bytes(buf[6..22].try_into().expect("Cannot fail"));
+    let ltk = LongTermKey::from_le_bytes(buf[6..22].try_into().expect(""));
 
     Some(BondInformation {
         identity: Identity { bd_addr, irk: None },
@@ -388,14 +388,15 @@ impl EventHandler for BleDiscovery<'_> {
         while let Some(Ok(report)) = it.next() {
             if !seen.iter().any(|b| b.raw() == report.addr.raw()) {
                 if let Some(name) = parse_device_name(report.data)
-                    && name.starts_with("FKMD-") {
-                        log::info!("Disovered FKM Display! [{:?}] ({name})", report.addr);
+                    && name.starts_with("FKMD-")
+                {
+                    log::info!("Disovered FKM Display! [{:?}] ({name})", report.addr);
 
-                        _ = self.sender.try_send(BleDisplayDevice {
-                            name: name.to_string(),
-                            addr: report.addr.into_inner(),
-                        });
-                    }
+                    _ = self.sender.try_send(BleDisplayDevice {
+                        name: name.to_string(),
+                        addr: report.addr.into_inner(),
+                    });
+                }
 
                 if seen.is_full() {
                     seen.pop_front();

src/board.rs

@@ -1,6 +1,6 @@
 use crate::utils::stackmat::{DEC_DIGITS, DOT_MOD};
 use adv_shift_registers::wrappers::ShifterValueRange;
-use anyhow::Result;
+use embedded_hal::digital::OutputPin;
 use esp_hal::{
     gpio::{AnyPin, Input, InputConfig, Level, Output, Pin, Pull},
     peripherals::{
@@ -47,9 +47,7 @@ pub struct Board {
 }
 
 impl Board {
-    pub fn init(peripherals: Peripherals) -> Result<Board> {
-        use embedded_hal::digital::OutputPin;
-
+    pub fn init(peripherals: Peripherals) -> Board {
         let timg0 = TimerGroup::new(peripherals.TIMG0);
         let timg1 = TimerGroup::new(peripherals.TIMG1);
         let rng = Rng::new();
@@ -100,7 +98,7 @@ impl Board {
         let mut cs = adv_shift_reg.get_pin_mut(1, 0, true);
         _ = cs.set_high();
 
-        Ok(Board {
+        Board {
             timg0,
             timg1,
             rng,
@@ -128,6 +126,6 @@ impl Board {
             lcd,
             usb_dp,
             usb_dm,
-        })
+        }
     }
 }

src/main.rs

@@ -99,7 +99,7 @@ async fn main(spawner: Spawner) {
     }
 
     set_brownout_detection(false);
-    let board = Board::init(peripherals).expect("Board init error");
+    let board = Board::init(peripherals);
     let software_interrupt = SoftwareInterruptControl::new(board.sw_interrupt);
     esp_rtos::start(board.timg1.timer0, software_interrupt.software_interrupt0);
     FkmLogger::set_logger();

src/rfid.rs

@@ -26,26 +26,39 @@ pub async fn rfid_task(
 ) {
     #[allow(clippy::manual_div_ceil)]
     let (rx_buffer, rx_descriptors, tx_buffer, tx_descriptors) = dma_buffers!(512);
-    let dma_tx_buf = DmaTxBuf::new(tx_descriptors, tx_buffer).expect("Dma tx buf failed");
-    let dma_rx_buf = DmaRxBuf::new(rx_descriptors, rx_buffer).expect("Dma rx buf failed");
+    let Ok(dma_tx_buf) = DmaTxBuf::new(tx_descriptors, tx_buffer) else {
+        log::error!("Dma tx buf failed");
+        return;
+    };
+    let Ok(dma_rx_buf) = DmaRxBuf::new(rx_descriptors, rx_buffer) else {
+        log::error!("Dma rx buf failed");
+        return;
+    };
 
-    let spi = Spi::new(
+    let Ok(spi) = Spi::new(
         spi,
         esp_hal::spi::master::Config::default()
             .with_frequency(Rate::from_khz(400))
             .with_mode(Mode::_0),
     )
-    .expect("Spi init failed")
-    .with_sck(sck)
-    .with_miso(miso)
-    .with_mosi(mosi)
-    .with_dma(dma_chan)
-    .with_buffers(dma_rx_buf, dma_tx_buf)
-    .into_async();
+    .map(|s| {
+        s.with_sck(sck)
+            .with_miso(miso)
+            .with_mosi(mosi)
+            .with_dma(dma_chan)
+            .with_buffers(dma_rx_buf, dma_tx_buf)
+            .into_async()
+    }) else {
+        log::error!("Rfid task error while creating Spi instance!");
+        return;
+    };
 
     let mut mfrc522 = {
-        let spi = embedded_hal_bus::spi::ExclusiveDevice::new(spi, cs_pin, embassy_time::Delay)
-            .expect("Spi bus init failed (cs set high failed)");
+        let Ok(spi) = embedded_hal_bus::spi::ExclusiveDevice::new(spi, cs_pin, embassy_time::Delay)
+        else {
+            log::error!("Spi bus init failed (cs set high failed)");
+            return;
+        };
 
         esp_hal_mfrc522::MFRC522::new(esp_hal_mfrc522::drivers::SpiDriver::new(spi))
     };

src/stackmat.rs

@@ -20,8 +20,7 @@ pub async fn stackmat_task(
     global_state: GlobalState,
 ) {
     let serial_config = esp_hal::uart::Config::default().with_baudrate(1200);
-    let Ok(mut uart) = UartRx::new(uart, serial_config).map(|u| u.with_rx(uart_pin))
-    else {
+    let Ok(mut uart) = UartRx::new(uart, serial_config).map(|u| u.with_rx(uart_pin)) else {
         log::error!("Stackmat task error while creating UartRx instance!");
         return;
     };