From binary to hex in wiegand

[kryptonite88]

Hello,

I’m developing an application that needs to send a wiegand signal. I’m using a serial to wiegand converter for that. I’m having a problem though, with sending serial commands.

The documentation specifies how the frame should look. In the frame is a data portion. This contains the wiegand data that is to be converted. In the picture below is the example from the documentation.

The top red part is the 26bit wiegand data. The fist bit is parity followed by 8 bits of facility code followed by 16 bits of id code ending with another parity bit. The bottom red part shows how that is going to look in the frame.

So my question is: how do I get a user id like 15 to the binary data in the top and then to the hexadecimal data shown below using c#.

With kind regards,
Ben

[GaryTexmo]

Have a look here...

http://msdn.microsoft.com/en-us/libr...8VS.71%29.aspx
http://msdn.microsoft.com/en-us/libr...8VS.71%29.aspx

You can supply a base to some of the methods of this class. I believe Convert.ToString(number, base) will get you the string representation.

[jensa]

Hi Ben,

The static class BitConverter will help you a lot (you can also combine bit/byte handling with pointers in unsafe code), check out MSDN docs. But I am not really sure what you are looking to accomplish so I cannot help you out in detail before I get more info what you exactly need to do. But I will give my best to shortly get you some info of bit/byte handling in C# managed code.

Let's say that you have a byte array:

// Let's create the frame with 20 bytes as your image show
byte[] frame = new byte[20];
 
// To modify/set single bytes, example setting first byte to hex
// 0x55
frame[0] = 0x55;
 
// or use int values and cast them to byte, remember that 0-255 is only valid
// otherwise the result will be truncated.
frame[0] = (byte)85;
 
// if you need to put a unsigned 16-bit integer into the frame you can use.
// Observe order, big endian or little endian
byte[] value = BitConvert.GetBytes(UInt16.MaxValue);
frame[1] = value[0];
frame[2] = value[1];
// above method enables you to set big endian or little endian, e.g MSB / LSB order
 
//To modify single bits inside 1 byte you can do bit OR.
frame[2] = frame[2] | 0x01;

For bitwise methods see,
http://www.blackwasp.co.uk/CSharpLogicalBitwiseOps.aspx

EDIT:
You can also use a shifting method to "shift in values above 1-byte" then you don't need to use BitConverter.GetBytes.


Regards,

Jens

[kryptonite88]

Well I’m using a converter for serial to wiegand. The command u see in the picture is used to send a wiegand frame. A wiegand frame send a id to a other decice. The id is composed from the 16 bits user code portion of the bits. In the picture I believe there sending the id 1943. So I made a program that converts a int to a string of bits and then converts that to a string of hex and then converts it to a byte array that I send. I have been testing this all day yesterday but it does not seem to work. I think there something wrong with my conversion. I user the code below:

 public override byte[] CommandArray
{
get
{
byte[] returnVal = new byte[FRAME_SIZE];
 
// Start
returnVal[0] = Commands.SYNC;
returnVal[1] = Commands.SYNC;
 
// Command
returnVal[2] = cmd;
 
// Size
returnVal[3] = 0x1A;
 
// Data
Factory.UserIdToWiegandFrame(id).CopyTo(returnVal, 4);
 
// Wiegand pulse width
returnVal[16] = 0xFF;
 
// Wiegand bit period
returnVal[17] = 0x00;
 
// Cariage return
returnVal[19] = Commands.CR;
 
//string[] test = new string[FRAME_SIZE];
//for (int i = 0; i < returnVal.Length; i++)
// test[i] = Convert.ToString(returnVal[i], 16);
 
return returnVal;
}
}
 

This is the factory code:

 public static byte[] UserIdToWiegandFrame(int userId)
{
StringBuilder sb = new StringBuilder();
StringBuilder id = new StringBuilder();
 
// Parity bit
sb.Append("1");
 
// Facillity code
sb.Append("00000000");
 
// Id toevoegen
id.Append(Convert.ToString(userId, 2));
 
// 0 inserten tot het id 16 bit lang is.
while (id.Length < 16)
{
id.Insert(0, "0");
}
 
sb.Append(id.ToString());
 
// Parity bit
sb.Append("0");
 
string temptest = sb.ToString();
 
// 0 toevoegen tot de frame 96 bit lang is.
while (sb.Length < 96)
{
sb.Append("0");
}
 
string testagain = BinToHex(sb.ToString());
 
int tmp = 0;
return GetBytes(BinToHex(sb.ToString()), out tmp);
}
 
 public static string BinToHex(string bin)
{
StringBuilder hex = new StringBuilder();
int remainer = bin.Length % 4;
 
for (int i = 0; i < remainer; i++)
{
bin.Insert(0, "0");
}
 
//return Convert.ToString(Convert.ToInt32(bin, 2), 16);
 
int count = bin.Length / 4;
 
for (int j = 0; j < count; j++)
{
int index = ((j * 4 - 1) < 0) ? 0 : (j * 4);
//Console.WriteLine(string.Format("BIN: {0}", bin.Substring(index, 4)));
//Console.WriteLine(string.Format("DEC: {0}", Convert.ToInt32(bin.Substring(index, 4), 2)));
//Console.WriteLine(string.Format("HEX: {0}", Convert.ToString(Convert.ToInt32(bin.Substring(index, 4), 2), 16)));
hex.Append(Convert.ToString(Convert.ToInt32(bin.Substring(index, 4), 2), 16));
}
 
return hex.ToString();
}
 
 public static byte[] GetBytes(string hexString, out int discarded)
{
discarded = 0;
string newString = "";
char c;
// remove all none A-F, 0-9, characters
for (int i = 0; i < hexString.Length; i++)
{
c = hexString[i];
if (IsHexDigit(c))
newString += c;
else
discarded++;
}
// if odd number of characters, discard last character
if (newString.Length % 2 != 0)
{
discarded++;
newString = newString.Substring(0, newString.Length - 1);
}
 
int byteLength = newString.Length / 2;
byte[] bytes = new byte[byteLength];
string hex;
int j = 0;
for (int i = 0; i < bytes.Length; i++)
{
hex = new String(new Char[] { newString[j], newString[j + 1] });
bytes[i] = HexToByte(hex);
j = j + 2;
}
return bytes;
}
 

Would the bitconverter give me a different result or the same?

[jensa]

Hi,

So if I understand you right you would like to compose the 16-bits ID of the 26-bits in the frame. You current method i based on convertering the 26-bits into a string of bits where you then can modify the bits and last recreating the 26-bits (hex). If this is the case (and I understand right) I would not recommend this.

You should shift data into position, example if you are using and UInt16 (ushort). With shifting you are "extracting the 1-byte" values and moves them out/in.

frame[firstpos] = value << 8; // shift MSB 8 bits to left
frame[secondpos] = value << 16; // shift LSB 16 bits to left

But if you just need to modify the 16-bit you can just also convert these "bytes" into a UInt16 and go and modify it and they recreate the bytes by using BitConverter.GetBytes(of your UInt16).


Regards,

Jens

[kryptonite88]

So I could skip the whole to string and to hex method by just shifting the bits next to each other? So to complete the entire frame 0f 36 bits I could just shift the first parity bit + 8 bit facility code + 16 bit usercode + parity bit and the convert it to a byte array?

[jensa]

Yes. I also made a mistake in the last example, you need to cast a ushort to byte when shifting also, otherwise a compile error will be shown. Shifting is the right method if you need to control different sets of bits and put/unput the data into byte array.

Regards,

Jens