Using enums to index a bit array

The application is a windows-based C# user interface for an embedded control and monitoring system.

The embedded system (written in C) maintains a table of faults which it sends to the c# application. The fault table contains one bit for each fault, stored in structure. Now from the point of view of the user interface the table is somewhat sparse - There are only a few of the fault bits that we are interested in, so the structure can be represented as below:

 typedef struct
 {
    BYTE FaultsIAmNotInterestedIn0[14];
    BYTE PowerSupplyFaults[4];
    BYTE FaultsIAmNotInterestedIn1[5];
    BYTE MachineryFaults[2];
    BYTE FaultsIAmNotInterestedIn2[5];
    BYTE CommunicationFaults[4];
 }FAULT_TABLE;

Now, I want to be able to index each fault bit that I am interested in. In C I would use an enumeration to do this:

typedef enum
{
  FF_PSU1 = offsetof(FAULT_TABLE,PowerSupplyFaults)*8,
  FF_PSU2,
  FF_PSU3, 
  FF_PSU4,
  FF_PSU5,
  FF_PSU6,
  FF_PSU7,
  FF_PSU8,
  FF_PSU9,
  FF_PSU10,
  FF_PSU11,
  FF_PSU12,
  FF_PSU13,

  FF_MACHINERY1 = offsetof(FAULT_TABLE,MachineryFaults)*8,
  FF_MACHINERY2,
  FF_MACHINERY3,
  FF_M开发者_Go百科ACHINERY4,
  FF_MACHINERY5,
  FF_MACHINERY6,
  FF_MACHINERY7,
  FF_MACHINERY8,
  FF_MACHINERY9,
  FF_MACHINERY10,

  FF_COMMS1 = offsetof(FAULT_TABLE,CommunicationFaults)*8,
  FF_COMMS2,
  FF_COMMS3,
  FF_COMMS4,
  FF_COMMS5,
  FF_COMMS6,
  FF_COMMS7,
  FF_COMMS8,
  FF_COMMS9,
  FF_COMMS10,
  FF_COMMS11,
  FF_COMMS12,
  FF_COMMS13
}FAULT_FLAGS;

Is there a way that I can create a similar enumeration, based on a data structure in C#?

Add a Flags attribute to your enum. See http://msdn.microsoft.com/query/dev10.query?appId=Dev10IDEF1&l=EN-US&k=k(SYSTEM.FLAGSATTRIBUTE);k(TargetFrameworkMoniker-%22.NETFRAMEWORK%2cVERSION%3dV4.0%22);k(DevLang-CSHARP)&rd=true

You can get the offset of an element of a struct with Marshal.OffsetOf

http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.offsetof.aspx

Your struct can be created in pretty much the same way although you need to ensure you specify the layout (although I suppose this depends on how the struct is instantiated).

http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.structlayoutattribute(v=vs.71).aspx

However... the problem will come with the Enum. Enum values need to be compile time constants and Marshal.OffsetOf isn't. So you may have to store the offsets as static members of a class instead.

I also think you'll probably have to stray into unsafe code to make any real use of these offsets once you have them - and there is probably a better way to approach whatever you want to do in managed code.

You can create an enum to map the bits/flags, but you cannot map more than 32 bits.

In your example, I would create several const of long (64 bits). That won't solve the bit limitation when your array is very long (e.g. the first one).

Another trick is creating a static function that gives you the value of the bit (as a bool), upon the bit position in the array. In this case, the position (being a constant) is surely within the int range.

public static bool GetBit(byte[] buffer, int pos)
{
  return (buffer[pos >> 3] & (1 << (pos & 7)) != 0);
}

Hope it helps.

Create an enum that specifies the bit-offset within each set of bytes:

enum PowerSupplyFaults
{
    PowerSupplyFault1, PowerSupplyFault2, PowerSupplyFault3
}

PowerSupplyFault1 will be auto-assigned 0, Fault2 as 1, etc.

Assuming you receive a struct that mirrors the C version:

struct FaultTable
{
    // ...

    public byte[] PowerSupplyFaults;
    public byte[] MachineFaults;

    // ...
}

You can test for a fault by feeding the bytes into a BitArray and testing by index:

FaultTable faults = GetFaultTable();
BitArray psu_faults = new BitArray( fault_table.PowerSupplyFaults );

if ( psu_faults[ (int)PowerSupplyFaults.PowerSupplyFault3 ] )
{
    // ...
}

Alternatively, you can walk all the bits and see which are set:

for ( int i = 0; i < psu_faults.Length; i++ )
{
    if ( psu_faults[ i ] )
    {
        Console.WriteLine( "PSU fault: {0}", (PowerSupplyFaults)i );
    }
}