`using System; using System.Collections.Generic; using System.Linq; using System.Text; using
System.Threading.Tasks; using ProtocolSimulation.Coordinate;
namespace ProtocolSimulation.Common {
/// <summary>
/// 字节数组和字节处理工具类
/// </summary>
public class BytesUtils
{
/// <summary>
/// 纬度编码：
///
1、21,22位
///
纬度：1位符号，7位整数，13位小数；范围：[-127.8191,127.8191]
///
经度：1位符号，7位整数，14位小数；范围：[-127.16383,127.16383]
///
2、25,26位
///
纬度：1位符号，7位整数，17位小数；范围：[-127.131071,127.131071]
///
经度：1位符号，7位整数，18位小数；范围：[-127.262143,127.262143]
/// </summary>
/// <param name="latitude"></param>
/// <param name="bit"></param>
/// <returns></returns>
public static string LatLon2Chars(double latlng, int bit)
{
Console.WriteLine("经纬度LatLon2Chars" + latlng);
string str = "";
// 1位符号
str += (latlng < 0) ? '1' : '0';
double tmp = Math.Abs(latlng);
// Degree7位
int degree = LatLngDecimalAndDMS.ExtractDegrees(tmp);
str += Int2Str(degree, 7);
// Minute6位
int minute = LatLngDecimalAndDMS.ExtractMinutes(tmp);
str += Int2Str(minute, 6);
// Second6位
int second = LatLngDecimalAndDMS.ExtractSeconds(tmp);
str += Int2Str(second, 6);
if (bit == 21)
{ // 8191
str += '0';
}
else if (bit == 22)
{ // 16383
str += "00";
}
else if (bit == 25)
{ // 131071
str += "00000";
}
else if (bit == 26)
{ // 262143
str += "000000";
}
else
{
// 其他位数暂时不考虑
}
return str;
}
public static double Chars2LatLon(string str)
{
Console.WriteLine("经纬度" + str);
// 1位符号
int flag = (str.Substring(0,1).ToCharArray()[0] == '1') ? -1 : 1;
// Degree7位
int degree = Chars2Int(str.Substring(1, 7).ToCharArray(), 7);
// Minute6位
int minute = Chars2Int(str.Substring(8, 6).ToCharArray(), 6);
// Second6位
int second = Chars2Int(str.Substring(14, 6).ToCharArray(), 6);
return Math.Round(LatLngDecimalAndDMS.ConvertToDouble(degree, minute, second) * f
}
/// <summary>
/// 组装47001报头和6017报文
/// </summary>
/// <param name="hdata"></param>
/// <param name="data"></param>
/// <returns></returns>
public static byte[] UnionBytes(byte[] hdata, byte[] data)
{
byte[] sendData = new byte[hdata.Length + data.Length];
for (int i = 0; i < hdata.Length; i++)
{
sendData[i] = hdata[i];
}
for (int i = 0; i < data.Length; i++)
{
sendData[hdata.Length + i] = data[i];
}
return sendData;
}
/// <summary>
/// 将字符串转换成N位的二进制字符串
/// </summary>
/// <param name="str">字符串</param>
/// <param name="N">二进制位数，一般为8或者7</param>
/// <returns></returns>
public static string Str2BinStr(string str, int N)
{
byte[] data = System.Text.Encoding.Default.GetBytes(str);
StringBuilder sb = new StringBuilder(data.Length * 8);
foreach (byte b in data)
{
sb.Append(Convert.ToString(b, 2).PadLeft(N, '0'));
}
return sb.ToString();
}
/// <summary>
/// 字符串转换成字节，每N位Char转换成一个字节，高位在前地位在后
/// </summary>
/// <param name="str">待转换字符串</param>
/// <param name="N">一般为7或者8</param>
/// <returns></returns>
public static byte[] CharsToByte(string str, int N)
{
char[] chars = str.ToCharArray();
int byteCount = chars.Length / N;
byte[] data = new byte[byteCount];
int value = 0;
for (int i = 0; i < byteCount; i++)
{
if (N == 8)
{
value = (chars[N * i] - '0') * 128 + (chars[1 + N * i] - '0') * 64
+ (chars[2 + N * i] - '0') * 32 + (chars[3 + N * i] - '0') * 16
+ (chars[4 + N * i] - '0') * 8 + (chars[5 + N * i] - '0') * 4
+ (chars[6 + N * i] - '0') * 2 + (chars[7 + N * i] - '0');
}
else if (N == 7)
{
value = (chars[N * i] - '0') * 64
+ (chars[1 + N * i] - '0') * 32 + (chars[2 + N * i] - '0') * 16
+ (chars[3 + N * i] - '0') * 8 + (chars[4 + N * i] - '0') * 4
+ (chars[5 + N * i] - '0') * 2 + (chars[6 + N * i] - '0');
}
data[i] = (byte)value;
}
return data;
}
public static string ReversalStrs(string str, int N)
{
string result = "";
int len = str.Length / N;
for (int i = 0; i < len; i++)
{
result += ReversalStr(str.Substring(i * N, N), N);
}
return result;
}
/// <summary>
/// 字符串序列反转，默认将[0,N-1]反转
/// </summary>
/// <param name="str"></param>
/// <param name="N">需要反转的长度</param>
/// <returns></returns>
public static string ReversalStr(string str, int N)
{
string revStr = "";
char[] chars = str.ToCharArray();
for (int i = 0; i < N; i++)
{
revStr += chars[N - 1 - i];
}
return revStr;
}
/// <summary>
/// 将字符串中每个字节拆成7或者8个二进制字符串
/// </summary>
/// <param name="str"></param>
/// <param name="N">7或者8</param>
public static string StrToChars(string str, int N)
{
// 英文数字1字节，中文2字节（暂时不好处理）
byte[] bytes = System.Text.Encoding.Default.GetBytes(str);
return ByteToChars(bytes, N);
}
/// <summary>
/// 将字节数组中每个字节拆成7或者8个二进制字符串
/// </summary>
/// <param name="bytes"></param>
/// <param name="N">7或者8</param>
/// <returns></returns>
public static string ByteToChars(byte[] bytes, int N)
{
string charStr = "";
// 字节长度
int len = bytes.Length;
char zero = '0';
int tmp;
for (int position = 0; position < len; position++)
{
//一个字节变七个
for (int j = 0; j < N; j++)
{
tmp = (int)bytes[position];
switch (j)
{
case 0: zero = (char)(tmp & 0x01); break;
case 1: tmp = (tmp & 0x02); zero = (char)(tmp >> 1); break;
case 2: tmp = (char)(tmp & 0x04); zero = (char)(tmp >> 2); break;
case 3: tmp = (char)(tmp & 0x08); zero = (char)(tmp >> 3); break;
case 4: tmp = (char)(tmp & 0x10); zero = (char)(tmp >> 4); break;
case 5: tmp = (char)(tmp & 0x20); zero = (char)(tmp >> 5); break;
case 6: tmp = (char)(tmp & 0x40); zero = (char)(tmp >> 6); break;
case 7: tmp = (char)(tmp & 0x80); zero = (char)(tmp >> 7); break;
}
tmp = (int)zero;
zero = (char)(tmp | 0x30);
charStr = charStr + zero.ToString();
}
}
return charStr;
}
/// <summary>
/// 转换十六进制字符串位字节数组
/// </summary>
/// <param name="msg">待转换十六进制字符串</param>
/// <returns>字节数组</returns>
public static byte[] HexToByte(string msg)
{
// 将字符串中的所有空格去除
msg = msg.Replace(" ", "");
// 创建字符串长度一半的字节数组（因为一个十六进制包含两个长度字符）
byte[] comBuffer = new byte[msg.Length / 2];
for (int i = 0; i < msg.Length; i += 2)
// 将每两个字符转换成一个字节，并添加到数组中
comBuffer[i / 2] = (byte)Convert.ToByte(msg.Substring(i, 2), 16);
return comBuffer;
}
/// <summary>
/// 将字节数组转换成十六进制字符串
/// </summary>
/// <param name="comByte">待转换字节数组</param>
/// <returns>十六进制字符串</returns>
public static string ByteToHex(byte[] comByte)
{
StringBuilder builder = new StringBuilder(comByte.Length * 3);
foreach (byte data in comByte)
// 将一个字节转换成字符串，并添加到builder后面
builder.Append(Convert.ToString(data, 16).PadLeft(2, '0').PadRight(3, ' '));
return builder.ToString().ToUpper();
}
/// <summary>
/// 二进制字符串转换成整数，如111转换成7
/// </summary>
/// <param name="value"></param>
/// <param name="length"></param>
/// <returns></returns>
public static int Chars2Int(char[] value, int length)
{
int result = 0;
for (int i = length - 1; i >= 0; i--)
{
result = result * 2 + (value[i] - '0');
}
return result;
}
public static long Chars2Long(char[] value, int length)
{
long result = 0;
for (int i = length - 1; i >= 0; i--)
{
result = result * 2 + (value[i] - '0');
}
return result;
}
public static double ConvertToDouble(int degree,int minute,int second) {
return degree+(double)minute/60+(double)second/3600;
}
/// <summary>
/// Int值转换成string，如7转换成111
/// </summary>
/// <param name="value"></param>
/// <param name="length"></param>
/// <returns></returns>
public static string Int2Str(int value, int length)
{
string result = "";
int tmp;
for (int i = length; i > 0; i--)
{
tmp = value % 2 + 48;
result = result + ((char)tmp).ToString();
value = value / 2;
}
return result;
}
public static string Long2Str(long value, int length)
{
string result = "";
long tmp;
for (int i = length; i > 0; i--)
{
tmp = value % 2 + 48;
result = result + ((char)tmp).ToString();
value = value / 2;
}
return result;
}
/// <summary>
/// 将字节列表转换成byte数组
/// </summary>
/// <param name="buffer">字节列表</param>
/// <param name="startIndex">起始下标</param>
/// <param name="length">提取长度</param>
/// <returns>字节数组</returns>
public static byte[] List2Bytes(List<byte> buffer, int startIndex, int length)
{
byte[] result = new byte[length];
for (int i = 0; i < length; i++)
{
result[i] = buffer[startIndex + i];
}
return result;
}
/// <summary>
/// 截取字节数组
/// </summary>
/// <param name="srcBytes">要截取的字节数组</param>
/// <param name="startIndex">开始截取位置的索引</param>
/// <param name="length">要截取的字节长度</param>
/// <returns>截取后的字节数组</returns>
public static byte[] SubByte(byte[] srcBytes, int startIndex, int length)
{
System.IO.MemoryStream bufferStream = new System.IO.MemoryStream();
byte[] returnByte = new byte[] { };
if (srcBytes == null) { return returnByte; }
if (startIndex < 0) { startIndex = 0; }
if (startIndex < srcBytes.Length)
{
if (length < 1 || length > srcBytes.Length - startIndex)
{
length = srcBytes.Length - startIndex;
}
bufferStream.Write(srcBytes, startIndex, length);
returnByte = bufferStream.ToArray();
bufferStream.SetLength(0);
bufferStream.Position = 0;
}
bufferStream.Close();
bufferStream.Dispose();
return returnByte;
}
}
}`