|
|
using System;
|
|
|
using System.Runtime.InteropServices;
|
|
|
using System.Text;
|
|
|
|
|
|
namespace SlnMesnac.RfidUpload.Common
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// 工具类
|
|
|
/// </summary>
|
|
|
public sealed class MsgUtil
|
|
|
{
|
|
|
|
|
|
private static readonly Lazy<MsgUtil> lazy = new Lazy<MsgUtil>(() => new MsgUtil());
|
|
|
|
|
|
public static MsgUtil Instance
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return lazy.Value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private MsgUtil() { }
|
|
|
|
|
|
#region 数据解析公共方法
|
|
|
/// <summary>
|
|
|
/// 字节数组转换成结构体
|
|
|
/// </summary>
|
|
|
/// <param name="buf"></param>
|
|
|
/// <param name="len"></param>
|
|
|
/// <param name="type"></param>
|
|
|
/// <returns></returns>
|
|
|
public static object BytesToStruct(byte[] buf, int len, Type type)
|
|
|
{
|
|
|
object rtn;
|
|
|
IntPtr buffer = Marshal.AllocHGlobal(len);
|
|
|
Marshal.Copy(buf, 0, buffer, len);
|
|
|
try
|
|
|
{
|
|
|
rtn = Marshal.PtrToStructure(buffer, type);
|
|
|
Marshal.FreeHGlobal(buffer);
|
|
|
}
|
|
|
catch (Exception)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
return rtn;
|
|
|
}
|
|
|
|
|
|
public string StringToHexString(string s, Encoding encode)
|
|
|
{
|
|
|
|
|
|
byte[] b = encode.GetBytes(s); //按照指定编码将string编程字节数组
|
|
|
string result = string.Empty;
|
|
|
for (int i = 0; i < b.Length; i++) //逐字节变为16进制字符，以%隔开
|
|
|
{
|
|
|
result += "%" + Convert.ToString(b[i], 16);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
//// <summary>
|
|
|
/// 结构体转byte数组
|
|
|
/// </summary>
|
|
|
/// <param name="structObj">要转换的结构体</param>
|
|
|
/// <returns>转换后的byte数组</returns>
|
|
|
public static byte[] StructToBytes(object structObj)
|
|
|
{
|
|
|
//得到结构体的大小
|
|
|
int size = Marshal.SizeOf(structObj);
|
|
|
//创建byte数组
|
|
|
byte[] bytes = new byte[size];
|
|
|
//分配结构体大小的内存空间
|
|
|
IntPtr structPtr = Marshal.AllocHGlobal(size);
|
|
|
//将结构体拷到分配好的内存空间
|
|
|
Marshal.StructureToPtr(structObj, structPtr, false);
|
|
|
//从内存空间拷到byte数组
|
|
|
Marshal.Copy(structPtr, bytes, 0, size);
|
|
|
//释放内存空间
|
|
|
Marshal.FreeHGlobal(structPtr);
|
|
|
//返回byte数组
|
|
|
return bytes;
|
|
|
}
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
#region 消息验证方法
|
|
|
|
|
|
/// <summary>
|
|
|
/// CS和校验
|
|
|
/// </summary>
|
|
|
/// <param name="Abyte"></param>
|
|
|
/// <returns></returns>
|
|
|
public byte Check_CS(byte[] Abyte)
|
|
|
{
|
|
|
byte result = new byte();
|
|
|
try
|
|
|
{
|
|
|
int num = 0;
|
|
|
for (int i = 0; i < Abyte.Length; i++)
|
|
|
{
|
|
|
num = (num + Abyte[i]) % 256;
|
|
|
}
|
|
|
result = (byte)num;
|
|
|
}
|
|
|
catch
|
|
|
{
|
|
|
result = 0;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// BCC异或取反校验
|
|
|
/// </summary>
|
|
|
/// <param name="data"></param>
|
|
|
/// <returns></returns>
|
|
|
public string getBCC(byte[] data)
|
|
|
{
|
|
|
String ret = "";
|
|
|
byte[] BCC = new byte[1];
|
|
|
for (int i = 0; i < data.Length; i++)
|
|
|
{
|
|
|
BCC[0] = (byte)(BCC[0] ^ data[i]);
|
|
|
}
|
|
|
String hex = ((~BCC[0]) & 0xFF).ToString("X");//取反操作
|
|
|
if (hex.Length == 1)
|
|
|
{
|
|
|
hex = '0' + hex;
|
|
|
}
|
|
|
ret += hex.ToUpper();
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
static int BytesToInt(byte[] b, int length)
|
|
|
{
|
|
|
int temp = 0;
|
|
|
for (int i = 0; i <= length - 1 && i < 4; i++)
|
|
|
{
|
|
|
temp += (int)(b[i] << (i * 8));
|
|
|
}
|
|
|
return temp;
|
|
|
}
|
|
|
|
|
|
public static byte[] CalculateVerify(byte[] pMessage, int iLength)
|
|
|
{
|
|
|
UInt16 i;
|
|
|
int iVerify = 0;
|
|
|
|
|
|
iVerify = pMessage[0];
|
|
|
for (i = 0; i < iLength - 1; i++)
|
|
|
{
|
|
|
iVerify = iVerify + pMessage[i + 1];
|
|
|
}
|
|
|
return BitConverter.GetBytes(Convert.ToUInt16(iVerify));
|
|
|
}
|
|
|
#endregion
|
|
|
public byte[] HexStrTorbytes(string strHex)//e.g. " 01 01" ---> { 0x01, 0x01}
|
|
|
{
|
|
|
strHex = strHex.Replace(" ", "");
|
|
|
if ((strHex.Length % 2) != 0)
|
|
|
strHex += " ";
|
|
|
byte[] returnBytes = new byte[strHex.Length / 2];
|
|
|
for (int i = 0; i < returnBytes.Length; i++)
|
|
|
returnBytes[i] = Convert.ToByte(strHex.Substring(i * 2, 2), 16);
|
|
|
return returnBytes;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将字符串强制转换成int，转换失败则返回0
|
|
|
/// </summary>
|
|
|
/// <param name="str"></param>
|
|
|
/// <returns></returns>
|
|
|
public int ParseToInt(string str)
|
|
|
{
|
|
|
int returnInt = 0;
|
|
|
|
|
|
if (str == null || str.Trim().Length < 1)
|
|
|
{
|
|
|
return returnInt;
|
|
|
}
|
|
|
|
|
|
if (int.TryParse(str, out returnInt))
|
|
|
{
|
|
|
return returnInt;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public byte[] HexToString(string Str)
|
|
|
{
|
|
|
byte[] str = new byte[Str.Length / 2];
|
|
|
for (int i = 0; i < str.Length; i++)
|
|
|
{
|
|
|
int temp = Convert.ToInt32(Str.Substring(i * 2, 2), 16);
|
|
|
str[i] = (byte)temp;
|
|
|
}
|
|
|
return str;
|
|
|
}
|
|
|
public string ConverToString(byte[] data)
|
|
|
{
|
|
|
string str;
|
|
|
StringBuilder stb = new StringBuilder();
|
|
|
for (int i = 0; i < data.Length; i++)
|
|
|
{
|
|
|
if ((int)data[i] > 15)
|
|
|
{
|
|
|
stb.Append(Convert.ToString(data[i], 16).ToUpper()); //添加字符串
|
|
|
}
|
|
|
else //如果是小于0F需要加个零
|
|
|
{
|
|
|
stb.Append("0" + Convert.ToString(data[i], 16).ToUpper());
|
|
|
}
|
|
|
}
|
|
|
str = stb.ToString();
|
|
|
return str;
|
|
|
}
|
|
|
|
|
|
public string bytesToHexStr(byte[] bytes, int iLen)
|
|
|
{
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
if (bytes != null)
|
|
|
{
|
|
|
for (int i = 0; i < iLen; i++)
|
|
|
{
|
|
|
sb.Append(bytes[i].ToString("X2"));
|
|
|
}
|
|
|
}
|
|
|
return sb.ToString();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 从十进制转换到十六进制
|
|
|
/// </summary>
|
|
|
/// <param name="ten"></param>
|
|
|
/// <returns></returns>
|
|
|
public string Ten2Hex(string ten)
|
|
|
{
|
|
|
ulong tenValue = Convert.ToUInt64(ten);
|
|
|
ulong divValue, resValue;
|
|
|
string hex = "";
|
|
|
do
|
|
|
{
|
|
|
//divValue = (ulong)Math.Floor(tenValue / 16);
|
|
|
|
|
|
divValue = (ulong)Math.Floor((decimal)(tenValue / 16));
|
|
|
|
|
|
resValue = tenValue % 16;
|
|
|
hex = tenValue2Char(resValue) + hex;
|
|
|
tenValue = divValue;
|
|
|
}
|
|
|
while (tenValue >= 16);
|
|
|
if (tenValue != 0)
|
|
|
hex = tenValue2Char(tenValue) + hex;
|
|
|
return hex;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 异或和校验
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public string CalculateXORChecksum(byte[] bytes)
|
|
|
{
|
|
|
byte checksum = bytes[0];
|
|
|
foreach (byte b in bytes)
|
|
|
{
|
|
|
checksum ^= b;
|
|
|
}
|
|
|
|
|
|
return checksum.ToString("X2");
|
|
|
}
|
|
|
|
|
|
public string tenValue2Char(ulong ten)
|
|
|
{
|
|
|
switch (ten)
|
|
|
{
|
|
|
case 0:
|
|
|
case 1:
|
|
|
case 2:
|
|
|
case 3:
|
|
|
case 4:
|
|
|
case 5:
|
|
|
case 6:
|
|
|
case 7:
|
|
|
case 8:
|
|
|
case 9:
|
|
|
return ten.ToString();
|
|
|
case 10:
|
|
|
return "A";
|
|
|
case 11:
|
|
|
return "B";
|
|
|
case 12:
|
|
|
return "C";
|
|
|
case 13:
|
|
|
return "D";
|
|
|
case 14:
|
|
|
return "E";
|
|
|
case 15:
|
|
|
return "F";
|
|
|
default:
|
|
|
return "";
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|