This project has moved. For the latest updates, please go here.

Status Flag Display shows extra bits

Nov 15, 2012 at 7:07 PM

the new graphs display of the FLAG measurements only define the first 16 bits. However, several of the failing PMUs  have a FLAG value of 557056 (decimal), which is 88000 (hexadecimal); the value displayed on the graph is 88000.

 

The leading '8' represents four bits (one is set) that have no meaning. Is the FLAG value from the PMU actually only 16 bits, with any extra just 'noise'?

Nov 15, 2012 at 7:54 PM

I looked at these values with the PMU Connection Tester, and the actual value for the FLAG is 32768 (decimal), which is 8000 (hexadecimal) => Invalid Data.

The extra bit seems to be an error, and doesn't actually exist. A bug, minor, I guess...

Coordinator
Nov 15, 2012 at 8:01 PM

The IEEE C37.118 standard only defines the first 16 bits. The openPDC is setting its own "common status flags".

    /// <summary>
    /// Protocol independent common status flags enumeration.
    /// </summary>
    /// <remarks>
    /// <para>
    /// These flags are expected to exist in the high-word of a double-word flag set such that original word flags remain in-tact
    /// in low-word of double-word flag set.
    /// </para>
    /// <para>
    /// Note that value being stored in a historian using a 32-bit single precision floating number value will only have castable
    /// conversion accuracy back to an unsigned 32-bit integer up to the 24th bit, so any bits used beyond Bit23 will be lossy.
    /// </para>
    /// </remarks>
    [Flags(), Serializable()]
    public enum CommonStatusFlags : uint
    {
        /// <summary>
        /// Data was discarded from real-time stream due to late arrival (0 when not discarded, 1 when discarded).
        /// </summary>
        DataDiscarded = (uint)Bits.Bit20,
        /// <summary>
        /// Data is valid (0 when device data is valid, 1 when invalid or device is in test mode).
        /// </summary>
        DataIsValid = (uint)Bits.Bit19,
        /// <summary>
        /// Synchronization is valid (0 when in device is in sync, 1 when it is not).
        /// </summary>
        SynchronizationIsValid = (uint)Bits.Bit18,
        /// <summary>
        /// Data sorting type, 0 by timestamp, 1 by arrival.
        /// </summary>
        DataSortingType = (uint)Bits.Bit17,
        /// <summary>
        /// Device error (including configuration error), 0 when no error.
        /// </summary>
        DeviceError = (uint)Bits.Bit16,
        /// <summary>
        /// Reserved bits for future common flags, presently set to 0.
        /// </summary>
        ReservedFlags = (uint)(Bits.Bit21 | Bits.Bit22 | Bits.Bit23 | Bits.Bit24 | Bits.Bit25 | Bits.Bit26 | Bits.Bit27 | Bits.Bit28 | Bits.Bit29 | Bits.Bit30 | Bits.Bit31),
        /// <summary>
        /// No flags.
        /// </summary>
        NoFlags = (uint)Bits.Nil
    }

Nov 16, 2012 at 3:39 PM
thanks! This explains all.


On Thu, Nov 15, 2012 at 4:01 PM, staphen <notifications@codeplex.com> wrote:

From: staphen

The IEEE C37.118 standard only defines the first 16 bits. The openPDC is setting its own "common status flags".

    /// <summary>
    /// Protocol independent common status flags enumeration.
    /// </summary>
    /// <remarks>
    /// <para>
    /// These flags are expected to exist in the high-word of a double-word flag set such that original word flags remain in-tact
    /// in low-word of double-word flag set.
    /// </para>
    /// <para>
    /// Note that value being stored in a historian using a 32-bit single precision floating number value will only have castable
    /// conversion accuracy back to an unsigned 32-bit integer up to the 24th bit, so any bits used beyond Bit23 will be lossy.
    /// </para>
    /// </remarks>
    [Flags(), Serializable()]
    public enum CommonStatusFlags : uint
    {
        /// <summary>
        /// Data was discarded from real-time stream due to late arrival (0 when not discarded, 1 when discarded).
        /// </summary>
        DataDiscarded = (uint)Bits.Bit20,
        /// <summary>
        /// Data is valid (0 when device data is valid, 1 when invalid or device is in test mode).
        /// </summary>
        DataIsValid = (uint)Bits.Bit19,
        /// <summary>
        /// Synchronization is valid (0 when in device is in sync, 1 when it is not).
        /// </summary>
        SynchronizationIsValid = (uint)Bits.Bit18,
        /// <summary>
        /// Data sorting type, 0 by timestamp, 1 by arrival.
        /// </summary>
        DataSortingType = (uint)Bits.Bit17,
        /// <summary>
        /// Device error (including configuration error), 0 when no error.
        /// </summary>
        DeviceError = (uint)Bits.Bit16,
        /// <summary>
        /// Reserved bits for future common flags, presently set to 0.
        /// </summary>
        ReservedFlags = (uint)(Bits.Bit21 | Bits.Bit22 | Bits.Bit23 | Bits.Bit24 | Bits.Bit25 | Bits.Bit26 | Bits.Bit27 | Bits.Bit28 | Bits.Bit29 | Bits.Bit30 | Bits.Bit31),
        /// <summary>
        /// No flags.
        /// </summary>
        NoFlags = (uint)Bits.Nil
    }

Read the full discussion online.

To add a post to this discussion, reply to this email (openpdc@discussions.codeplex.com)

To start a new discussion for this project, email openpdc@discussions.codeplex.com

You are receiving this email because you subscribed to this discussion on CodePlex. You can unsubscribe or change your settings on codePlex.com.

Please note: Images and attachments will be removed from emails. Any posts to this discussion will also be available online at codeplex.com




--
Patrick Pentz