add typed read/write helpers for common CIP scalar types

Author: JaskRendix

src/cip/error.rs

@@ -8,6 +8,10 @@ pub enum CipError {
     PathSegmentError,
     PathDestinationUnknown,
     VendorSpecific(u8),
+    TypeMismatch {
+        expected: &'static str,
+        actual: &'static str,
+    },
 }
 
 impl From<u8> for CipError {
@@ -37,6 +41,10 @@ impl fmt::Display for CipError {
             CipError::PathDestinationUnknown => write!(f, "Path destination unknown (0x06)"),
 
             CipError::VendorSpecific(code) => write!(f, "Vendor-specific CIP error 0x{:02X}", code),
+
+            CipError::TypeMismatch { expected, actual } => {
+                write!(f, "Type mismatch: expected {expected}, got {actual}")
+            }
         }
     }
 }

src/client.rs

@@ -661,4 +661,89 @@ impl EthernetIpClient {
 
         Ok(())
     }
+
+    pub async fn read_dint(&mut self, tag: &str) -> Result<i32, CipError> {
+        match self.read_tag(tag).await? {
+            CipValue::DInt(v) => Ok(v),
+            other => Err(CipError::TypeMismatch {
+                expected: "DINT",
+                actual: other.type_name(),
+            }),
+        }
+    }
+
+    pub async fn read_bool(&mut self, tag: &str) -> Result<bool, CipError> {
+        match self.read_tag(tag).await? {
+            CipValue::Bool(v) => Ok(v),
+            other => Err(CipError::TypeMismatch {
+                expected: "BOOL",
+                actual: other.type_name(),
+            }),
+        }
+    }
+
+    pub async fn read_real(&mut self, tag: &str) -> Result<f32, CipError> {
+        match self.read_tag(tag).await? {
+            CipValue::Real(v) => Ok(v),
+            other => Err(CipError::TypeMismatch {
+                expected: "REAL",
+                actual: other.type_name(),
+            }),
+        }
+    }
+
+    pub async fn read_string(&mut self, tag: &str) -> Result<String, CipError> {
+        match self.read_tag(tag).await? {
+            CipValue::String(s) => Ok(s),
+            other => Err(CipError::TypeMismatch {
+                expected: "STRING",
+                actual: other.type_name(),
+            }),
+        }
+    }
+
+    pub async fn write_dint(&mut self, tag: &str, value: i32) -> Result<(), CipError> {
+        self.write_tag(tag, CipValue::DInt(value)).await
+    }
+
+    pub async fn read_int(&mut self, tag: &str) -> Result<i16, CipError> {
+        match self.read_tag(tag).await? {
+            CipValue::Int(v) => Ok(v),
+            other => Err(CipError::TypeMismatch {
+                expected: "INT",
+                actual: other.type_name(),
+            }),
+        }
+    }
+
+    pub async fn read_sint(&mut self, tag: &str) -> Result<i8, CipError> {
+        match self.read_tag(tag).await? {
+            CipValue::SInt(v) => Ok(v),
+            other => Err(CipError::TypeMismatch {
+                expected: "SINT",
+                actual: other.type_name(),
+            }),
+        }
+    }
+
+    pub async fn write_bool(&mut self, tag: &str, value: bool) -> Result<(), CipError> {
+        self.write_tag(tag, CipValue::Bool(value)).await
+    }
+
+    pub async fn write_real(&mut self, tag: &str, value: f32) -> Result<(), CipError> {
+        self.write_tag(tag, CipValue::Real(value)).await
+    }
+
+    pub async fn write_string(&mut self, tag: &str, value: &str) -> Result<(), CipError> {
+        self.write_tag(tag, CipValue::String(value.to_string()))
+            .await
+    }
+
+    pub async fn write_int(&mut self, tag: &str, value: i16) -> Result<(), CipError> {
+        self.write_tag(tag, CipValue::Int(value)).await
+    }
+
+    pub async fn write_sint(&mut self, tag: &str, value: i8) -> Result<(), CipError> {
+        self.write_tag(tag, CipValue::SInt(value)).await
+    }
 }

src/types.rs

@@ -53,6 +53,22 @@ pub enum CipValue {
     Unit,
 }
 
+impl CipValue {
+    pub fn type_name(&self) -> &'static str {
+        match self {
+            CipValue::Bool(_) => "BOOL",
+            CipValue::SInt(_) => "SINT",
+            CipValue::Int(_) => "INT",
+            CipValue::DInt(_) => "DINT",
+            CipValue::LInt(_) => "LINT",
+            CipValue::Real(_) => "REAL",
+            CipValue::String(_) => "STRING",
+            CipValue::BoolPacked(_) => "BOOL_PACKED",
+            CipValue::Unit => "UNIT",
+        }
+    }
+}
+
 /// Result type used by CIP Multiple Service Packet (MSP) responses.
 ///
 /// - `Ok(T)` contains a successfully decoded CIP value.

tests/error_handling.rs

@@ -1,4 +1,5 @@
 use ethernetip::cip::CipError;
+use ethernetip::types::CipValue;
 
 #[test]
 fn map_status_codes() {
@@ -13,3 +14,55 @@ fn map_status_codes() {
         CipError::VendorSpecific(0xAB)
     ));
 }
+
+#[test]
+fn type_mismatch_error_formats_correctly() {
+    let err = CipError::TypeMismatch {
+        expected: "DINT",
+        actual: "REAL",
+    };
+
+    let msg = format!("{err}");
+    assert_eq!(msg, "Type mismatch: expected DINT, got REAL");
+}
+
+#[test]
+fn cip_error_display_variants() {
+    assert_eq!(
+        format!("{}", CipError::ConnectionFailure),
+        "Connection failure (0x01)"
+    );
+    assert_eq!(
+        format!("{}", CipError::ResourceUnavailable),
+        "Resource unavailable (0x02)"
+    );
+    assert_eq!(
+        format!("{}", CipError::InvalidAttribute),
+        "Invalid attribute (0x04)"
+    );
+    assert_eq!(
+        format!("{}", CipError::PathSegmentError),
+        "Path segment error (0x05)"
+    );
+    assert_eq!(
+        format!("{}", CipError::PathDestinationUnknown),
+        "Path destination unknown (0x06)"
+    );
+    assert_eq!(
+        format!("{}", CipError::VendorSpecific(0xFF)),
+        "Vendor-specific CIP error 0xFF"
+    );
+}
+
+#[test]
+fn cip_value_type_name() {
+    assert_eq!(CipValue::Bool(true).type_name(), "BOOL");
+    assert_eq!(CipValue::SInt(1).type_name(), "SINT");
+    assert_eq!(CipValue::Int(1).type_name(), "INT");
+    assert_eq!(CipValue::DInt(1).type_name(), "DINT");
+    assert_eq!(CipValue::LInt(1).type_name(), "LINT");
+    assert_eq!(CipValue::Real(1.0).type_name(), "REAL");
+    assert_eq!(CipValue::String("x".into()).type_name(), "STRING");
+    assert_eq!(CipValue::BoolPacked(vec![1]).type_name(), "BOOL_PACKED");
+    assert_eq!(CipValue::Unit.type_name(), "UNIT");
+}