reduce .unwrap() usage

control-core/src/identification/mod.rs

@@ -187,20 +187,36 @@ pub async fn machine_device_identification<'maindevice>(
             vendor: subdevice
                 .eeprom_read::<u16>(maindevice, addresses.vendor_word)
                 .await
-                .unwrap(),
+                .or(Err(anyhow!(
+                    "[{}::machine_device_identification] Failed to read vendor from EEPROM for device {}",
+                    module_path!(),
+                    subdevice.name()
+                )))?,
             serial: subdevice
                 .eeprom_read::<u16>(maindevice, addresses.serial_word)
                 .await
-                .unwrap(),
+                .or(Err(anyhow!(
+                    "[{}::machine_device_identification] Failed to read serial from EEPROM for device {}",
+                    module_path!(),
+                    subdevice.name()
+                )))?,
             machine: subdevice
                 .eeprom_read::<u16>(maindevice, addresses.machine_word)
                 .await
-                .unwrap(),
+                .or(Err(anyhow!(
+                    "[{}::machine_device_identification] Failed to read machine from EEPROM for device {}",
+                    module_path!(),
+                    subdevice.name()
+                )))?,
         },
         role: subdevice
             .eeprom_read::<u16>(maindevice, addresses.role_word)
             .await
-            .unwrap(),
+            .or(Err(anyhow!(
+                "[{}::machine_device_identification] Failed to read role from EEPROM for device {}",
+                module_path!(),
+                subdevice.name()
+            )))?,
         subdevice_index: subdevice_index,
     };
 

control-core/src/machines/new.rs

@@ -32,7 +32,12 @@ pub fn validate_same_machine_identification(
 ) -> Result<(), Error> {
     let machine_identification_unique = &identified_device_group
         .first()
-        .unwrap()
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "[{}::validate_same_machine_identification] No devices in group",
+                module_path!()
+            )
+        })?
         .machine_identification_unique;
     for device in identified_device_group.iter() {
         if device.machine_identification_unique != *machine_identification_unique {

control-core/src/rest/mutation.rs

@@ -1,4 +1,3 @@
-use axum::body::Body;
 use serde::Serialize;
 
 use crate::identification::MachineIdentificationUnique;
@@ -24,13 +23,6 @@ impl MutationResponse {
     }
 }
 
-impl From<MutationResponse> for Body {
-    fn from(mutation_response: MutationResponse) -> Self {
-        let body = serde_json::to_string(&mutation_response).unwrap();
-        Body::from(body)
-    }
-}
-
 #[derive(Debug, serde::Deserialize)]
 pub struct MachineMutationBody<T> {
     pub machine_identification_unique: MachineIdentificationUnique,

control-core/src/socketio/event.rs

@@ -20,29 +20,33 @@ where
     pub ts: i64,
 }
 
-impl<T> From<Event<T>> for GenericEvent
+impl<T> TryFrom<Event<T>> for GenericEvent
 where
     T: Serialize,
 {
-    fn from(event: Event<T>) -> Self {
-        Self {
+    type Error = serde_json::Error;
+
+    fn try_from(event: Event<T>) -> Result<Self, Self::Error> {
+        Ok(Self {
             name: event.name,
-            data: serde_json::to_value(event.data).unwrap(),
+            data: serde_json::to_value(event.data)?,
             ts: event.ts,
-        }
+        })
     }
 }
 
-impl<T> From<&Event<T>> for GenericEvent
+impl<T> TryFrom<&Event<T>> for GenericEvent
 where
     T: Serialize,
 {
-    fn from(event: &Event<T>) -> Self {
-        Self {
+    type Error = serde_json::Error;
+
+    fn try_from(event: &Event<T>) -> Result<Self, Self::Error> {
+        Ok(Self {
             name: event.name.clone(),
-            data: serde_json::to_value(&event.data).unwrap(),
+            data: serde_json::to_value(&event.data)?,
             ts: event.ts,
-        }
+        })
     }
 }
 

control-core/src/socketio/namespace.rs

@@ -147,7 +147,7 @@ where
 }
 
 pub trait CacheableEvents<Events> {
-    fn event_value(&self) -> GenericEvent;
+    fn event_value(&self) -> Result<GenericEvent, serde_json::Error>;
     fn event_cache_fn(&self) -> CacheFn;
 }
 

docs/io.md

@@ -42,17 +42,19 @@ The `digital_output_state` is used to read the current state of the output of a
 ```rust
 impl DigitalOutputDevice<EL2002Port> for EL2002 {
     fn digital_output_write(&mut self, port: EL2002Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
         match port {
-            EL2002Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(),
-            EL2002Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(),
+            EL2002Port::DO1 => self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into(),
+            EL2002Port::DO2 => self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into(),
         }
     }
 
     fn digital_output_state(&self, port: EL2002Port) -> DigitalOutputState {
+        let expect_text = "All channels should be Some(_)";
         DigitalOutputState {
             output: DigitalOutputOutput(match port {
-                EL2002Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value,
-                EL2002Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value,
+                EL2002Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value,
+                EL2002Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value,
             }),
         }
     }

ethercat-hal/src/devices/el1008.rs

@@ -28,17 +28,18 @@ impl NewDevice for EL1008 {
 
 impl DigitalInputDevice<EL1008Port> for EL1008 {
     fn digital_input_state(&self, port: EL1008Port) -> DigitalInputState {
+        let expect_text = "All channels should be Some(_)";
         DigitalInputState {
             input: DigitalInputInput {
                 value: match port {
-                    EL1008Port::DI1 => self.txpdo.channel1.as_ref().unwrap().value,
-                    EL1008Port::DI2 => self.txpdo.channel2.as_ref().unwrap().value,
-                    EL1008Port::DI3 => self.txpdo.channel3.as_ref().unwrap().value,
-                    EL1008Port::DI4 => self.txpdo.channel4.as_ref().unwrap().value,
-                    EL1008Port::DI5 => self.txpdo.channel5.as_ref().unwrap().value,
-                    EL1008Port::DI6 => self.txpdo.channel6.as_ref().unwrap().value,
-                    EL1008Port::DI7 => self.txpdo.channel7.as_ref().unwrap().value,
-                    EL1008Port::DI8 => self.txpdo.channel8.as_ref().unwrap().value,
+                    EL1008Port::DI1 => self.txpdo.channel1.as_ref().expect(&expect_text).value,
+                    EL1008Port::DI2 => self.txpdo.channel2.as_ref().expect(&expect_text).value,
+                    EL1008Port::DI3 => self.txpdo.channel3.as_ref().expect(&expect_text).value,
+                    EL1008Port::DI4 => self.txpdo.channel4.as_ref().expect(&expect_text).value,
+                    EL1008Port::DI5 => self.txpdo.channel5.as_ref().expect(&expect_text).value,
+                    EL1008Port::DI6 => self.txpdo.channel6.as_ref().expect(&expect_text).value,
+                    EL1008Port::DI7 => self.txpdo.channel7.as_ref().expect(&expect_text).value,
+                    EL1008Port::DI8 => self.txpdo.channel8.as_ref().expect(&expect_text).value,
                 },
             },
         }

ethercat-hal/src/devices/el2002.rs

@@ -28,17 +28,23 @@ impl NewDevice for EL2002 {
 
 impl DigitalOutputDevice<EL2002Port> for EL2002 {
     fn digital_output_write(&mut self, port: EL2002Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
         match port {
-            EL2002Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(),
-            EL2002Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(),
+            EL2002Port::DO1 => {
+                self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2002Port::DO2 => {
+                self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into()
+            }
         }
     }
 
     fn digital_output_state(&self, port: EL2002Port) -> DigitalOutputState {
+        let expect_text = "All channels should be Some(_)";
         DigitalOutputState {
             output: DigitalOutputOutput(match port {
-                EL2002Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value,
-                EL2002Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value,
+                EL2002Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value,
+                EL2002Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value,
             }),
         }
     }

ethercat-hal/src/devices/el2008.rs

@@ -28,29 +28,47 @@ impl NewDevice for EL2008 {
 
 impl DigitalOutputDevice<EL2008Port> for EL2008 {
     fn digital_output_write(&mut self, port: EL2008Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
         match port {
-            EL2008Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(),
-            EL2008Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(),
-            EL2008Port::DO3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(),
-            EL2008Port::DO4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(),
-            EL2008Port::DO5 => self.rxpdo.channel5.as_mut().unwrap().value = value.into(),
-            EL2008Port::DO6 => self.rxpdo.channel6.as_mut().unwrap().value = value.into(),
-            EL2008Port::DO7 => self.rxpdo.channel7.as_mut().unwrap().value = value.into(),
-            EL2008Port::DO8 => self.rxpdo.channel8.as_mut().unwrap().value = value.into(),
+            EL2008Port::DO1 => {
+                self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2008Port::DO2 => {
+                self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2008Port::DO3 => {
+                self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2008Port::DO4 => {
+                self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2008Port::DO5 => {
+                self.rxpdo.channel5.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2008Port::DO6 => {
+                self.rxpdo.channel6.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2008Port::DO7 => {
+                self.rxpdo.channel7.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2008Port::DO8 => {
+                self.rxpdo.channel8.as_mut().expect(&expect_text).value = value.into()
+            }
         }
     }
 
     fn digital_output_state(&self, port: EL2008Port) -> DigitalOutputState {
+        let expect_text = "All channels should be Some(_)";
         DigitalOutputState {
             output: DigitalOutputOutput(match port {
-                EL2008Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value,
-                EL2008Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value,
-                EL2008Port::DO3 => self.rxpdo.channel3.as_ref().unwrap().value,
-                EL2008Port::DO4 => self.rxpdo.channel4.as_ref().unwrap().value,
-                EL2008Port::DO5 => self.rxpdo.channel5.as_ref().unwrap().value,
-                EL2008Port::DO6 => self.rxpdo.channel6.as_ref().unwrap().value,
-                EL2008Port::DO7 => self.rxpdo.channel7.as_ref().unwrap().value,
-                EL2008Port::DO8 => self.rxpdo.channel8.as_ref().unwrap().value,
+                EL2008Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value,
+                EL2008Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value,
+                EL2008Port::DO3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value,
+                EL2008Port::DO4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value,
+                EL2008Port::DO5 => self.rxpdo.channel5.as_ref().expect(&expect_text).value,
+                EL2008Port::DO6 => self.rxpdo.channel6.as_ref().expect(&expect_text).value,
+                EL2008Port::DO7 => self.rxpdo.channel7.as_ref().expect(&expect_text).value,
+                EL2008Port::DO8 => self.rxpdo.channel8.as_ref().expect(&expect_text).value,
             }),
         }
     }

ethercat-hal/src/devices/el2024.rs

@@ -29,21 +29,31 @@ impl NewDevice for EL2024 {
 
 impl DigitalOutputDevice<EL2024Port> for EL2024 {
     fn digital_output_write(&mut self, port: EL2024Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
         match port {
-            EL2024Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(),
-            EL2024Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(),
-            EL2024Port::DO3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(),
-            EL2024Port::DO4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(),
+            EL2024Port::DO1 => {
+                self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2024Port::DO2 => {
+                self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2024Port::DO3 => {
+                self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2024Port::DO4 => {
+                self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into()
+            }
         }
     }
 
     fn digital_output_state(&self, port: EL2024Port) -> DigitalOutputState {
+        let expect_text = "All channels should be Some(_)";
         DigitalOutputState {
             output: DigitalOutputOutput(match port {
-                EL2024Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value,
-                EL2024Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value,
-                EL2024Port::DO3 => self.rxpdo.channel3.as_ref().unwrap().value,
-                EL2024Port::DO4 => self.rxpdo.channel4.as_ref().unwrap().value,
+                EL2024Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value,
+                EL2024Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value,
+                EL2024Port::DO3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value,
+                EL2024Port::DO4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value,
             }),
         }
     }

ethercat-hal/src/devices/el2634.rs

@@ -29,21 +29,31 @@ impl NewDevice for EL2634 {
 
 impl DigitalOutputDevice<EL2634Port> for EL2634 {
     fn digital_output_write(&mut self, port: EL2634Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
         match port {
-            EL2634Port::R1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(),
-            EL2634Port::R2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(),
-            EL2634Port::R3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(),
-            EL2634Port::R4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(),
+            EL2634Port::R1 => {
+                self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2634Port::R2 => {
+                self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2634Port::R3 => {
+                self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2634Port::R4 => {
+                self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into()
+            }
         }
     }
 
     fn digital_output_state(&self, port: EL2634Port) -> DigitalOutputState {
+        let expect_text = "All channels should be Some(_)";
         DigitalOutputState {
             output: DigitalOutputOutput(match port {
-                EL2634Port::R1 => self.rxpdo.channel1.as_ref().unwrap().value,
-                EL2634Port::R2 => self.rxpdo.channel2.as_ref().unwrap().value,
-                EL2634Port::R3 => self.rxpdo.channel3.as_ref().unwrap().value,
-                EL2634Port::R4 => self.rxpdo.channel4.as_ref().unwrap().value,
+                EL2634Port::R1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value,
+                EL2634Port::R2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value,
+                EL2634Port::R3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value,
+                EL2634Port::R4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value,
             }),
         }
     }

ethercat-hal/src/devices/el2809.rs

@@ -29,45 +29,79 @@ impl NewDevice for EL2809 {
 
 impl DigitalOutputDevice<EL2809Port> for EL2809 {
     fn digital_output_write(&mut self, port: EL2809Port, value: DigitalOutputOutput) {
+        let expect_text = "All channels should be Some(_)";
         match port {
-            EL2809Port::DO1 => self.rxpdo.channel1.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO2 => self.rxpdo.channel2.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO3 => self.rxpdo.channel3.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO4 => self.rxpdo.channel4.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO5 => self.rxpdo.channel5.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO6 => self.rxpdo.channel6.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO7 => self.rxpdo.channel7.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO8 => self.rxpdo.channel8.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO9 => self.rxpdo.channel9.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO10 => self.rxpdo.channel10.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO11 => self.rxpdo.channel11.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO12 => self.rxpdo.channel12.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO13 => self.rxpdo.channel13.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO14 => self.rxpdo.channel14.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO15 => self.rxpdo.channel15.as_mut().unwrap().value = value.into(),
-            EL2809Port::DO16 => self.rxpdo.channel16.as_mut().unwrap().value = value.into(),
+            EL2809Port::DO1 => {
+                self.rxpdo.channel1.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO2 => {
+                self.rxpdo.channel2.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO3 => {
+                self.rxpdo.channel3.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO4 => {
+                self.rxpdo.channel4.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO5 => {
+                self.rxpdo.channel5.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO6 => {
+                self.rxpdo.channel6.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO7 => {
+                self.rxpdo.channel7.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO8 => {
+                self.rxpdo.channel8.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO9 => {
+                self.rxpdo.channel9.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO10 => {
+                self.rxpdo.channel10.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO11 => {
+                self.rxpdo.channel11.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO12 => {
+                self.rxpdo.channel12.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO13 => {
+                self.rxpdo.channel13.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO14 => {
+                self.rxpdo.channel14.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO15 => {
+                self.rxpdo.channel15.as_mut().expect(&expect_text).value = value.into()
+            }
+            EL2809Port::DO16 => {
+                self.rxpdo.channel16.as_mut().expect(&expect_text).value = value.into()
+            }
         }
     }
 
     fn digital_output_state(&self, port: EL2809Port) -> DigitalOutputState {
+        let expect_text = "All channels should be Some(_)";
         DigitalOutputState {
             output: DigitalOutputOutput(match port {
-                EL2809Port::DO1 => self.rxpdo.channel1.as_ref().unwrap().value,
-                EL2809Port::DO2 => self.rxpdo.channel2.as_ref().unwrap().value,
-                EL2809Port::DO3 => self.rxpdo.channel3.as_ref().unwrap().value,
-                EL2809Port::DO4 => self.rxpdo.channel4.as_ref().unwrap().value,
-                EL2809Port::DO5 => self.rxpdo.channel5.as_ref().unwrap().value,
-                EL2809Port::DO6 => self.rxpdo.channel6.as_ref().unwrap().value,
-                EL2809Port::DO7 => self.rxpdo.channel7.as_ref().unwrap().value,
-                EL2809Port::DO8 => self.rxpdo.channel8.as_ref().unwrap().value,
-                EL2809Port::DO9 => self.rxpdo.channel9.as_ref().unwrap().value,
-                EL2809Port::DO10 => self.rxpdo.channel10.as_ref().unwrap().value,
-                EL2809Port::DO11 => self.rxpdo.channel11.as_ref().unwrap().value,
-                EL2809Port::DO12 => self.rxpdo.channel12.as_ref().unwrap().value,
-                EL2809Port::DO13 => self.rxpdo.channel13.as_ref().unwrap().value,
-                EL2809Port::DO14 => self.rxpdo.channel14.as_ref().unwrap().value,
-                EL2809Port::DO15 => self.rxpdo.channel15.as_ref().unwrap().value,
-                EL2809Port::DO16 => self.rxpdo.channel16.as_ref().unwrap().value,
+                EL2809Port::DO1 => self.rxpdo.channel1.as_ref().expect(&expect_text).value,
+                EL2809Port::DO2 => self.rxpdo.channel2.as_ref().expect(&expect_text).value,
+                EL2809Port::DO3 => self.rxpdo.channel3.as_ref().expect(&expect_text).value,
+                EL2809Port::DO4 => self.rxpdo.channel4.as_ref().expect(&expect_text).value,
+                EL2809Port::DO5 => self.rxpdo.channel5.as_ref().expect(&expect_text).value,
+                EL2809Port::DO6 => self.rxpdo.channel6.as_ref().expect(&expect_text).value,
+                EL2809Port::DO7 => self.rxpdo.channel7.as_ref().expect(&expect_text).value,
+                EL2809Port::DO8 => self.rxpdo.channel8.as_ref().expect(&expect_text).value,
+                EL2809Port::DO9 => self.rxpdo.channel9.as_ref().expect(&expect_text).value,
+                EL2809Port::DO10 => self.rxpdo.channel10.as_ref().expect(&expect_text).value,
+                EL2809Port::DO11 => self.rxpdo.channel11.as_ref().expect(&expect_text).value,
+                EL2809Port::DO12 => self.rxpdo.channel12.as_ref().expect(&expect_text).value,
+                EL2809Port::DO13 => self.rxpdo.channel13.as_ref().expect(&expect_text).value,
+                EL2809Port::DO14 => self.rxpdo.channel14.as_ref().expect(&expect_text).value,
+                EL2809Port::DO15 => self.rxpdo.channel15.as_ref().expect(&expect_text).value,
+                EL2809Port::DO16 => self.rxpdo.channel16.as_ref().expect(&expect_text).value,
             }),
         }
     }

ethercat-hal/src/devices/el3204.rs

@@ -32,11 +32,12 @@ impl NewDevice for EL3204 {
 
 impl TemperatureInputDevice<EL3204Port> for EL3204 {
     fn temperature_input_state(&self, port: EL3204Port) -> TemperatureInputState {
+        let expect_text = "All channels should be Some(_)";
         let channel = match port {
-            EL3204Port::T1 => self.txpdo.channel1.as_ref().unwrap(),
-            EL3204Port::T2 => self.txpdo.channel2.as_ref().unwrap(),
-            EL3204Port::T3 => self.txpdo.channel3.as_ref().unwrap(),
-            EL3204Port::T4 => self.txpdo.channel4.as_ref().unwrap(),
+            EL3204Port::T1 => self.txpdo.channel1.as_ref().expect(&expect_text),
+            EL3204Port::T2 => self.txpdo.channel2.as_ref().expect(&expect_text),
+            EL3204Port::T3 => self.txpdo.channel3.as_ref().expect(&expect_text),
+            EL3204Port::T4 => self.txpdo.channel4.as_ref().expect(&expect_text),
         };
         TemperatureInputState {
             input: TemperatureInputInput {

server/src/ethercat/loop.rs

@@ -105,7 +105,7 @@ pub async fn setup_loop(
         machines.insert(
             identified_device_group
                 .first()
-                .unwrap()
+                .expect("There should always be a first device")
                 .machine_identification_unique
                 .clone(),
             machine,

server/src/machines/winder2/api.rs

@@ -272,7 +272,17 @@ pub struct Winder1Namespace(Namespace);
 
 impl NamespaceCacheingLogic<Winder1Events> for Winder1Namespace {
     fn emit_cached(&mut self, events: Winder1Events) {
-        let event = events.event_value();
+        let event = match events.event_value() {
+            Ok(event) => event,
+            Err(err) => {
+                log::error!(
+                    "[{}::emit_cached] Failed to event.event_value(): {:?}",
+                    module_path!(),
+                    err
+                );
+                return;
+            }
+        };
         let buffer_fn = events.event_cache_fn();
         self.0.emit_cached(&event, buffer_fn);
     }
@@ -285,19 +295,19 @@ impl Winder1Namespace {
 }
 
 impl CacheableEvents<Winder1Events> for Winder1Events {
-    fn event_value(&self) -> GenericEvent {
+    fn event_value(&self) -> Result<GenericEvent, serde_json::Error> {
         match self {
-            Winder1Events::TraversePosition(event) => event.into(),
-            Winder1Events::TraverseState(event) => event.into(),
-            Winder1Events::PullerSpeed(event) => event.into(),
-            Winder1Events::PullerState(event) => event.into(),
-            Winder1Events::AutostopWoundedlength(event) => event.into(),
-            Winder1Events::AutostopState(event) => event.into(),
-            Winder1Events::Mode(event) => event.into(),
-            Winder1Events::SpoolRpm(event) => event.into(),
-            Winder1Events::SpoolState(event) => event.into(),
-            Winder1Events::TensionArmAngleEvent(event) => event.into(),
-            Winder1Events::TensionArmStateEvent(event) => event.into(),
+            Winder1Events::TraversePosition(event) => event.try_into(),
+            Winder1Events::TraverseState(event) => event.try_into(),
+            Winder1Events::PullerSpeed(event) => event.try_into(),
+            Winder1Events::PullerState(event) => event.try_into(),
+            Winder1Events::AutostopWoundedlength(event) => event.try_into(),
+            Winder1Events::AutostopState(event) => event.try_into(),
+            Winder1Events::Mode(event) => event.try_into(),
+            Winder1Events::SpoolRpm(event) => event.try_into(),
+            Winder1Events::SpoolState(event) => event.try_into(),
+            Winder1Events::TensionArmAngleEvent(event) => event.try_into(),
+            Winder1Events::TensionArmStateEvent(event) => event.try_into(),
         }
     }
 

server/src/machines/winder2/mod.rs

@@ -62,7 +62,7 @@ impl Winder2 {
         }
         .build();
         self.namespace
-            .emit_cached(Winder1Events::TraverseState(event));
+            .emit_cached(Winder1Events::TraverseState(event))
     }
 }
 
@@ -107,7 +107,7 @@ impl Winder2 {
             mode: self.mode.clone().into(),
         }
         .build();
-        self.namespace.emit_cached(Winder1Events::Mode(event));
+        self.namespace.emit_cached(Winder1Events::Mode(event))
     }
 }
 
@@ -131,7 +131,7 @@ impl Winder2 {
         }
         .build();
         self.namespace
-            .emit_cached(Winder1Events::TensionArmAngleEvent(event));
+            .emit_cached(Winder1Events::TensionArmAngleEvent(event))
     }
 
     fn emit_tension_arm_state(&mut self) {
@@ -140,7 +140,7 @@ impl Winder2 {
         }
         .build();
         self.namespace
-            .emit_cached(Winder1Events::TensionArmStateEvent(event));
+            .emit_cached(Winder1Events::TensionArmStateEvent(event))
     }
 }
 
@@ -162,7 +162,7 @@ impl Winder2 {
             .steps_to_angular_velocity(self.spool.get_speed() as f64)
             .get::<revolution_per_minute>();
         let event = api::SpoolRpmEvent { rpm }.build();
-        self.namespace.emit_cached(Winder1Events::SpoolRpm(event));
+        self.namespace.emit_cached(Winder1Events::SpoolRpm(event))
     }
 
     fn emit_spool_state(&mut self) {
@@ -171,7 +171,7 @@ impl Winder2 {
             speed_max: self.spool_speed_controller.get_max_speed(),
         }
         .build();
-        self.namespace.emit_cached(Winder1Events::SpoolState(event));
+        self.namespace.emit_cached(Winder1Events::SpoolState(event))
     }
 }
 

server/src/main.rs

@@ -13,7 +13,7 @@ pub mod socketio;
 fn main() {
     env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
 
-    let rt = tokio::runtime::Runtime::new().unwrap();
+    let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime");
     let socketio_layer = rt.block_on(init_socketio());
     rt.spawn(async {
         init_api(APP_STATE.clone(), socketio_layer)

server/src/rest/util.rs

@@ -8,30 +8,51 @@ pub struct ResponseUtil {}
 
 impl ResponseUtil {
     pub fn error(message: &str) -> Response<Body> {
+        let json = match serde_json::to_string(&json!({ "error": message })) {
+            Ok(json) => json,
+            Err(e) => {
+                log::error!("Failed to serialize error message: {}", e);
+                return Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(Body::empty())
+                    .unwrap();
+            }
+        };
         Response::builder()
             .status(StatusCode::INTERNAL_SERVER_ERROR)
             .header("Content-Type", "application/json")
-            .body(Body::from(
-                serde_json::to_string(&json!({ "error": message })).unwrap(),
-            ))
+            .body(Body::from(json))
             .unwrap()
     }
 
     pub fn ok<T: serde::Serialize>(data: T) -> Response<Body> {
+        let json = match serde_json::to_string(&data) {
+            Ok(json) => json,
+            Err(e) => {
+                log::error!("Failed to serialize response data: {}", e);
+                return ResponseUtil::error("Failed to serialize response data");
+            }
+        };
+
         Response::builder()
             .status(StatusCode::OK)
             .header("Content-Type", "application/json")
-            .body(Body::from(serde_json::to_string(&data).unwrap()))
+            .body(Body::from(json))
             .unwrap()
     }
 
     pub fn not_found(message: &str) -> Response<Body> {
+        let json = match serde_json::to_string(&json!({ "error": message })) {
+            Ok(json) => json,
+            Err(e) => {
+                log::error!("Failed to serialize not found message: {}", e);
+                return ResponseUtil::error("Failed to serialize not found message");
+            }
+        };
         Response::builder()
             .status(StatusCode::NOT_FOUND)
             .header("Content-Type", "application/json")
-            .body(Body::from(
-                serde_json::to_string(&json!({ "error": message })).unwrap(),
-            ))
+            .body(Body::from(json))
             .unwrap()
     }
 }

server/src/socketio/main_namespace/mod.rs

@@ -26,7 +26,17 @@ where
     fn emit_cached(&mut self, event: MainNamespaceEvents) {
         println!("Emitting event: {:?}", event);
         let buffer_fn = event.event_cache_fn();
-        let generic_event = event.event_value();
+        let generic_event = match event.event_value() {
+            Ok(event) => event,
+            Err(err) => {
+                log::error!(
+                    "[{}::emit_cached] Failed to event.event_value(): {:?}",
+                    module_path!(),
+                    err
+                );
+                return;
+            }
+        };
         self.0.emit_cached(&generic_event, buffer_fn);
     }
 }
@@ -38,10 +48,10 @@ pub enum MainNamespaceEvents {
 }
 
 impl CacheableEvents<MainNamespaceEvents> for MainNamespaceEvents {
-    fn event_value(&self) -> GenericEvent {
+    fn event_value(&self) -> Result<GenericEvent, serde_json::Error> {
         match self {
-            MainNamespaceEvents::EthercatSetupEvent(event) => event.clone().into(),
-            MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event) => event.clone().into(),
+            MainNamespaceEvents::EthercatSetupEvent(event) => event.clone().try_into(),
+            MainNamespaceEvents::EthercatInterfaceDiscoveryEvent(event) => event.clone().try_into(),
         }
     }