예제 #1
0
 /// <summary>
 /// Creates a new <see cref="DataFrame"/> from specified parameters.
 /// </summary>
 /// <param name="timestamp">The exact timestamp, in <see cref="Ticks"/>, of the data represented by this <see cref="DataFrame"/>.</param>
 /// <param name="configurationFrame">The <see cref="ConfigurationFrame"/> associated with this <see cref="DataFrame"/>.</param>
 /// <remarks>
 /// This constructor is used by a consumer to generate an IEEE C37.118 data frame.
 /// </remarks>
 public DataFrame(Ticks timestamp, ConfigurationFrame1 configurationFrame)
     : base(new DataCellCollection(), timestamp, configurationFrame)
 {
     // Pass time-base along to DataFrame's common header
     if (configurationFrame is not null)
     {
         CommonHeader.Timebase = configurationFrame.Timebase;
     }
 }
예제 #2
0
        /// <summary>
        /// Creates a new <see cref="CommonFrameHeader"/> from specified parameters.
        /// </summary>
        /// <param name="configurationFrame">IEEE C37.118 <see cref="ConfigurationFrame1"/> if available.</param>
        /// <param name="typeID">The IEEE C37.118 specific frame type of this frame.</param>
        /// <param name="idCode">The ID code of this frame.</param>
        /// <param name="timestamp">The timestamp of this frame.</param>
        public CommonFrameHeader(ConfigurationFrame1 configurationFrame, FrameType typeID, ushort idCode, Ticks timestamp)
        {
            m_frameType = typeID;
            m_idCode    = idCode;
            m_timestamp = timestamp;
            m_version   = 1;
            m_timebase  = (UInt24)100000;

            if ((object)configurationFrame != null)
            {
                // Hang on to configured frame rate and ticks per frame
                m_framesPerSecond = configurationFrame.FrameRate;
                m_ticksPerFrame   = Ticks.PerSecond / (double)m_framesPerSecond;
            }
        }
예제 #3
0
        /// <summary>
        /// Creates a new <see cref="CommonFrameHeader"/> from specified parameters.
        /// </summary>
        /// <param name="configurationFrame">IEEE C37.118 <see cref="ConfigurationFrame1"/> if available.</param>
        /// <param name="typeID">The IEEE C37.118 specific frame type of this frame.</param>
        /// <param name="idCode">The ID code of this frame.</param>
        /// <param name="timestamp">The timestamp of this frame.</param>
        /// <param name="version">The target version for this IEEE C37.118 frame.</param>
        public CommonFrameHeader(ConfigurationFrame1 configurationFrame, FrameType typeID, ushort idCode, Ticks timestamp, DraftRevision version)
        {
            m_frameType = typeID;
            m_idCode    = idCode;
            m_timestamp = timestamp;
            m_version   = (byte)version;
            m_timebase  = (UInt24)100000;

            if (configurationFrame is null)
            {
                return;
            }

            // Hang on to configured frame rate and ticks per frame
            m_framesPerSecond = configurationFrame.FrameRate;
            m_ticksPerFrame   = Ticks.PerSecond / (double)m_framesPerSecond;
        }
예제 #4
0
        /// <summary>
        /// Creates a new <see cref="CommonFrameHeader"/> from given <paramref name="buffer"/>.
        /// </summary>
        /// <param name="configurationFrame">IEEE C37.118 <see cref="ConfigurationFrame1"/> if already parsed.</param>
        /// <param name="buffer">Buffer that contains data to parse.</param>
        /// <param name="startIndex">Start index into buffer where valid data begins.</param>
        public CommonFrameHeader(ConfigurationFrame1 configurationFrame, byte[] buffer, int startIndex)
        {
            const byte VersionNumberMask = (byte)IEEEC37_118.FrameType.VersionNumberMask;

            if (buffer[startIndex] != PhasorProtocols.Common.SyncByte)
            {
                throw new InvalidOperationException("Bad data stream, expected sync byte 0xAA as first byte in IEEE C37.118 frame, got 0x" + buffer[startIndex].ToString("X").PadLeft(2, '0'));
            }

            // Strip out frame type and version information...
            m_frameType = (FrameType)(buffer[startIndex + 1] & ~VersionNumberMask);
            m_version   = (byte)(buffer[startIndex + 1] & VersionNumberMask);

            m_frameLength = BigEndian.ToUInt16(buffer, startIndex + 2);
            m_idCode      = BigEndian.ToUInt16(buffer, startIndex + 4);

            uint secondOfCentury  = BigEndian.ToUInt32(buffer, startIndex + 6);
            uint fractionOfSecond = BigEndian.ToUInt32(buffer, startIndex + 10);

            // Without timebase, the best timestamp you can get is down to the whole second
            m_timestamp = (new UnixTimeTag((double)secondOfCentury)).ToDateTime().Ticks;

            if ((object)configurationFrame != null)
            {
                long ticksBeyondSecond;

                // If config frame is available, frames have enough information for sub-second time resolution
                m_timebase = configurationFrame.Timebase;

                // "Actual fractional seconds" are obtained by taking fractionOfSecond and dividing by timebase.
                // Since we are converting to ticks, we need to multiply by Ticks.PerSecond.
                // We do the multiplication first so that the whole operation can be done using integer arithmetic.
                // m_timebase / 2L is added before dividing by timebase in order to round the result.
                ticksBeyondSecond = (fractionOfSecond & ~Common.TimeQualityFlagsMask) * Ticks.PerSecond;
                m_timestamp      += (ticksBeyondSecond + m_timebase / 2L) / m_timebase;

                // Hang on to configured frame rate and ticks per frame
                m_framesPerSecond = configurationFrame.FrameRate;
                m_ticksPerFrame   = Ticks.PerSecond / (double)m_framesPerSecond;
            }

            m_timeQualityFlags = fractionOfSecond & Common.TimeQualityFlagsMask;
        }
예제 #5
0
 /// <summary>
 /// Creates a new <see cref="ConfigurationCell"/> from specified parameters.
 /// </summary>
 /// <param name="parent">The reference to parent <see cref="ConfigurationFrame1"/> of this <see cref="ConfigurationCell"/>.</param>
 /// <param name="idCode">The numeric ID code for this <see cref="ConfigurationCell"/>.</param>
 /// <param name="nominalFrequency">The nominal <see cref="LineFrequency"/> of the <see cref="FrequencyDefinition"/> of this <see cref="ConfigurationCell"/>.</param>
 public ConfigurationCell(ConfigurationFrame1 parent, ushort idCode, LineFrequency nominalFrequency)
     : this(parent)
 {
     IDCode           = idCode;
     NominalFrequency = nominalFrequency;
 }
예제 #6
0
 /// <summary>
 /// Creates a new <see cref="ConfigurationCell3"/> from specified parameters.
 /// </summary>
 /// <param name="parent">The reference to parent <see cref="ConfigurationFrame1"/> of this <see cref="ConfigurationCell3"/>.</param>
 /// <param name="idCode">The numeric ID code for this <see cref="ConfigurationCell3"/>.</param>
 /// <param name="nominalFrequency">The nominal <see cref="LineFrequency"/> of the <see cref="FrequencyDefinition"/> of this <see cref="ConfigurationCell3"/>.</param>
 public ConfigurationCell3(ConfigurationFrame1 parent, ushort idCode, LineFrequency nominalFrequency) //FIXME: Does this need to use config frame 3?
     : this(parent)
 {
     IDCode           = idCode;
     NominalFrequency = nominalFrequency;
 }
예제 #7
0
파일: FrameParser.cs 프로젝트: kobi2187/gsf
        /// <summary>
        /// Casts the parsed <see cref="IChannelFrame"/> to its specific implementation (i.e., <see cref="DataFrame"/>, <see cref="ConfigurationFrame"/>, <see cref="CommandFrame"/> or <see cref="HeaderFrame"/>).
        /// </summary>
        /// <param name="frame"><see cref="IChannelFrame"/> that was parsed by <see cref="FrameImageParserBase{TTypeIdentifier,TOutputType}"/> that implements protocol specific common frame header interface.</param>
        protected override void OnReceivedChannelFrame(IChannelFrame frame)
        {
            // Raise abstract channel frame events as a priority (i.e., IDataFrame, IConfigurationFrame, etc.)
            base.OnReceivedChannelFrame(frame);

            // Raise IEEE C37.118 specific channel frame events, if any have been subscribed
            if (frame != null && (ReceivedDataFrame != null || ReceivedConfigurationFrame2 != null || ReceivedConfigurationFrame1 != null || ReceivedHeaderFrame != null || ReceivedCommandFrame != null))
            {
                DataFrame dataFrame = frame as DataFrame;

                if (dataFrame != null)
                {
                    if (ReceivedDataFrame != null)
                    {
                        ReceivedDataFrame(this, new EventArgs <DataFrame>(dataFrame));
                    }
                }
                else
                {
                    // Configuration frame type 2 is more specific than type 1 (and more common), so we check it first
                    ConfigurationFrame2 configFrame2 = frame as ConfigurationFrame2;

                    if (configFrame2 != null)
                    {
                        if (ReceivedConfigurationFrame2 != null)
                        {
                            ReceivedConfigurationFrame2(this, new EventArgs <ConfigurationFrame2>(configFrame2));
                        }
                    }
                    else
                    {
                        ConfigurationFrame1 configFrame1 = frame as ConfigurationFrame1;

                        if (configFrame1 != null)
                        {
                            if (ReceivedConfigurationFrame1 != null)
                            {
                                ReceivedConfigurationFrame1(this, new EventArgs <ConfigurationFrame1>(configFrame1));
                            }
                        }
                        else
                        {
                            HeaderFrame headerFrame = frame as HeaderFrame;

                            if (headerFrame != null)
                            {
                                if (ReceivedHeaderFrame != null)
                                {
                                    ReceivedHeaderFrame(this, new EventArgs <HeaderFrame>(headerFrame));
                                }
                            }
                            else
                            {
                                CommandFrame commandFrame = frame as CommandFrame;

                                if (commandFrame != null)
                                {
                                    if (ReceivedCommandFrame != null)
                                    {
                                        ReceivedCommandFrame(this, new EventArgs <CommandFrame>(commandFrame));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }