16进制、10进制、BCD码之间的转换

1. 原文地址：：：：http://01258.blog.51cto.com/2229941/473635
3. include <stdio.h>
4. #include <string.h>
5. 
   
6. /////////////////////////////////////////////////////
7. //
8. //功能：二进制取反
9. //
10. //输入：const unsigned char *src   二进制数据
11. //       int length                 待转换的二进制数据长度
12. //
13. //输出：unsigned char *dst         取反后的二进制数据
14. //
15. //返回：0     success
16. //
17. //////////////////////////////////////////////////////
18. int convert(unsignedchar *dst, const unsignedchar *src, int length)
19. {
20.         int i;
21. 
    
22.         for(i=0; i<length; i++)
23.          {
24.                  dst[i] = src[i]^0xFF;
25.          }
26.         return 0;
27. }
28. 
    
29. //////////////////////////////////////////////////////////
30. //
31. //功能：十六进制转为十进制
32. //
33. //输入：const unsigned char *hex          待转换的十六进制数据
34. //       int length                        十六进制数据长度
35. //
36. //输出：
37. //
38. //返回：int   rslt                         转换后的十进制数据
39. //
40. //思路：十六进制每个字符位所表示的十进制数的范围是0 ~255，进制为256
41. //       左移8位(<<8)等价乘以256
42. //
43. /////////////////////////////////////////////////////////
44. unsigned long HextoDec(const unsignedchar *hex, int length)
45. {
46.     int i;
47.      unsigned long rslt = 0;
48. 
    
49.     for(i=0; i<length; i++)
50.      {
51.          rslt += (unsigned int)(hex[i])<<(8*(length-1-i));
52.                                                         
53.      }
54. 
    
55.     return rslt;
56. }
57. 
    
58. 
    
59. /////////////////////////////////////////////////////////
60. //
61. //功能：十进制转十六进制
62. //
63. //输入：int dec                      待转换的十进制数据
64. //       int length                   转换后的十六进制数据长度
65. //
66. //输出：unsigned char *hex           转换后的十六进制数据
67. //
68. //返回：0     success
69. //
70. //思路：原理同十六进制转十进制
71. //////////////////////////////////////////////////////////
72. int DectoHex(int dec, unsignedchar *hex, int length)
73. {
74.     int i;
75. 
    
76.     for(i=length-1; i>=0; i--)
77.      {
78.          hex[i] = (dec%256)&0xFF;
79.          dec /= 256;
80.      }
81. 
    
82.     return 0;
83. }
84. 
    
85. /////////////////////////////////////////////////////////
86. //
87. //功能：求权
88. //
89. //输入：int base                     进制基数
90. //       int times                    权级数
91. //
92. //输出：
93. //
94. //返回：unsigned long                当前数据位的权
95. //
96. //////////////////////////////////////////////////////////
97. unsigned long power(int base,int times)
98. {
99.     int i;
100.      unsigned long rslt = 1;
101. 
     
102.     for(i=0; i<times; i++)
103.          rslt *= base;
104. 
     
105.     return rslt;
106. }
107. 
     
108. /////////////////////////////////////////////////////////
109. //
110. //功能：BCD转10进制
111. //
112. //输入：const unsigned char *bcd      待转换的BCD码
113. //       int length                    BCD码数据长度
114. //
115. //输出：
116. //
117. //返回：unsigned long                当前数据位的权
118. //
119. //思路：压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100
120. //       先求每个字符所表示的十进制值，然后乘以权
121. //////////////////////////////////////////////////////////
122. unsigned long   BCDtoDec(const unsignedchar *bcd, int length)
123. {
124.      int i, tmp;
125.       unsigned long dec = 0;
126. 
     
127.      for(i=0; i<length; i++)
128.       {
129.          tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);   
130.          dec += tmp * power(100, length-1-i);          
131.       }
132. 
     
133.      return dec;
134. }
135. 
     
136. /////////////////////////////////////////////////////////
137. //
138. //功能：十进制转BCD码
139. //
140. //输入：int Dec                       待转换的十进制数据
141. //       int length                    BCD码数据长度
142. //
143. //输出：unsigned char *Bcd            转换后的BCD码
144. //
145. //返回：0   success
146. //
147. //思路：原理同BCD码转十进制
148. //
149. //////////////////////////////////////////////////////////
150. int DectoBCD(int Dec, unsignedchar *Bcd, int length)
151. {
152.      int i;
153.      int temp;
154. 
     
155.      for(i=length-1; i>=0; i--)
156.       {
157.           temp = Dec%100;
158.           Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
159.           Dec /= 100;
160.       }
161. 
     
162.      return 0;
163. }
164. 
     
165. int main()
166. {
167.     registerint i;
168.      unsigned char tmp_bff[12] ="";
169. 
     
170.     //十六进制转十进制
171.      unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
172.      unsigned long dec_hex = 0;
173. 
     
174.      dec_hex = HextoDec(HEX, 4);
175.     
176.      printf("dec_hex = %d\n", dec_hex);
177. 
     
178.     //十进制转十六进制
179.      DectoHex(dec_hex, tmp_bff, 4);
180.     for(i=0; i<5; i++)
181.      {
182.          printf("tmp_bff[%d] = 0x%02X\n",i, tmp_bff[i]);
183.      }
184. 
     
185.     //BCD码转十进制
186.      unsigned long dec_bcd = 0;
187.      unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};
188. 
     
189.      dec_bcd = BCDtoDec(BCD, 4);
190.      printf("dec_bcd = %d\n", dec_bcd);
191. 
     
192.     //十进制转BCD码
193.      DectoBCD(dec_bcd, tmp_bff, 4);
194.     for(i=0; i<5; i++)
195.      {
196.          printf("tmp_bff[%d] = 0x%02X\n", i, tmp_bff[i]);
197.      }
198. 
     
199.      getchar();

1. }
2. 4月30日

3. 16进制、10进制、BCD码之间的转换

1. #include <stdio.h>
2. #include <string.h>
3. 
   
4. /////////////////////////////////////////////////////
5. //
6. //功能：二进制取反
7. //
8. //输入：const unsigned char *src   二进制数据
9. //       int length                 待转换的二进制数据长度
10. //
11. //输出：unsigned char *dst         取反后的二进制数据
12. //
13. //返回：0     success
14. //
15. //////////////////////////////////////////////////////
16. int convert(unsignedchar *dst, const unsignedchar *src, int length)
17. {
18.         int i;
19. 
    
20.         for(i=0; i<length; i++)
21.          {
22.                  dst[i] = src[i]^0xFF;
23.          }
24.         return 0;
25. }
26. 
    
27. //////////////////////////////////////////////////////////
28. //
29. //功能：十六进制转为十进制
30. //
31. //输入：const unsigned char *hex          待转换的十六进制数据
32. //       int length                        十六进制数据长度
33. //
34. //输出：
35. //
36. //返回：int   rslt                         转换后的十进制数据
37. //
38. //思路：十六进制每个字符位所表示的十进制数的范围是0 ~255，进制为256
39. //       左移8位(<<8)等价乘以256
40. //
41. /////////////////////////////////////////////////////////
42. unsigned long HextoDec(const unsignedchar *hex, int length)
43. {
44.     int i;
45.      unsigned long rslt = 0;
46. 
    
47.     for(i=0; i<length; i++)
48.      {
49.          rslt += (unsigned int)(hex[i])<<(8*(length-1-i));
50.                                                         
51.      }
52. 
    
53.     return rslt;
54. }
55. 
    
56. 
    
57. /////////////////////////////////////////////////////////
58. //
59. //功能：十进制转十六进制
60. //
61. //输入：int dec                      待转换的十进制数据
62. //       int length                   转换后的十六进制数据长度
63. //
64. //输出：unsigned char *hex           转换后的十六进制数据
65. //
66. //返回：0     success
67. //
68. //思路：原理同十六进制转十进制
69. //////////////////////////////////////////////////////////
70. int DectoHex(int dec, unsignedchar *hex, int length)
71. {
72.     int i;
73. 
    
74.     for(i=length-1; i>=0; i--)
75.      {
76.          hex[i] = (dec%256)&0xFF;
77.          dec /= 256;
78.      }
79. 
    
80.     return 0;
81. }
82. 
    
83. /////////////////////////////////////////////////////////
84. //
85. //功能：求权
86. //
87. //输入：int base                     进制基数
88. //       int times                    权级数
89. //
90. //输出：
91. //
92. //返回：unsigned long                当前数据位的权
93. //
94. //////////////////////////////////////////////////////////
95. unsigned long power(int base,int times)
96. {
97.     int i;
98.      unsigned long rslt = 1;
99. 
    
100.     for(i=0; i<times; i++)
101.          rslt *= base;
102. 
     
103.     return rslt;
104. }
105. 
     
106. /////////////////////////////////////////////////////////
107. //
108. //功能：BCD转10进制
109. //
110. //输入：const unsigned char *bcd      待转换的BCD码
111. //       int length                    BCD码数据长度
112. //
113. //输出：
114. //
115. //返回：unsigned long                当前数据位的权
116. //
117. //思路：压缩BCD码一个字符所表示的十进制数据范围为0 ~ 99,进制为100
118. //       先求每个字符所表示的十进制值，然后乘以权
119. //////////////////////////////////////////////////////////
120. unsigned long   BCDtoDec(const unsignedchar *bcd, int length)
121. {
122.      int i, tmp;
123.       unsigned long dec = 0;
124. 
     
125.      for(i=0; i<length; i++)
126.       {
127.          tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);   
128.          dec += tmp * power(100, length-1-i);          
129.       }
130. 
     
131.      return dec;
132. }
133. 
     
134. /////////////////////////////////////////////////////////
135. //
136. //功能：十进制转BCD码
137. //
138. //输入：int Dec                       待转换的十进制数据
139. //       int length                    BCD码数据长度
140. //
141. //输出：unsigned char *Bcd            转换后的BCD码
142. //
143. //返回：0   success
144. //
145. //思路：原理同BCD码转十进制
146. //
147. //////////////////////////////////////////////////////////
148. int DectoBCD(int Dec, unsignedchar *Bcd, int length)
149. {
150.      int i;
151.      int temp;
152. 
     
153.      for(i=length-1; i>=0; i--)
154.       {
155.           temp = Dec%100;
156.           Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
157.           Dec /= 100;
158.       }
159. 
     
160.      return 0;
161. }
162. 
     
163. int main()
164. {
165.     registerint i;
166.      unsigned char tmp_bff[12] ="";
167. 
     
168.     //十六进制转十进制
169.      unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
170.      unsigned long dec_hex = 0;
171. 
     
172.      dec_hex = HextoDec(HEX, 4);
173.     
174.      printf("dec_hex = %d\n", dec_hex);
175. 
     
176.     //十进制转十六进制
177.      DectoHex(dec_hex, tmp_bff, 4);
178.     for(i=0; i<5; i++)
179.      {
180.          printf("tmp_bff[%d] = 0x%02X\n",i, tmp_bff[i]);
181.      }
182. 
     
183.     //BCD码转十进制
184.      unsigned long dec_bcd = 0;
185.      unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};
186. 
     
187.      dec_bcd = BCDtoDec(BCD, 4);
188.      printf("dec_bcd = %d\n", dec_bcd);
189. 
     
190.     //十进制转BCD码
191.      DectoBCD(dec_bcd, tmp_bff, 4);
192.     for(i=0; i<5; i++)
193.      {
194.          printf("tmp_bff[%d] = 0x%02X\n", i, tmp_bff[i]);
195.      }
196. 
     
197.      getchar();
198. }