FC43 Frame Writer and Improvements

ffi/rodbus-ffi/src/helpers/conversions.rs

@@ -40,6 +40,7 @@ impl From<rodbus::RequestError> for ffi::RequestError {
             rodbus::RequestError::Exception(ex) => ex.into(),
             rodbus::RequestError::Io(_) => ffi::RequestError::IoError,
             rodbus::RequestError::BadResponse(_) => ffi::RequestError::BadResponse,
+            rodbus::RequestError::FrameRecorderNotEmpty => ffi::RequestError::InternalError,
         }
     }
 }

rodbus/examples/server.rs

@@ -138,8 +138,14 @@ impl RequestHandler for SimpleHandler {
         mei_code: MeiCode,
         read_dev_id: ReadDeviceCode,
         object_id: Option<u8>,
-    ) -> Result<DeviceInfo, ExceptionCode> {
-        let mut device_info = DeviceInfo::new(
+    ) -> Result<ServerDeviceInfo, ExceptionCode> {
+        let server = ServerDeviceInfo {
+            read_device_code: read_dev_id,
+            conformity_level: DeviceConformityLevel::ExtendedIdentificationIndividual,
+            next_object_id: None,
+            object_data: &[0x00,0x04,0x41,0x41,0x41,0x41],
+        };
+        /*let mut device_info = DeviceInfo::new(
             mei_code,
             read_dev_id,
             DeviceConformityLevel::ExtendedIdentificationIndividual,
@@ -170,7 +176,7 @@ impl RequestHandler for SimpleHandler {
                 message.as_bytes(),
             )];
 
-            return Ok(device_info);
+            return Ok(server);
         } else {
             device_info.number_objects = response_data.len() as u8;
             device_info.storage = vec![];
@@ -184,9 +190,9 @@ impl RequestHandler for SimpleHandler {
                 );
                 device_info.storage.push(obj);
             }
-        }
+        }*/
 
-        Ok(device_info)
+        Ok(server)
     }
 
     fn wrap(self) -> std::sync::Arc<std::sync::Mutex<Box<Self>>>

rodbus/src/client/message.rs

@@ -14,6 +14,7 @@ use crate::client::requests::write_single::SingleWrite;
 use crate::common::traits::Serialize;
 use crate::types::{Indexed, UnitId};
 
+use crate::common::frame::FrameRecords;
 use scursor::{ReadCursor, WriteCursor};
 use std::time::Duration;
 
@@ -174,7 +175,11 @@ impl RequestDetails {
 }
 
 impl Serialize for RequestDetails {
-    fn serialize(&self, cursor: &mut WriteCursor) -> Result<(), RequestError> {
+    fn serialize(
+        &self,
+        cursor: &mut WriteCursor,
+        _: Option<&mut FrameRecords>,
+    ) -> Result<(), RequestError> {
         match self {
             RequestDetails::ReadCoils(x) => x.serialize(cursor),
             RequestDetails::ReadDiscreteInputs(x) => x.serialize(cursor),

rodbus/src/client/requests/read_bits.rs

@@ -72,7 +72,7 @@ impl ReadBits {
     }
 
     pub(crate) fn serialize(&self, cursor: &mut WriteCursor) -> Result<(), RequestError> {
-        self.request.get().serialize(cursor)
+        self.request.get().serialize(cursor, None)
     }
 
     pub(crate) fn failure(&mut self, err: RequestError) {

rodbus/src/client/requests/read_device_identification.rs

@@ -62,7 +62,7 @@ impl ReadDevice {
     }
 
     pub(crate) fn serialize(&self, cursor: &mut WriteCursor) -> Result<(), RequestError> {
-        self.request.serialize(cursor)
+        self.request.serialize(cursor, None)
     }
 
     pub(crate) fn channel(

rodbus/src/client/requests/read_registers.rs

@@ -75,7 +75,7 @@ impl ReadRegisters {
     }
 
     pub(crate) fn serialize(&self, cursor: &mut WriteCursor) -> Result<(), RequestError> {
-        self.request.get().serialize(cursor)
+        self.request.get().serialize(cursor, None)
     }
 
     pub(crate) fn failure(&mut self, err: RequestError) {

rodbus/src/client/requests/write_multiple.rs

@@ -95,7 +95,7 @@ where
     }
 
     pub(crate) fn serialize(&self, cursor: &mut WriteCursor) -> Result<(), RequestError> {
-        self.request.serialize(cursor)
+        self.request.serialize(cursor, None)
     }
 
     pub(crate) fn failure(&mut self, err: RequestError) {

rodbus/src/common/frame.rs

@@ -1,4 +1,5 @@
 use crate::common::phys::PhysLayer;
+use std::collections::HashMap;
 use std::ops::Range;
 
 use crate::common::buffer::ReadBuffer;
@@ -7,7 +8,7 @@ use crate::common::traits::{Loggable, LoggableDisplay, Serialize};
 use crate::error::RequestError;
 use crate::tcp::frame::{MbapDisplay, MbapHeader, MbapParser};
 use crate::types::UnitId;
-use crate::{DecodeLevel, ExceptionCode, FrameDecodeLevel};
+use crate::{DecodeLevel, ExceptionCode, FrameDecodeLevel, RecorderError};
 
 use scursor::WriteCursor;
 
@@ -251,6 +252,11 @@ impl FormatType {
     }
 }
 
+pub(crate) struct FrameRecords {
+    records: HashMap<&'static str, usize>,
+    //records: HashSet<usize>,
+}
+
 pub(crate) struct FrameWriter {
     format_type: FormatType,
     buffer: [u8; constants::MAX_FRAME_LENGTH],
@@ -280,6 +286,60 @@ impl std::fmt::Display for FunctionField {
     }
 }
 
+impl FrameRecords {
+    pub(crate) fn new() -> Self {
+        Self {
+            records: HashMap::new(),
+            //records: HashSet::new(),
+        }
+    }
+
+    ///Record a offset to fill in the value at a later point, but before it's send.
+    /// NOTE: Currently only works with byte values.
+    pub(crate) fn record(
+        &mut self,
+        key: &'static str,
+        cursor: &mut WriteCursor,
+    ) -> Result<(), crate::InternalError> {
+        if self.records.contains_key(key) {
+            return Err(RecorderError::RecordKeyExists(key).into());
+        }
+
+        //Insert our new key and advance the cursor position to the next byte.
+        self.records.insert(key, cursor.position());
+        cursor.skip(1).unwrap();
+
+        Ok(())
+    }
+
+    ///Tries to fill in the value at the recorded offset, returns an error if there is no corresponding
+    /// record found
+    pub(crate) fn fill_record(
+        &mut self,
+        cursor: &mut WriteCursor,
+        key: &'static str,
+        value: u8,
+    ) -> Result<(), crate::InternalError> {
+        if let Some(position) = self.records.remove(key) {
+            let current_position = cursor.position();
+
+            //TODO(Kay): Handle possible errors of the cursor !
+            cursor.seek_to(position)?;
+            cursor.write_u8(value)?;
+            cursor.seek_to(current_position)?;
+
+            return Ok(());
+        }
+
+        Err(RecorderError::RecordDoesNotExist(key).into())
+    }
+
+    ///Return true if there are no recorded offsets in our store.
+    pub(crate) fn records_empty(&self) -> bool {
+        self.records.is_empty()
+    }
+}
+
 impl FunctionField {
     pub(crate) fn unknown(fc: u8) -> Self {
         Self::UnknownFunction(fc)