低层通讯常用的字符及字符串转换函数

风火石

1.     public static string byteStr(ushort val)
   
2.     {
   
3.         byte num = (byte) ((val >> 8) & 0xff);
   
4.         byte num2 = (byte) (val & 0xff);
   
5.         return string.Format("{0:X2} {1:X2}", num, num2);
   
6.     }
   
7. 
   
8.     public static ulong HexToInt(string hexString)
   
9.     {
   
10.         string str = "0123456789abcdef";
    
11.         string str2 = hexString.ToLower();
    
12.         if ((str2.Length > 2) && str2.Substring(0, 2).Equals("0x"))
    
13.         {
    
14.             str2 = str2.Substring(2, str2.Length - 2);
    
15.         }
    
16.         string str3 = "";
    
17.         int length = str2.Length;
    
18.         for (int i = length - 1; i >= 0; i--)
    
19.         {
    
20.             str3 = str3 + str2[i];
    
21.         }
    
22.         ulong num3 = 0L;
    
23.         ulong num4 = 1L;
    
24.         for (int j = 0; j < length; j++)
    
25.         {
    
26.             uint index = (uint) str.IndexOf(str3[j]);
    
27.             num3 += (j == 0) ? ((ulong) index) : (num4 * index);
    
28.             num4 *= (ulong) 0x10L;
    
29.         }
    
30.         return num3;
    
31.     }
    
32. 
    
33.     public static bool ParseHexData(ArrayList rawList, byte[] FwBuf, ref ushort FwLen, ref ushort FwOff)
    
34.     {
    
35.         string str;
    
36.         for (int i = rawList.Count - 1; i >= 0; i--)
    
37.         {
    
38.             str = (string) rawList[i];
    
39.             if ((str.Length > 0) && (((int) HexToInt(str.Substring(7, 2))) != 0))
    
40.             {
    
41.                 rawList.Remove(rawList[i]);
    
42.             }
    
43.         }
    
44.         FwLen = 0;
    
45.         FwOff = _MAX_FW_SIZE;
    
46.         for (int j = 0; j < _MAX_FW_SIZE; j++)
    
47.         {
    
48.             FwBuf[j] = 0xff;
    
49.         }
    
50.         for (int k = 0; k < rawList.Count; k++)
    
51.         {
    
52.             str = (string) rawList[k];
    
53.             int index = str.IndexOf("//");
    
54.             if (index > -1)
    
55.             {
    
56.                 str = str.Substring(0, index - 1);
    
57.             }
    
58.             if (str.Length > 0)
    
59.             {
    
60.                 ushort num5 = (ushort) HexToInt(str.Substring(3, 4));
    
61.                 if (num5 >= _MAX_FW_SIZE)
    
62.                 {
    
63.                     return false;
    
64.                 }
    
65.                 if (num5 < FwOff)
    
66.                 {
    
67.                     FwOff = num5;
    
68.                 }
    
69.                 index = ((int) HexToInt(str.Substring(1, 2))) * 2;
    
70.                 string str4 = str.Substring(9, index);
    
71.                 int num6 = index / 2;
    
72.                 int num7 = 0;
    
73.                 while (num7 < num6)
    
74.                 {
    
75.                     FwBuf[num5] = (byte) HexToInt(str4.Substring(num7 * 2, 2));
    
76.                     num7++;
    
77.                     num5 = (ushort) (num5 + 1);
    
78.                 }
    
79.                 if (num5 > FwLen)
    
80.                 {
    
81.                     FwLen = num5;
    
82.                 }
    
83.             }
    
84.         }
    
85.         return true;
    
86.     }
    
87. 
    
88.     public static bool ParseHexFile(string fName, byte[] FwBuf, ref ushort FwLen, ref ushort FwOff)
    
89.     {
    
90.         if (File.Exists(fName))
    
91.         {
    
92.             ArrayList rawList = new ArrayList();
    
93.             StreamReader reader = new StreamReader(fName);
    
94.             if (reader != null)
    
95.             {
    
96.                 string str;
    
97.                 while ((str = reader.ReadLine()) != null)
    
98.                 {
    
99.                     rawList.Add(str);
    
100.                 }
     
101.                 reader.Close();
     
102.                 return ParseHexData(rawList, FwBuf, ref FwLen, ref FwOff);
     
103.             }
     
104.         }
     
105.         return false;
     
106.     }
     
107. 
     
108.     public static unsafe void ParseIICData(byte[] fData, byte[] FwBuf, ref ushort FwLen, ref ushort FwOff)
     
109.     {
     
110.         ushort xStart = 8;
     
111.         FwLen = 0;
     
112.         FwOff = _MAX_FW_SIZE;
     
113.         for (int i = 0; i < _MAX_FW_SIZE; i++)
     
114.         {
     
115.             FwBuf[i] = 0xff;
     
116.         }
     
117.         fixed (byte* numRef = fData)
     
118.         {
     
119.             ushort* numPtr;
     
120.             do
     
121.             {
     
122.                 ReverseBytes(fData, xStart, 2);
     
123.                 ReverseBytes(fData, xStart + 2, 2);
     
124.                 numPtr = (ushort*) (numRef + xStart);
     
125.                 ushort* numPtr2 = (ushort*) ((numRef + xStart) + 2);
     
126.                 if (numPtr[0] != 0x8001)
     
127.                 {
     
128.                     Array.Copy(fData, xStart + 4, FwBuf, (int) numPtr2[0], (int) numPtr[0]);
     
129.                     ushort num3 = (ushort) (numPtr2[0] + numPtr[0]);
     
130.                     if (num3 > FwLen)
     
131.                     {
     
132.                         FwLen = num3;
     
133.                     }
     
134.                     if (numPtr2[0] < FwOff)
     
135.                     {
     
136.                         FwOff = numPtr2[0];
     
137.                     }
     
138.                 }
     
139.                 xStart = (ushort) (xStart + ((ushort) (numPtr[0] + 4)));
     
140.             }
     
141.             while ((numPtr[0] != 0x8001) && (xStart < fData.Length));
     
142.         }
     
143.     }
     
144. 
     
145.     public static bool ParseIICFile(string fName, byte[] FwBuf, ref ushort FwLen, ref ushort FwOff)
     
146.     {
     
147.         if (!File.Exists(fName))
     
148.         {
     
149.             return false;
     
150.         }
     
151.         Stream stream = new FileStream(fName, FileMode.Open, FileAccess.Read);
     
152.         if (stream == null)
     
153.         {
     
154.             return false;
     
155.         }
     
156.         int length = (int) stream.Length;
     
157.         byte[] buffer = new byte[length];
     
158.         stream.Read(buffer, 0, length);
     
159.         stream.Close();
     
160.         if (length > _MAX_FW_SIZE)
     
161.         {
     
162.             return false;
     
163.         }
     
164.         ParseIICData(buffer, FwBuf, ref FwLen, ref FwOff);
     
165.         return true;
     
166.     }
     
167. 
     
168.     public static unsafe int ReverseBytes(byte* dta, int bytes)
     
169.     {
     
170.         if (bytes < 0)
     
171.         {
     
172.             return 0;
     
173.         }
     
174.         byte[] buffer = new byte[bytes];
     
175.         for (byte i = 0; i < bytes; i = (byte) (i + 1))
     
176.         {
     
177.             buffer[i] = *(((dta + bytes) - i) - 1);
     
178.         }
     
179.         for (byte j = 0; j < bytes; j = (byte) (j + 1))
     
180.         {
     
181.             dta[j] = buffer[j];
     
182.         }
     
183.         return ((bytes > 2) ? BitConverter.ToInt32(buffer, 0) : BitConverter.ToInt16(buffer, 0));
     
184.     }
     
185. 
     
186.     public static int ReverseBytes(byte[] dta, int xStart, int bytes)
     
187.     {
     
188.         if (bytes < 0)
     
189.         {
     
190.             return 0;
     
191.         }
     
192.         byte[] buffer = new byte[bytes];
     
193.         for (byte i = 0; i < bytes; i = (byte) (i + 1))
     
194.         {
     
195.             buffer[i] = dta[((xStart + bytes) - i) - 1];
     
196.         }
     
197.         for (byte j = 0; j < bytes; j = (byte) (j + 1))
     
198.         {
     
199.             dta[xStart + j] = buffer[j];
     
200.         }
     
201.         return ((bytes > 2) ? BitConverter.ToInt32(buffer, 0) : BitConverter.ToInt16(buffer, 0));
     
202.     }

复制代码