Merge pull request #42 from Switch2-OliverW/variable_length_data

Extend Variable Length Data parsing

Author: maebli

src/user_data/data_information.rs

@@ -14,8 +14,8 @@ impl DataInformationBlock<'_> {
     #[must_use]
     pub fn get_size(&self) -> usize {
         let mut size = 1;
-        if let Some(vife) = &self.data_information_field_extension {
-            size += vife.len();
+        if let Some(dife) = &self.data_information_field_extension {
+            size += dife.len();
         }
         size
     }
@@ -605,37 +605,66 @@ impl DataFieldCoding {
                     0x00..=0xBF => Ok(Data {
                         value: Some(DataType::Text(TextUnit::new(
                             input
-                                .get(1..(length as usize))
+                                .get(1..(1 + length as usize))
                                 .ok_or(DataRecordError::InsufficientData)?,
                         ))),
                         size: length as usize + 1,
                     }),
-                    0xC0..=0xD9 => {
+                    0xC0..=0xC9 => {
                         length -= 0xC0;
-                        let is_negative =
-                            *input.first().ok_or(DataRecordError::InsufficientData)? > 0xC9;
-                        let sign = if is_negative { -1 } else { 1 };
-                        bcd_to_value!(input, length as usize, sign)
+                        let bytes = input
+                            .get(1..(1 + length as usize))
+                            .ok_or(DataRecordError::InsufficientData)?;
+                        match bcd_to_value!(bytes, 2 * length as usize) {
+                            Ok(data) => Ok(Data {
+                                value: data.value,
+                                size: data.size + 1,
+                            }),
+                            Err(err) => Err(err),
+                        }
                     }
-                    0xE0..=0xE9 => {
+                    0xD0..=0xD9 => {
+                        length -= 0xD0;
+                        let bytes = input
+                            .get(1..(1 + length as usize))
+                            .ok_or(DataRecordError::InsufficientData)?;
+                        match bcd_to_value!(bytes, 2 * length as usize, -1) {
+                            Ok(data) => Ok(Data {
+                                value: data.value,
+                                size: data.size + 1,
+                            }),
+                            Err(err) => Err(err),
+                        }
+                    }
+                    0xE0..=0xEF => {
                         length -= 0xE0;
-                        todo!("0xE0-0xE9 not implemented for length {}", length);
+                        let bytes = input
+                            .get(1..(1 + length as usize))
+                            .ok_or(DataRecordError::InsufficientData)?;
+                        match integer_to_value!(bytes, length as usize) {
+                            Ok(data) => Ok(Data {
+                                value: data.value,
+                                size: data.size + 1,
+                            }),
+                            Err(err) => Err(err),
+                        }
                     }
                     0xF0..=0xF4 => {
-                        length -= 0xF0;
-                        todo!("0xF0-0xF4 not implemented for length {}", length);
+                        length -= 0xEC;
+                        // integer_to_value!(input, 4 * length as usize)
+                        todo!("Variable length handle 64 -> 128 bit numbers: {}", length);
                     }
                     0xF5 => {
-                        length = 6;
-                        todo!("0xF5 not implemented for length {}", length);
+                        // integer_to_value!(input, 48)
+                        todo!("Variable length handle 192 bit number: {}", length);
                     }
                     0xF6 => {
-                        length = 8;
-                        todo!("0xF6 not implemented for length {}", length);
+                        // integer_to_value!(input, 64)
+                        todo!("Variable length handle 256 bit number: {}", length);
                     }
                     _ => {
                         todo!(
-                            "Variable length parsing for length: {} is a resreved value",
+                            "Variable length parsing for length: {} is a reserved value",
                             length
                         );
                     }

src/user_data/variable_user_data.rs

@@ -32,7 +32,61 @@ impl<'a> From<(&'a [u8], &'a FixedDataHeader)> for DataRecords<'a> {
     }
 }
 
+#[cfg(all(test, feature = "std"))]
 mod tests {
+    use crate::user_data::{data_information::DataFieldCoding, data_record::DataRecord};
+
+    #[test]
+    fn test_parse_variable_data_length() {
+        use crate::user_data::data_information::DataFieldCoding;
+        use crate::user_data::data_information::DataType;
+        use crate::user_data::data_information::TextUnit;
+        use crate::user_data::DataRecords;
+
+        let data: &[u8] = &[
+            0x0D, 0x06, 0xC1, 0x12, 0x0D, 0x06, 0xD3, 0x12, 0x34, 0x56, 0x0D, 0x06, 0x02, 0x31,
+            0x32, 0x0D, 0x06, 0xE1, 0xFF, 0x0D, 0x06, 0x00,
+        ];
+
+        let records: Vec<DataRecord<'_>> = DataRecords::from(data).flatten().collect();
+
+        assert_eq!(records.len(), 5);
+        {
+            let record = records.get(0).unwrap();
+            let code = get_data_field_coding(record);
+            assert_eq!(code, DataFieldCoding::VariableLength);
+            let value = record.data.value.clone().unwrap();
+            assert_eq!(value, DataType::Number(12.0))
+        }
+        {
+            let record = records.get(1).unwrap();
+            let code = get_data_field_coding(record);
+            assert_eq!(code, DataFieldCoding::VariableLength);
+            let value = record.data.value.clone().unwrap();
+            assert_eq!(value, DataType::Number(-563412.0))
+        }
+        {
+            let record = records.get(2).unwrap();
+            let code = get_data_field_coding(record);
+            assert_eq!(code, DataFieldCoding::VariableLength);
+            let value = record.data.value.clone().unwrap();
+            assert_eq!(value, DataType::Text(TextUnit::new(&[0x31, 0x32])))
+        }
+        {
+            let record = records.get(3).unwrap();
+            let code = get_data_field_coding(record);
+            assert_eq!(code, DataFieldCoding::VariableLength);
+            let value = record.data.value.clone().unwrap();
+            assert_eq!(value, DataType::Number(-1.0))
+        }
+        {
+            let record = records.get(4).unwrap();
+            let code = get_data_field_coding(record);
+            assert_eq!(code, DataFieldCoding::VariableLength);
+            let value = record.data.value.clone().unwrap();
+            assert_eq!(value, DataType::Text(TextUnit::new(&[])))
+        }
+    }
 
     #[test]
     fn test_parse_variable_data() {
@@ -82,4 +136,14 @@ mod tests {
         /* Data block 3: unit 1, storage No 0, tariff 2, instantaneous energy, 218,37 kWh (6 digit BCD) */
         let _data = &[0x8B, 0x60, 0x04, 0x37, 0x18, 0x02];
     }
+
+    fn get_data_field_coding(record: &DataRecord) -> DataFieldCoding {
+        record
+            .data_record_header
+            .processed_data_record_header
+            .data_information
+            .clone()
+            .unwrap()
+            .data_field_coding
+    }
 }