cleanups

Software/MainBoard/rust/src/fat_error.rs

@@ -0,0 +1,318 @@
+use alloc::format;
+use alloc::string::{String, ToString};
+use core::convert::Infallible;
+use core::fmt;
+use core::str::Utf8Error;
+use embassy_embedded_hal::shared_bus::I2cDeviceError;
+use embassy_executor::SpawnError;
+use embassy_sync::mutex::TryLockError;
+use embedded_storage::nor_flash::NorFlashErrorKind;
+use esp_hal::i2c::master::ConfigError;
+use esp_hal::pcnt::unit::{InvalidHighLimit, InvalidLowLimit};
+use esp_hal::twai::EspTwaiError;
+use esp_wifi::wifi::WifiError;
+use ina219::errors::{BusVoltageReadError, ShuntVoltageReadError};
+use littlefs2_core::PathError;
+use onewire::Error;
+use pca9535::ExpanderError;
+
+//All error superconstruct
+#[derive(Debug)]
+pub enum FatError {
+    OneWireError {
+        error: Error<Infallible>,
+    },
+    String {
+        error: String,
+    },
+    LittleFSError {
+        error: littlefs2_core::Error,
+    },
+    PathError {
+        error: PathError,
+    },
+    TryLockError {
+        error: TryLockError,
+    },
+    WifiError {
+        error: WifiError,
+    },
+    SerdeError {
+        error: serde_json::Error,
+    },
+    PreconditionFailed {
+        error: String,
+    },
+    NoBatteryMonitor,
+    SpawnError {
+        error: SpawnError,
+    },
+    PartitionError {
+        error: esp_bootloader_esp_idf::partitions::Error,
+    },
+    I2CConfigError {
+        error: ConfigError,
+    },
+    DS323 {
+        error: String,
+    },
+    Eeprom24x {
+        error: String,
+    },
+    ExpanderError {
+        error: String,
+    },
+    CanBusError {
+        error: EspTwaiError,
+    },
+    SNTPError {
+        error: sntpc::Error,
+    },
+}
+
+pub type FatResult<T> = Result<T, FatError>;
+
+impl fmt::Display for FatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FatError::SpawnError { error } => {
+                write!(f, "SpawnError {:?}", error.to_string())
+            }
+            FatError::OneWireError { error } => write!(f, "OneWireError {:?}", error),
+            FatError::String { error } => write!(f, "{}", error),
+            FatError::LittleFSError { error } => write!(f, "LittleFSError {:?}", error),
+            FatError::PathError { error } => write!(f, "PathError {:?}", error),
+            FatError::TryLockError { error } => write!(f, "TryLockError {:?}", error),
+            FatError::WifiError { error } => write!(f, "WifiError {:?}", error),
+            FatError::SerdeError { error } => write!(f, "SerdeError {:?}", error),
+            FatError::PreconditionFailed { error } => write!(f, "PreconditionFailed {:?}", error),
+            FatError::PartitionError { error } => {
+                write!(f, "PartitionError {:?}", error)
+            }
+            FatError::NoBatteryMonitor => {
+                write!(f, "No Battery Monitor")
+            }
+            FatError::I2CConfigError { error } => write!(f, "I2CConfigError {:?}", error),
+            FatError::DS323 { error } => write!(f, "DS323 {:?}", error),
+            FatError::Eeprom24x { error } => write!(f, "Eeprom24x {:?}", error),
+            FatError::ExpanderError { error } => write!(f, "ExpanderError {:?}", error),
+            FatError::CanBusError { error } => {
+                write!(f, "CanBusError {:?}", error)
+            }
+            FatError::SNTPError { error } => write!(f, "SNTPError {:?}", error),
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! bail {
+    ($msg:literal $(,)?) => {
+        return $crate::fat_error::fat_bail($msg)
+    };
+    ($fmt:literal, $($arg:tt)*) => {
+        return $crate::fat_error::fat_bail(&alloc::format!($fmt, $($arg)*))
+    };
+}
+
+pub fn fat_bail<X>(message: &str) -> Result<X, FatError> {
+    Err(FatError::String {
+        error: message.to_string(),
+    })
+}
+
+pub trait ContextExt<T> {
+    fn context<C>(self, context: C) -> Result<T, FatError>
+    where
+        C: AsRef<str>;
+}
+impl<T> ContextExt<T> for Option<T> {
+    fn context<C>(self, context: C) -> Result<T, FatError>
+    where
+        C: AsRef<str>,
+    {
+        match self {
+            Some(value) => Ok(value),
+            None => Err(FatError::PreconditionFailed {
+                error: context.as_ref().to_string(),
+            }),
+        }
+    }
+}
+
+impl From<Error<Infallible>> for FatError {
+    fn from(error: Error<Infallible>) -> Self {
+        FatError::OneWireError { error }
+    }
+}
+impl From<littlefs2_core::Error> for FatError {
+    fn from(value: littlefs2_core::Error) -> Self {
+        FatError::LittleFSError { error: value }
+    }
+}
+
+impl From<PathError> for FatError {
+    fn from(value: PathError) -> Self {
+        FatError::PathError { error: value }
+    }
+}
+
+impl From<TryLockError> for FatError {
+    fn from(value: TryLockError) -> Self {
+        FatError::TryLockError { error: value }
+    }
+}
+
+impl From<WifiError> for FatError {
+    fn from(value: WifiError) -> Self {
+        FatError::WifiError { error: value }
+    }
+}
+
+impl From<serde_json::error::Error> for FatError {
+    fn from(value: serde_json::Error) -> Self {
+        FatError::SerdeError { error: value }
+    }
+}
+
+impl From<SpawnError> for FatError {
+    fn from(value: SpawnError) -> Self {
+        FatError::SpawnError { error: value }
+    }
+}
+
+impl From<esp_bootloader_esp_idf::partitions::Error> for FatError {
+    fn from(value: esp_bootloader_esp_idf::partitions::Error) -> Self {
+        FatError::PartitionError { error: value }
+    }
+}
+
+impl From<Utf8Error> for FatError {
+    fn from(value: Utf8Error) -> Self {
+        FatError::String {
+            error: value.to_string(),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<edge_http::io::Error<E>> for FatError {
+    fn from(value: edge_http::io::Error<E>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<ds323x::Error<E>> for FatError {
+    fn from(value: ds323x::Error<E>) -> Self {
+        FatError::DS323 {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<eeprom24x::Error<E>> for FatError {
+    fn from(value: eeprom24x::Error<E>) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<ExpanderError<I2cDeviceError<E>>> for FatError {
+    fn from(value: ExpanderError<I2cDeviceError<E>>) -> Self {
+        FatError::ExpanderError {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<bincode::error::DecodeError> for FatError {
+    fn from(value: bincode::error::DecodeError) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<bincode::error::EncodeError> for FatError {
+    fn from(value: bincode::error::EncodeError) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<ConfigError> for FatError {
+    fn from(value: ConfigError) -> Self {
+        FatError::I2CConfigError { error: value }
+    }
+}
+
+impl<E: core::fmt::Debug> From<I2cDeviceError<E>> for FatError {
+    fn from(value: I2cDeviceError<E>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<BusVoltageReadError<I2cDeviceError<E>>> for FatError {
+    fn from(value: BusVoltageReadError<I2cDeviceError<E>>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+impl<E: core::fmt::Debug> From<ShuntVoltageReadError<I2cDeviceError<E>>> for FatError {
+    fn from(value: ShuntVoltageReadError<I2cDeviceError<E>>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<Infallible> for FatError {
+    fn from(value: Infallible) -> Self {
+        panic!("Infallible error: {:?}", value)
+    }
+}
+
+impl From<InvalidLowLimit> for FatError {
+    fn from(value: InvalidLowLimit) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+impl From<InvalidHighLimit> for FatError {
+    fn from(value: InvalidHighLimit) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<nb::Error<EspTwaiError>> for FatError {
+    fn from(value: nb::Error<EspTwaiError>) -> Self {
+        match value {
+            nb::Error::Other(can_error) => FatError::CanBusError { error: can_error },
+            nb::Error::WouldBlock => FatError::String {
+                error: "Would block".to_string(),
+            },
+        }
+    }
+}
+
+impl From<NorFlashErrorKind> for FatError {
+    fn from(value: NorFlashErrorKind) -> Self {
+        FatError::String {
+            error: value.to_string(),
+        }
+    }
+}
+
+impl From<sntpc::Error> for FatError {
+    fn from(value: sntpc::Error) -> Self {
+        FatError::SNTPError { error: value }
+    }
+}