init

Common/DTS.Common.Serialization/IRIGCH10/Packets/IDataPacket.cs

@@ -0,0 +1,211 @@
+using DTS.Serialization.IRIGCH10.Enums;
+using DTS.Serialization.IRIGCH10.Packets;
+using System;
+using System.ComponentModel;
+using System.IO;
+
+namespace DTS.Serialization.IRIGCH10
+{
+    /// <summary>
+    /// this is the interface that all datapackets implement, it defines how packets can be interacted with in general
+    /// </summary>
+    public interface IDataPacket
+    {
+        /// <summary>
+        /// all chapter 10 packets have a packet header
+        /// </summary>
+        IPacketHeader PacketHeader { get; }
+        /// <summary>
+        /// computes the checksum for the datapacket data
+        /// </summary>
+        uint ComputeCheckSum();
+        /// <summary>
+        /// returns all bytes for the packet 
+        /// </summary>
+        /// <returns></returns>
+        byte[] GetBytes();
+        /// <summary>
+        /// sets the Realtime Counter (10 MHZ) for the packet
+        /// </summary>
+        /// <param name="rtc"></param>
+        void SetRTC(long rtc);
+        /// <summary>
+        /// sets the DataVersion of the packet
+        /// (part of the packet header)
+        /// </summary>
+        /// <param name="version"></param>
+        void SetDataVersion(DataTypeVersion version);
+        
+        /// <summary>
+        /// sets the channel id for the packet (part of packet header)
+        /// </summary>
+        /// <param name="channelID"></param>
+        void SetChannelID(ushort channelID);
+        /// <summary>
+        /// sets the sequence number for the packet,
+        /// in general should be increasing and flip back to 0
+        /// after max value
+        /// </summary>
+        /// <param name="seq"></param>
+        void SetSequenceNumber(ushort seq);
+    }
+    /// <summary>
+    /// this is the general base class all packets extend, it
+    /// has common features like computing the checksum, setting the
+    /// packet specific Channel Data Word, etc
+    /// </summary>
+    public abstract class AbstractDataPacket
+    {
+        protected void SetCSDWBit(int bit, bool value)
+        {
+            if (bit <0 || bit > 31)
+            {
+                return;
+            }
+            if (!value)
+            {
+                //and with all ones except for the bit in question
+                ChannelSpecificDataWord &= ~(1u << bit);
+            }
+            else
+            {
+                //or with all 0s except for bit in question
+                ChannelSpecificDataWord |= (1u << bit);
+            }
+        }
+        protected bool GetCSDWBit(int bit)
+        {
+            if (bit < 0 || bit > 31) { return false; }
+            return (ChannelSpecificDataWord & (1u << bit)) != 0;
+        }
+        protected int CommonHeaderWork(ushort channelId, byte dataVersion,
+            byte sequenceNumber, long rtc, uint dataLength, int nanoseconds, int seconds)
+        {
+            PacketHeader.ChannelId = channelId;
+            PacketHeader.DataVersion = dataVersion;
+            PacketHeader.SequenceNum = sequenceNumber;
+            PacketHeader.IPTSTimeSource = PacketHeader.SecondaryHeaderPresent;
+            PacketHeader.RTCSyncError = false;
+            PacketHeader.SecondaryHeaderTimeFormat = IRIGCH10.PacketHeader.SecondaryHeaderTimeFormats.IEEE1588;
+            PacketHeader.DataOverflowError = false;
+            PacketHeader.CheckSumPresence = IRIGCH10.PacketHeader.DataCheckSumPresences.NotPresent;
+            PacketHeader.SetRTC(rtc);
+            PacketHeader.DataLength = dataLength;
+
+            PacketHeader.PacketLength = PacketHeader.DataLength + IRIGCH10.PacketHeader.PACKET_HEADER_LENGTH;
+            if (PacketHeader.SecondaryHeaderPresent)
+            {
+                PacketHeader.PacketLength += SecondaryTimeFormatHeader.SECONDARY_TIME_HEADER_LENGTH;
+            }
+            if (0 != PacketHeader.PacketLength % 4)
+            {
+                var pad = 4 - PacketHeader.PacketLength % 4;
+                //pad out packet length to a multiple of 4 ...
+                PacketHeader.PacketLength += pad;
+            }
+            _dataBytes = new byte[PacketHeader.PacketLength - IRIGCH10.PacketHeader.PACKET_HEADER_LENGTH];
+
+            var offset = 0;
+
+            if (PacketHeader.SecondaryHeaderPresent)
+            {
+                var secondaryHeader = SecondaryTimeFormatHeader.GetBytes(nanoseconds, seconds);
+
+                Buffer.BlockCopy(secondaryHeader, 0, _dataBytes, offset, secondaryHeader.Length);
+                offset += secondaryHeader.Length;
+            }
+
+            var channelSpecificDataWord = BitConverter.GetBytes(ChannelSpecificDataWord);
+            Buffer.BlockCopy(channelSpecificDataWord, 0, _dataBytes, offset, channelSpecificDataWord.Length);
+            offset += channelSpecificDataWord.Length;
+            return offset;
+        }
+        private uint _ChannelSpecificDataWork = 0;
+        [Browsable(false)]
+        public uint ChannelSpecificDataWord
+        {
+            get => _ChannelSpecificDataWork;
+            protected set => _ChannelSpecificDataWork = value;
+        }
+        [Browsable(false)]
+        public IPacketHeader PacketHeader { get; protected set; }
+        public uint ComputeCheckSum()
+        {
+            return Utils.Utils.GetCheckSum32(_dataBytes);
+        }
+
+        /// <summary>
+        /// sets the sequence number for the packet
+        /// </summary>
+        /// <param name="seq"></param>
+        public void SetSequenceNumber(ushort seq)
+        {
+            PacketHeader.SequenceNum = BitConverter.GetBytes(seq)[0];
+        }
+
+        private long _rtc;
+        /// <summary>
+        /// returns the Realtime Counter (10Mhz) value for the packet
+        /// </summary>
+        /// <returns></returns>
+        public long GetRTC() { return _rtc; }
+        /// <summary>
+        /// sets the Realtime Counter (10Mhz) value for the packet
+        /// </summary>
+        /// <param name="rtc"></param>
+        public void SetRTC(long rtc)
+        {
+            _rtc = rtc;
+            PacketHeader.SetRTC(rtc);
+
+        }
+
+        public const long BASE_RTC = 141989612500056L;
+        /// <summary>
+        /// returns all bytes for the packet
+        /// is virtual so extending classes can define their own behavior as needed
+        /// </summary>
+        /// <returns></returns>
+        public virtual byte[] GetBytes()
+        {
+            using (var ms = new MemoryStream())
+            {
+                using (var bw = new BinaryWriter(ms))
+                {
+                    bw.Write(PacketHeader.GetBytes());
+                    bw.Write(_dataBytes);
+                }
+                return ms.ToArray();
+            }
+        }
+
+        protected AbstractDataPacket(DataFileDataTypes dataType, bool secondaryHeaderPresent)
+        {
+            PacketHeader = new PacketHeader(dataType);
+            PacketHeader.SecondaryHeaderPresent = secondaryHeaderPresent;
+        }
+        protected AbstractDataPacket(byte[] bytes)
+        {
+            var header = new byte[24];
+            Buffer.BlockCopy(bytes, 0, header, 0, 24);
+            PacketHeader = new PacketHeader(header);
+            _dataBytes = new byte[PacketHeader.DataLength];
+            var length = _dataBytes.Length;
+            var length2 = bytes.Length - 24;
+            if (length2 < length) { length = length2; }
+            Buffer.BlockCopy(bytes, 24, _dataBytes, 0, length);
+            ChannelSpecificDataWord = BitConverter.ToUInt32(_dataBytes, 0);
+        }
+
+        protected byte[] _dataBytes;
+        public void SetDataVersion(DataTypeVersion version)
+        {
+            PacketHeader.SetDataVersion(version);
+        }
+
+        public void SetChannelID(ushort channelID)
+        {
+            PacketHeader.ChannelId = channelID;
+        }
+    }
+}