Ufdjrw

I'm trying to communicate with a PLC that accepts/sends 16-bit values, with each single bit allowing for a check to happen or not.

To do this, I've been attempting to use the .Net BitArray but the results have been anything but succesful.

The underlaying structure is made out of an array of two bytes, both bytes are initialised with the value 0.

When I create a new bitarray using one of these bytes, I expected to get an array with 8 values set to false. This is not the case.

With a byte value of 0, the length and count of the bitarray is also zero. While I could presume that leading zeros are dropped, this seems very counterintuitive.

When I create a bitarray using a byte with the value of 200, I expected to get an array with 8 values (True, True, False, False, True, False, False, False). However, I instead get a bitarray with a length and count of 200?

Code is currently this :

Private FaultBits as Byte = 0
Public Sub SetBitValue(index As Integer, value As Boolean)
 Try
 If index < 0 Then
 Throw New Exception("Index is below zero!")
 End If

 If index > 7 Then
 Throw New Exception("Index out of bounds! Maximum allowed index value is 7")
 End If

 'If BitConverter.IsLittleEndian Then
 'ToDo
 'End If

 Dim bitArray_Section As BitArray = Nothing

 bitArray_Section = New BitArray(FaultBits)
 'bitArray_Section.Length = 8 'Truncates incorrectly
 bitArray_Section.Item(index) = value 'Set the individual bit
 FaultBits = ConvertToByte(bitArray_Section) 'Set back to byte


 Catch ex As Exception
 Throw New Exception("clsFaultBits : SetBitValue : w. Index " & index & " : Exception : " & ex.Message())
 End Try
End Sub

And the get-equivalent :

 Public Function GetBitValue(index As Integer) As Boolean
 Try
 If index < 0 Then
 Throw New Exception("Index is below zero!")
 End If

 If index > 7 Then
 Throw New Exception("Index out of bounds! Maximum allowed index value is 7")
 End If


 Dim bitArray_Section As BitArray = Nothing

 bitArray_Section = New BitArray(FaultBits)
 'bitArray_Section.Length = 8
 Return bitArray_Section.Item(index)

 Catch ex As Exception
 Throw New Exception("clsFaultBits : GetBitValue : w. Index " & index & " : Exception : " & ex.Message())
 End Try
End Function

The convert function, I assumed this would have a length of 8 which is wrong :

Public Function ConvertToByte(bits As BitArray) As Byte
 Try
 If bits.Count <> 8 Then
 Throw New Exception("Invalid amount of bits!")
 End If

 Dim returnbyte(1) As Byte
 bits.CopyTo(returnbyte, 0)
 Return returnbyte(0)
 Catch ex As Exception
 Throw New Exception("clsFaultBits : ConvertToByte : Exception : " & ex.Message())
 End Try
End Function

ByteValue :: BitarrayLength / Count

0 :: 0 / 0

200 :: 200 / 200

10 :: 10 / 10

What I would like to accomplish :

Receive a byte (1-0-0-1-0-0-1-0)

Enable the booleans in the program by reading the individual bits:
Check1, Check4, Check7

Set the individual bits of the output Byte starting at 0-0-0-0-0-0-0-0

Turn on 5 : 0-0-0-0-1-0-0-0

Turn on 2 : 0-1-0-0-1-0-0-0

Send Byte

Am I completely misusing the BitArray class? What am I doing wrong?
What would allow me to change individual bit values without running into this chaos?

Why is the length / count of the BitArray the same value as the Byte, instead of the amount of bits the Byte is composed of?

I am aware the code has yet to take in account endian-ness.

Thanks in advance,

SOLVED :

I did not realise that sending a non-array byte to the BitArray would implicitly cast it to an integer and therefore it creates a BitArray which has a length/count equal to value of the byte. Which now makes complete sense.

It also made me realise my compiler warning for implicit casting does not trigger because Byte to Integer is not regarded as implicit, since I'm usually notified whenever an implicit cast happens.

Thanks for the help!

I'm not sure BitArray class is what you need. Anyway you can't create a BitArray from an Integer value. The statement New BitArray(200), for example, will create a BitArray of 200 items all set to 0.
If you need to send 16-bit values I think it would be simpler to use UShort (also called UInt16) datatype instead of a BitArray and use @djv suggestion to check the single bit. To set bits you have to make use of some "binary" algebra and the And operator. Remember to always use unsigned datatypes and be aware that bit count starts from right.

Unfortunately BitArray does not allow you to convert to/from a 16 bit value.

However, it does work for Byte() and Integer().

So we can convert from/to a 32 bit integer and that should work just fine.

It also not clear how you have your original data. As two separate bytes, or as a single 16 bit value?

I will assume a single unsinged 16 bit value.

So we will have this code:

Sub Testset()

 Dim i16 As UInt16
 i16 = 255
 SetBits(i16, 9, False)
 SetBits(i16, 9, True)

 Debug.Print(GetBits(i16, 9).ToString)

End Sub

Output from above:

00000000 11111111
00000010 11111111
True

And the two routines are:

Public Sub SetBits(ByRef My16Bits As UInt16, MyINdex As Integer, MyValue As Boolean)

 ' toss the passed 16 bits into a 32 bit interger 
 ' we do this, since the conversion routines only work
 ' for built in primitaves ike byte() or integer(). 

 Dim My32(0) As Integer
 My32(0) = My16Bits

 Dim My32Bits As New BitArray(New Integer() My32(0))

 My32Bits(MyINdex) = MyValue

 ' now convert bit array back to our 32 bit integer
 My32Bits.CopyTo(My32, 0)

 ' now copy our 32 bit interger back to that 16 bit
 My16Bits = My32(0)

 For i = 15 To 0 Step -1
 Debug.Write(IIf(My32Bits(i), "1", "0"))
 If i = 8 Then Debug.Write(" ")
 Next i
 Debug.Print("")

End Sub

Public Function GetBits(My16Bits As UInt16, MyIndex As Integer) As Boolean

 ' convert Int16 to bit array
 Dim My32(0) As Integer
 My32(0) = My16Bits
 Dim My32Bits As New BitArray(New Integer() My32(0))

 Return My32Bits(MyIndex)

End Function

Of course one would remove that loop that displays the values.

And if this had to be called a "lot" of times before you want the bit array converted one way or the other - then you might separate out the converting to a bit array as a separate routine, and the pass that to the get/set bit routines and then do a final call of code to convert the bitArrary back to the Int16 value. It really depends on how many times you expect to get/set bits. So 1 or 2 times, then above is fine. If you have to always test many bits and set many bits, then convert the value to a bit array before you call + use the two routines to set/get the value. So the code that converts to and from the bit array could be separated out as separate code.