//******************************************************************************************************//  CommonFrameHeader.cs - Gbtc////  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  04/26/2009 - J. Ritchie Carroll//       Generated original version of source code.//  09/15/2009 - Stephen C. Wills//       Added new header and license agreement.//  12/17/2012 - Starlynn Danyelle Gilliam//       Modified Header.////****************************************************************************************************** using System;using System.Runtime.Serialization;using GSF.Parsing; namespace GSF.PhasorProtocols.SelFastMessage{    /// <summary>    /// Represents the common header for all SEL Fast Message frames of data.    /// </summary>    [Serializable]    public class CommonFrameHeader : CommonHeaderBase<int>, ISerializable    {        #region [ Members ]         // Constants         /// <summary>        /// Total fixed length of <see cref="CommonFrameHeader"/>.        /// </summary>        public const ushort FixedLength = 24;         /// <summary>        /// Total header length of <see cref="CommonFrameHeader"/>.        /// </summary>        public const ushort HeaderLength = 18;         // Fields        private FrameSize m_frameSize;        private uint m_idCode;        private Ticks m_timestamp;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new <see cref="CommonFrameHeader"/> from specified parameters.        /// </summary>        /// <param name="frameSize">The <see cref="SelFastMessage.FrameSize"/> of this frame.</param>        /// <param name="timestamp">The timestamp of this frame.</param>        public CommonFrameHeader(FrameSize frameSize, Ticks timestamp)        {            m_frameSize = frameSize;            m_timestamp = timestamp;        }         /// <summary>        /// Creates a new <see cref="CommonFrameHeader"/> from given <paramref name="buffer"/>.        /// </summary>        /// <param name="buffer">Buffer that contains data to parse.</param>        /// <param name="startIndex">Start index into buffer where valid data begins.</param>        public CommonFrameHeader(byte[] buffer, int startIndex)        {            // Validate SEL Fast Message data image            if (buffer[startIndex] != Common.HeaderByte1 || buffer[startIndex + 1] != Common.HeaderByte2)                throw new InvalidOperationException($"Bad data stream, expected header bytes 0xA546 as first bytes in SEL Fast Message frame, got 0x{buffer[startIndex].ToString("X").PadLeft(2, '0')}{buffer[startIndex + 1].ToString("X").PadLeft(2, '0')}");             ushort sampleCount;            uint secondOfCentury;            NtpTimeTag timetag;             // Parse relevant common header values            m_frameSize = (FrameSize)buffer[startIndex + 2];            m_idCode = BigEndian.ToUInt32(buffer, startIndex + 12);            sampleCount = BigEndian.ToUInt16(buffer, startIndex + 18);            secondOfCentury = BigEndian.ToUInt32(buffer, startIndex + 20);             // We use an NTP time tag since SEL Fast Message SOC also starts at 1/1/1900            timetag = new NtpTimeTag(secondOfCentury, 0);             // Data frames have subsecond time information, so we add this fraction of time to current seconds value            timetag = new NtpTimeTag(timetag.Value + sampleCount * 50.0M / 1000.0M);             // Cache timestamp value            m_timestamp = timetag.ToDateTime().Ticks;        }         /// <summary>        /// Creates a new <see cref="CommonFrameHeader"/> from serialization parameters.        /// </summary>        /// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>        /// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>        protected CommonFrameHeader(SerializationInfo info, StreamingContext context)        {            // Deserialize common frame header            m_frameSize = (FrameSize)info.GetValue("frameSize", typeof(FrameSize));            m_idCode = info.GetUInt32("idCode32Bit");        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets the timestamp of this frame in NTP format.        /// </summary>        public NtpTimeTag TimeTag => new(m_timestamp);         /// <summary>        /// Gets or sets timestamp of this <see cref="CommonFrameHeader"/>.        /// </summary>        public Ticks Timestamp        {            get => m_timestamp;            set => m_timestamp = value;        }         /// <summary>        /// Gets or sets the SEL Fast Message destination address (PMADDR setting) of this <see cref="CommonFrameHeader"/>.        /// </summary>        public uint IDCode        {            get => m_idCode;            set => m_idCode = value;        }         /// <summary>        /// Gets the SEL Fast Message second of century of this <see cref="CommonFrameHeader"/>.        /// </summary>        public uint SecondOfCentury => (uint)Math.Truncate(TimeTag.Value);         /// <summary>        /// Gets the SEL Fast Message sample number of this <see cref="CommonFrameHeader"/>.        /// </summary>        public ushort SampleNumber => (ushort)(m_timestamp.DistanceBeyondSecond().ToMilliseconds() / 50);         /// <summary>        /// Gets or sets the SEL Fast Message frame size of this <see cref="CommonFrameHeader"/>.        /// </summary>        public FrameSize FrameSize        {            get => m_frameSize;            set => m_frameSize = value;        }         /// <summary>        /// Gets the SEL Fast Message register count of this <see cref="CommonFrameHeader"/>.        /// </summary>        public ushort RegisterCount => (ushort)(DataLength / 2);         /// <summary>        /// Gets the length of the data in the SEL Fast Message frame (i.e., the <see cref="FrameSize"/> minus the <see cref="HeaderLength"/> and checksum) of this <see cref="CommonFrameHeader"/>.        /// </summary>        public ushort DataLength =>            // Data length will be frame length minus common header length minus crc16            (ushort)((ushort)m_frameSize - HeaderLength - 2);          /// <summary>        /// Gets the binary image of the common header portion of this <see cref="CommonFrameHeader"/>.        /// </summary>        public byte[] BinaryImage        {            get            {                byte[] buffer = new byte[FixedLength];                 buffer[0] = Common.HeaderByte1;                buffer[1] = Common.HeaderByte2;                buffer[2] = (byte)m_frameSize;                buffer[9] = 0x20;   // Function code                buffer[10] = 0xC0;  // Sequence byte                 // Include destination address (PMADDR setting)                BigEndian.CopyBytes(m_idCode, buffer, 12);                 // Include register count                BigEndian.CopyBytes(RegisterCount, buffer, 16);                 // Include sample number                BigEndian.CopyBytes(SampleNumber, buffer, 18);                 // Include second of century                BigEndian.CopyBytes(SecondOfCentury, buffer, 20);                 return buffer;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Populates a <see cref="SerializationInfo"/> with the data needed to serialize the target object.        /// </summary>        /// <param name="info">The <see cref="SerializationInfo"/> to populate with data.</param>        /// <param name="context">The destination <see cref="StreamingContext"/> for this serialization.</param>        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)        {            // Serialize unique common frame header values            info.AddValue("frameSize", m_frameSize, typeof(FrameSize));            info.AddValue("idCode32Bit", m_idCode);        }         #endregion    }}