16 - Updated telegrams

Updated existing telegrams and added new ones

Author: stprograms

RS485 Monitor/src/TelegramParser.cs

@@ -132,7 +132,7 @@ public void ParseChunk(byte[] rawData)
     /// <summary>
     /// Parse the given file
     /// </summary>
-    /// <param name="filePath"></param> 
+    /// <param name="filePath"></param>
     public void ParseFile(string filePath)
     {
         FileInfo info = new(filePath);
@@ -199,28 +199,23 @@ private void FinishBlock()
             return null;
         }
 
-        // Check if we can convert 
-        if ( tg.Type == BaseTelegram.TelegramType.READ_RESPONSE)
+        // Define known telegrams
+        Dictionary<UInt16, Type> knownTelegrams = new()
         {
-            if (tg.Source == 0xAA && tg.Destination == 0x5A && tg.PDU.Length == 10)
-            {
-                tg = new BatteryStatus(tg);
-            }
-            else if (tg.Source == 0xAA && tg.Destination == 0xDA && tg.PDU.Length == 10)
-            {
-                tg = new ECUStatus(tg);
-            }
-        }
-
-        else if (tg.Type == BaseTelegram.TelegramType.READ_REQUEST)
+            {ControllerRequest.TELEGRAM_ID, typeof(ControllerRequest) },
+            {ControllerResponse.TELEGRAM_ID, typeof(ControllerResponse) },
+            {BatteryRequest.TELEGRAM_ID, typeof(BatteryRequest) },
+            {BatteryResponse.TELEGRAM_ID, typeof(BatteryResponse) },
+            {SpeedometerRequest.TELEGRAM_ID, typeof(SpeedometerRequest) },
+            {SpeedometerResponse.TELEGRAM_ID, typeof(SpeedometerResponse) },
+        };
+
+        // try to fetch the special telegram type
+        if (knownTelegrams.TryGetValue(tg.Id, out Type? specialType))
         {
-            if (tg.Source == 0xBA && tg.Destination == 0xAA && tg.PDU.Length == GSMStatus.RAW_DATA_LEN)
-            {
-                tg = new GSMStatus(tg);
-            }
+            tg = (BaseTelegram?)Activator.CreateInstance(specialType, [tg]);
         }
 
         return tg;
     }
-
-}
+}

RS485 Monitor/src/Telegrams/BaseTelegram.cs

@@ -1,7 +1,7 @@
 using NLog;
 
 /// <summary>
-/// This class defines a basic telegram with data. No special parsing of the 
+/// This class defines a basic telegram with data. No special parsing of the
 /// content is done here. Check the specialized classes for more detail
 /// </summary>
 public class BaseTelegram : IEquatable<BaseTelegram>
@@ -11,86 +11,141 @@ public class BaseTelegram : IEquatable<BaseTelegram>
     /// </summary>
     static readonly Logger log = LogManager.GetCurrentClassLogger();
 
-    #region Properties
+
+    #region Constants
     /// <summary>
-    /// Start Sequence of the telegram
+    /// Maximum supported data length
     /// </summary>
-    public UInt16 Start { get => (UInt16)((Raw[0] << 8) + Raw[1]); }
+    private const byte MAX_DATA_LEN = 32;
 
     /// <summary>
-    /// Source of the telegram
+    /// Minimum length of a telegram. This contains the following data:
+    /// - Type (2 bytes)
+    /// - Destination (1 byte)
+    /// - Source (1 byte)
+    /// - Data length (1 byte)
+    /// - Checksum (1 byte)
+    /// - End byte (1 byte)
     /// </summary>
-    public byte Source { get => Raw[POS_SRC]; }
+    private const byte MIN_DATA_LEN = 7;
 
     /// <summary>
-    /// Destination of the telegram
+    /// End byte of the telegram
     /// </summary>
-    public byte Destination { get => Raw[POS_DES]; }
+    private const byte END_TELEGRAM = 0x0D;
 
     /// <summary>
-    /// User Data
+    /// Offset of the high Byte of the the telegram type
     /// </summary>
-    public byte[] PDU { get; }
+    private const byte POS_TYPE_H = 0;
+    /// <summary>
+    /// Offset of the low Byte of the the telegram type
+    /// </summary>
+    private const byte POS_TYPE_L = 1;
+    /// <summary>
+    /// Position of the destination id in the raw data
+    /// </summary>
+    private const byte POS_DES = 2;
+    /// <summary>
+    /// Position of the source id in the raw data
+    /// </summary>
+    private const byte POS_SRC = 3;
+    /// <summary>
+    /// Position of the data length in the raw data
+    /// </summary>
+    private const byte POS_LEN = 4;
+    #endregion
 
+    #region Properties
     /// <summary>
-    /// Received checksum
+    /// Type of the telegram as raw value
     /// </summary>
-    public byte Checksum { get => Raw[POS_LEN + PDU.Length + 1]; }
+    public UInt16 RawType
+    {
+        get => (UInt16)((Raw[POS_TYPE_H] << 8) + Raw[POS_TYPE_L]);
+    }
 
     /// <summary>
-    /// Copy of the received raw data of the telegram
+    /// Destination / recipient of the telegram
     /// </summary>
-    public byte[] Raw { get; }
+    public byte Destination { get => Raw[POS_DES]; }
 
     /// <summary>
-    /// Are the raw data valid against the Checksum
+    /// Source / sender of the telegram
     /// </summary>
-    public bool Valid { get; }
+    public byte Source { get => Raw[POS_SRC]; }
 
-    public enum TelegramType
+    /// <summary>
+    /// Identifier for the telegram type. Is is a mixture of the telegram type,
+    /// the destination and the source.
+    /// </summary>
+    public UInt16 Id
     {
-        READ_REQUEST = 0xC55C,
-        READ_RESPONSE = 0xB66B
+        get => (UInt16)(Destination << 8 | Source);
     }
+
     /// <summary>
-    /// Type of the telegram
+    /// User Data / specific to the telegram
     /// </summary>
-    public TelegramType Type { get => (TelegramType)Start; }
-
-    #endregion
+    public byte[] PDU { get; }
 
-    #region Constants
     /// <summary>
-    /// Maximum supported data length
+    /// Received checksum
     /// </summary>
-    private const byte MAX_DATA_LEN = 32;
+    public byte Checksum { get => Raw[POS_LEN + PDU.Length + 1]; }
 
     /// <summary>
-    /// End byte of the telegram
+    /// Complete telegram as raw data
     /// </summary>
-    private const byte END_TELEGRAM = 0x0D;
+    public byte[] Raw { get; }
 
     /// <summary>
-    /// Position of the source id in the raw data
+    /// The raw PDU is valid against the received checksum
     /// </summary>
-    private const byte POS_SRC = 2;
+    public bool Valid
+    {
+        get
+        {
+            byte calcCheck = Raw[POS_LEN];
+            foreach (byte b in PDU)
+            {
+                calcCheck ^= b;
+            }
+
+            log.Trace($"Checksum: read={Checksum.ToString("X2")}, calc={calcCheck.ToString("X2")}");
+            return calcCheck == Checksum;
+        }
+    }
+
     /// <summary>
-    /// Position of the destination id in the raw data
+    /// Possible types of the telegram
     /// </summary>
-    private const byte POS_DES = 3;
+    public enum TelegramType
+    {
+        /// <summary>
+        /// Request telegram triggered by bus master to the unit
+        /// </summary>
+        REQUEST = 0xC55C,
+        /// <summary>
+        /// Telegram sent as a response to a request from the unit to the bus master
+        /// </summary>
+        RESPONSE = 0xB66B
+    }
+
     /// <summary>
-    /// Position of the data length in the raw data
+    /// Type of the telegram
     /// </summary>
-    private const byte POS_LEN = 4;
+    public TelegramType Type { get => (TelegramType)RawType; }
+
     #endregion
 
     /// <summary>
-    /// Internal constructor for specialized classes
+    /// Internal constructor for specialized classes. Create empty arrays
     /// </summary>
     protected BaseTelegram()
     {
-        PDU = new byte[1];
-        Raw = new byte[1];
+        PDU = Array.Empty<byte>();
+        Raw = Array.Empty<byte>();
     }
 
     /// <summary>
@@ -104,56 +159,52 @@ protected BaseTelegram(BaseTelegram c)
 
         this.PDU = new byte[c.PDU.Length];
         Array.Copy(c.PDU, this.PDU, this.PDU.Length);
-
-        this.Valid = c.Valid;
     }
 
     /// <summary>
     /// Create a new base telegram based on the given raw data
     /// </summary>
     /// <param name="rawData">raw data of one telegram</param>
-    /// <exception cref="ArgumentException">Given data length in the raw data is invalid.</exception>
+    /// <exception cref="ArgumentNullException">Raw data is null.</exception>
+    /// <exception cref="ArgumentException">Raw data is too short.</exception>
+    /// <exception cref="ArgumentException">Invalid data length in the raw data.</exception>
+    /// <exception cref="ArgumentException">Raw data does not contain End tag.</exception>
     public BaseTelegram(byte[] rawData)
     {
+        // Basic validation
+        ArgumentNullException.ThrowIfNull(rawData);
+        if (rawData.Length < MIN_DATA_LEN)
+        {
+            throw new ArgumentException("Raw data is too short");
+        }
+
         // Copy raw data
         Raw = new byte[rawData.Length];
         Array.Copy(rawData, Raw, Raw.Length);
 
         // fetch user data
-        byte dataLen = rawData[POS_LEN];
-        if (dataLen > MAX_DATA_LEN)
+        byte pduLen = rawData[POS_LEN];
+        if (pduLen > MAX_DATA_LEN)
         {
-            throw new ArgumentException($"Invalid data len {dataLen}. Max supported: {MAX_DATA_LEN}");
+            throw new ArgumentException($"Invalid data len {pduLen}. Max supported: {MAX_DATA_LEN}");
         }
-        PDU = new byte[dataLen];
+
+        // copy user data to PDU array
+        PDU = new byte[pduLen];
         Array.Copy(rawData, POS_LEN + 1, PDU, 0, PDU.Length);
 
-        /* Verify checksum
-         * Checksum is calculated as XOR of the user data, including the length byte
-         */
-        byte calcCheck = dataLen;
-        foreach (byte b in PDU)
-        {
-            calcCheck ^= b;
-        }
-        log.Trace($"Checksum: read={Checksum.ToString("X2")}, calc={calcCheck.ToString("X2")}");
-        Valid = (calcCheck == Checksum);
+        // Verify checksum
         if (Valid == false)
         {
-            log.Warn($"Telegram has an invalid checksum read:{Checksum.ToString("X2")}, calc:{calcCheck.ToString("X2")}");
+            log.Warn("Telegram has an invalid checksum");
         }
 
-        // Check end telegram
-        try
-        {
-            if (rawData.Length < (5 + 1 + dataLen) || rawData[5 + 1 + dataLen] != END_TELEGRAM)
-            {
-                log.Warn("RawData does not hold Endtag");
-            }
-        }
-        catch (IndexOutOfRangeException)
+        // Check end telegram value
+        int pos_end_tag = MIN_DATA_LEN - 1 + pduLen;
+        if (rawData.Length < pos_end_tag || rawData[pos_end_tag] != END_TELEGRAM)
         {
-            log.Warn("Rawdata does not contain End tag");
+            log.Error("RawData does not hold Endtag");
+            throw new ArgumentException("Raw data does not contain End tag");
         }
     }
 
@@ -192,8 +243,14 @@ public virtual string ToStringDetailed()
         return ToString();
     }
 
+    /// <summary>
+    /// Compare two telegrams based on the raw data
+    /// </summary>
+    /// <param name="other">Second object to compare</param>
+    /// <returns></returns>
     public bool Equals(BaseTelegram? other)
     {
         return Array.Equals(this.Raw, other?.Raw);
     }
-}
+
+}

RS485 Monitor/src/Telegrams/BatteryRequest.cs

@@ -0,0 +1,53 @@
+using NLog;
+
+/// <summary>
+/// Specialization of the BaseTelegram class that extracts the information
+/// of BatteryStatus
+/// </summary>
+public class BatteryRequest : BaseTelegram
+{
+    /// <summary>
+    /// Internal logging object
+    /// </summary>
+    private static readonly Logger log = LogManager.GetCurrentClassLogger();
+
+    #region Constants
+    /// <summary>
+    /// Required size of PDU data
+    /// </summary>
+    private const byte PDU_LENGTH = 1;
+
+
+    private const byte SOURCE = (byte)Units.ECU;
+    private const byte DESTINATION = (byte)Units.BATTERY;
+    public const UInt16 TELEGRAM_ID = DESTINATION << 8 | SOURCE;
+    #endregion
+
+    /// <summary>
+    /// Create a new Battery Status object based on a received telegram
+    /// </summary>
+    /// <param name="t">Raw telegram</param>
+    /// <exception cref="ArgumentException">Raw data has an unexpected length</exception>
+    public BatteryRequest(BaseTelegram t)
+    : base(t)
+    {
+        if (t.PDU.Length != PDU_LENGTH)
+        {
+            throw new ArgumentException($"Unexpected size of {t.PDU.Length}");
+        }
+        if (t.Source != SOURCE || t.Destination != DESTINATION)
+        {
+            throw new ArgumentException("Not a BatteryResponse telegram");
+        }
+    }
+
+    /// <summary>
+    /// Get a string representation of the telegram
+    /// </summary>
+    /// <returns>String representation</returns>
+    public override string ToString()
+    {
+        log.Trace(base.ToString());
+        return "Battery Request";
+    }
+}