开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
wg.c
资源名称：wg.rar　[点击查看]
上传用户：penglong
上传日期：2014-12-26
资源大小：2k
文件大小：10k
源码类别：

中间件编程

开发平台：

C/C++

wg.c：源码内容
  1. //------------------------------------------------------ 
  2. //功能：把数组封包成韦根26的格式，并发送出去 
  3. // 原理是把每个字节的低4位取出，来计算这个字节的值 
  4. //入口：str＝要封包的数组， 
  5. //出口：DATA0P3.0;DATA1=P3.1 
  6. //设计：大鹏，大鹏艾迪，2006/4/11 
  7. //------------------------------------------------------ 
  8. /*#include <52.h>
  9. #define  uchar unsigned char
  10. #define  uint unsigned int
  11. #define  ulong unsigned long int*/
  13. extern sbit WG_DATA0 =P3^2;
  14. extern sbit WG_DATA1 =P3^3 ;
  16. void send_wiegand26(uchar *str) 
  17. { 
  18. //| wiegand[0] | wiegand[1] | wiegand[2] | 
  19. //| *str *(str + 1) | *(str + 2) *(str + 3)| *(str + 4) *(str + 5)| 
  20. uchar idata i; 
  21. static uchar data one_num; //计算1的个数 
  22. uchar data check_temp; //韦根包奇偶效验中间暂存 
  23. bit data even; //韦根包前12位偶效验 
  24. bit data odd; //韦根包后12位齐效验 
  25. static uchar data wiegand[3]; //韦根包数据24位 
  26. // EA=0;//禁止中断
  27. //--------------------------------端口方向定义 
  28. // P3M0 = 0x00; //普通I/O口 
  29. // P3M1 = 0x00; 
  30. //================================数组到韦根包的转化 
  31. wiegand[0] = wiegand[0]|((*str)<<4);//原理是把每个字节的低4位取出，来计算这个字节的值 
  32. wiegand[0] = wiegand[0]|(*(str+1)&0x0f); 
  33. //--------------------------------计算前8位1的个数，为偶效验用 
  34. check_temp = wiegand[0]; 
  35. for(i = 0;i<8;i++) 
  36. { 
  37. if(check_temp&0x01) //(check_temp&0x01) 
  38. { 
  39. one_num++; 
  40. } 
  41. check_temp >>= 1; 
  42. } 
  43. wiegand[1] = wiegand[1]|(*(str+2)<<4); 
  44. //--------------------------------计算接下来的4位1的个数，为偶效验用 
  45. check_temp = wiegand[1]; 
  46. for(i = 0;i<4;i++) 
  47. { 
  48. if(check_temp&0x80) 
  50. { 
  51. one_num++; 
  52. } 
  53. check_temp<<=1; 
  54. } 
  55. //--------------------------------判断1的个数 
  56. one_num%2 == 0 ? (even = 0):( even = 1); 
  57. one_num = 0; 
  58. wiegand[1] = wiegand[1]|(*(str+3)&0x0f); 
  59. //--------------------------------计算接下来的4位1的个数，为奇效验用 
  60. check_temp = wiegand[1]; 
  61. for(i = 0;i<4;i++) 
  62. { 
  63.  if(check_temp&0x01){one_num++;} 
  64.  check_temp>>=1; 
  65. } 
  66. wiegand[2] = wiegand[2]|(*(str+4)<<4); 
  67. wiegand[2] = wiegand[2]|(*(str+5)&0x0f); 
  68. //--------------------------------计算接下来的8位1的个数，为奇效验用 
  69. check_temp = wiegand[2]; 
  70. for(i = 0;i<8;i++) 
  71. { 
  72. if(check_temp&0x01){one_num++;} 
  73. check_temp >>= 1; 
  74. } 
  75. //--------------------------------判断1的个数 
  76. one_num%2 == 0 ? (odd = 1):( odd = 0); 
  77. one_num = 0; 
  78. //================================启动发送，用定时器做时间延时 
  79. //--------------------------------韦根 输出端初始化 
  80. WG_DATA0 = 1; 
  81. WG_DATA1 = 1; 
  82. //--------------------------------发送偶效验 
  83. TMOD=0X01;                    //T0为方式1计数
  84. EA=1; EX1=0;       EX0=0;   //开中断,禁止INT0,INT1中断
  85. if(even)                     //enen韦根包前12位偶效验标志
  86. { 
  87. WG_DATA1 = 0; 
  89.  //-------------------------延时100us 
  90. TR0 = 0; //停止T0计算
  91. TH0 = (65536 - 158)/256; //定时100us  20MHz晶体
  92. TL0 = (65536 - 158)%256; 
  93. TF0 = 0; //T0中断请求标志清0
  94. ET0 = 0; //T0中断禁止
  95. TR0 = 1; //启动T0计算
  96. while (!TF0) { ;} 
  97. TF0 = 0; 
  98. WG_DATA1 = 1; 
  99. } 
  100. else 
  101. { 
  102. WG_DATA0 = 0; 
  103. //------------------------延时100us 
  104. TR0 = 0; 
  105. TH0 = (65536 - 158)/256; //定时100us 
  106. TL0 = (65536 - 158)%256; 
  107. TF0 = 0; 
  108. ET0 = 0; 
  109. TR0 = 1; 
  110. while (!TF0) { ;} 
  111. TF0 = 0; 
  112. WG_DATA0 = 1; 
  113. } 
  114. //----------------------------延时一个发送周期 
  115. TR0 = 0; 
  116. TH0 = (65536 - 1582)/256; //定时1000us//1500us 
  117. TL0 = (65536 - 1582)%256; 
  118. TF0 = 0; 
  119. ET0 = 0; 
  120. TR0 = 1; 
  121. while (!TF0) { ;} 
  122. TF0 = 0; 
  123. //-------------------------------发送24位数据 
  124. for(i = 0;i<24;i++) 
  125. { 
  126. //---------------------------韦根 输出端初始化 
  127. WG_DATA0 = 1; 
  128. WG_DATA1 = 1; 
  129. if((wiegand[0])&0x80) 
  131. { 
  132. WG_DATA1 = 0; 
  133. //----------------------延时100us 
  134. TR0 = 0; 
  135. TH0 = (65536 - 158)/256; //定时100us 
  136. TL0 = (65536 - 158)%256; 
  137. TF0 = 0; 
  138. ET0 = 0; 
  139. TR0 = 1; 
  140. while (!TF0) { ;} 
  141. TF0 = 0; 
  142. WG_DATA1 = 1; 
  143. } 
  144. else 
  145. { 
  146. WG_DATA0 = 0; 
  147. //---------------------延时100us 
  148. TR0 = 0; 
  149. TH0 = (65536 - 158)/256; //定时100us 
  150. TL0 = (65536 - 158)%256; 
  151. TF0 = 0; 
  152. ET0 = 0; 
  153. TR0 = 1; 
  154. while (!TF0) { ;} 
  155. TF0 = 0; 
  156. WG_DATA0 = 1; 
  157. } 
  158.  (*(long*)&wiegand[0]) <<= 1; 
  159. //-------------------------------延时一个发送周期 
  160. TR0 = 0; 
  161. TH0 = (65536 - 1582)/256; //定时1000us//1500us 
  162. TL0 = (65536 - 1582)%256; 
  163. TF0 = 0; 
  164. ET0 = 0; 
  165. TR0 = 1; 
  166. while (!TF0) { ;} 
  167. TF0 = 0; 
  168. } 
  169. //==============================发送奇效验位 
  170. //------------------------------韦根 输出端初始化 
  171. WG_DATA0 = 1; 
  172. WG_DATA1 = 1; 
  174.  if(odd)  //韦根包后12位齐效验标志
  175. { 
  176. WG_DATA1 = 0; 
  177. //-------------------------延时100us 
  178. TR0 = 0; 
  179. TH0 = (65536 - 158)/256; //定时100us 
  180. TL0 = (65536 - 158)%256; 
  181. TF0 = 0; 
  182. ET0 = 0; 
  183. TR0 = 1; 
  184. while (!TF0) { ;} 
  185. TF0 = 0; 
  186. WG_DATA1 = 1; 
  187. } 
  188. else 
  189. { 
  190. WG_DATA0 = 0; 
  191. //-------------------------延时100us 
  192. TR0 = 0; 
  193. TH0 = (65536 - 158)/256; //定时100us 
  194. TL0 = (65536 - 158)%256; 
  195. TF0 = 0; 
  196. ET0 = 0; 
  197. TR0 = 1; 
  198. while (!TF0) { ;} 
  199. TF0 = 0; 
  200. WG_DATA0 = 1; 
  201. } 
  202. } 
  205. /*
  206. void send_wiegand34(uchar *str) 
  207. { 
  208. //| wiegand[0] | wiegand[1] | wiegand[2] | 
  209. //| *str *(str + 1) | *(str + 2) *(str + 3)| *(str + 4) *(str + 5)| 
  210. uchar data i; 
  211. static uchar data one_num; //计算1的个数 
  212. uchar data check_temp;  //韦根包奇偶效验中间暂存 
  213. bit data even;  //韦根包前16位偶效验 
  214. bit data odd;  //韦根包后16位齐效验 
  215. static uchar data wiegand[4]; //韦根包数据32位 
  216. // EA=0;//禁止中断
  217. //--------------------------------端口方向定义 
  218. // P3M0 = 0x00; //普通I/O口 
  219. // P3M1 = 0x00; 
  220. //================================数组到韦根包的转化 
  221. wiegand[0] = wiegand[0]|((*str)<<4);//原理是把每个字节的低4位取出，来计算这个字节的值 
  222. wiegand[0] = wiegand[0]|(*(str+1)&0x0f); 
  223. //--------------------------------计算前8位1的个数，为偶效验用 
  224. check_temp = wiegand[0]; 
  225. for(i = 0;i<8;i++) 
  226. { 
  227. if(check_temp&0x01) //(check_temp&0x01) 
  228. { 
  229. one_num++; 
  230. } 
  231. check_temp >>= 1; 
  232. } 
  233. wiegand[1] = wiegand[1]|(*(str+2)<<4); 
  234. //--------------------------------计算接下来的4位1的个数，为偶效验用 
  235. check_temp = wiegand[1]; 
  236. for(i = 0;i<4;i++) 
  237. { 
  238. if(check_temp&0x80) 
  240. { 
  241. one_num++; 
  242. } 
  243. check_temp<<=1; 
  244. } 
  245. //--------------------------------判断1的个数 
  246. one_num%2 == 0 ? (even = 0):( even = 1); 
  247. one_num = 0; 
  248. wiegand[1] = wiegand[1]|(*(str+3)&0x0f); 
  249. //--------------------------------计算接下来的4位1的个数，为奇效验用 
  250. check_temp = wiegand[1]; 
  251. for(i = 0;i<4;i++) 
  252. { 
  253.  if(check_temp&0x01){one_num++;} 
  254.  check_temp>>=1; 
  255. } 
  256. wiegand[2] = wiegand[2]|(*(str+4)<<4); 
  257. wiegand[2] = wiegand[2]|(*(str+5)&0x0f); 
  258. //--------------------------------计算接下来的8位1的个数，为奇效验用 
  259. check_temp = wiegand[2]; 
  260. for(i = 0;i<8;i++) 
  261. { 
  262. if(check_temp&0x01){one_num++;} 
  263. check_temp >>= 1; 
  264. } 
  265. //--------------------------------判断1的个数 
  266. one_num%2 == 0 ? (odd = 1):( odd = 0); 
  267. one_num = 0; 
  268. //================================启动发送，用定时器做时间延时 
  269. //--------------------------------韦根 输出端初始化 
  270. WG_DATA0 = 1; 
  271. WG_DATA1 = 1; 
  272. //--------------------------------发送偶效验 
  273. // TMOD=0X01;                    //T0为方式1计数
  274. // EA=1; EX1=0;       EX0=0;   //开中断,禁止INT0,INT1中断
  275. if(even)                     //enen韦根包前12位偶效验标志
  276. { 
  277. WG_DATA1 = 0; 
  279.  //-------------------------延时100us 
  280. TR0 = 0; //停止T0计算
  281. TH0 = (65536 - 158)/256; //定时100us  20MHz晶体
  282. TL0 = (65536 - 158)%256; 
  283. TF0 = 0; //T0中断请求标志清0
  284. ET0 = 0; //T0中断禁止
  285. TR0 = 1; //启动T0计算
  286. while (!TF0) { ;} 
  287. TF0 = 0; 
  288. WG_DATA1 = 1; 
  289. } 
  290. else 
  291. { 
  292. WG_DATA0 = 0; 
  293. //------------------------延时100us 
  294. TR0 = 0; 
  295. TH0 = (65536 - 158)/256; //定时100us 
  296. TL0 = (65536 - 158)%256; 
  297. TF0 = 0; 
  298. ET0 = 0; 
  299. TR0 = 1; 
  300. while (!TF0) { ;} 
  301. TF0 = 0; 
  302. WG_DATA0 = 1; 
  303. } 
  304. //----------------------------延时一个发送周期 
  305. TR0 = 0; 
  306. TH0 = (65536 - 1582)/256; //定时1000us //1382//1500us
  307. TL0 = (65536 - 1582)%256; 
  308. TF0 = 0; 
  309. ET0 = 0; 
  310. TR0 = 1; 
  311. while (!TF0) { ;} 
  312. TF0 = 0; 
  313. //-------------------------------发送24位数据 
  314. for(i = 0;i<32;i++) 
  315. { 
  316. //---------------------------韦根 输出端初始化 
  317. WG_DATA0 = 1; 
  318. WG_DATA1 = 1; 
  319. if((wiegand[0])&0x80) 
  321. { 
  322. WG_DATA1 = 0; 
  323. //----------------------延时100us 
  324. TR0 = 0; 
  325. TH0 = (65536 - 158)/256; //定时100us 
  326. TL0 = (65536 - 158)%256; 
  327. TF0 = 0; 
  328. ET0 = 0; 
  329. TR0 = 1; 
  330. while (!TF0) { ;} 
  331. TF0 = 0; 
  332. WG_DATA1 = 1; 
  333. } 
  334. else 
  335. { 
  336. WG_DATA0 = 0; 
  337. //---------------------延时100us 
  338. TR0 = 0; 
  339. TH0 = (65536 - 158)/256; //定时100us 
  340. TL0 = (65536 - 158)%256; 
  341. TF0 = 0; 
  342. ET0 = 0; 
  343. TR0 = 1; 
  344. while (!TF0) { ;} 
  345. TF0 = 0; 
  346. WG_DATA0 = 1; 
  347. } 
  348. (*(long*)&wiegand[0]) <<= 1; 
  349. //-------------------------------延时一个发送周期 
  350. TR0 = 0; 
  351. TH0 = (65536 - 1582)/256; //定时1000us //1500us  -1382 
  352. TL0 = (65536 - 1582)%256; 
  353. TF0 = 0; 
  354. ET0 = 0; 
  355. TR0 = 1; 
  356. while (!TF0) { ;} 
  357. TF0 = 0; 
  358. } 
  359. //==============================发送奇效验位 
  360. //------------------------------韦根 输出端初始化 
  361. WG_DATA0 = 1; 
  362. WG_DATA1 = 1; 
  364.  if(odd)  //韦根包后12位齐效验标志
  365. { 
  366. WG_DATA1 = 0; 
  367. //-------------------------延时100us 
  368. TR0 = 0; 
  369. TH0 = (65536 - 158)/256; //定时100us 
  370. TL0 = (65536 - 158)%256; 
  371. TF0 = 0; 
  372. ET0 = 0; 
  373. TR0 = 1; 
  374. while (!TF0) { ;} 
  375. TF0 = 0; 
  376. WG_DATA1 = 1; 
  377. } 
  378. else 
  379. { 
  380. WG_DATA0 = 0; 
  381. //-------------------------延时100us 
  382. TR0 = 0; 
  383. TH0 = (65536 - 158)/256; //定时100us 
  384. TL0 = (65536 - 158)%256; 
  385. TF0 = 0; 
  386. ET0 = 0; 
  387. TR0 = 1; 
  388. while (!TF0) { ;} 
  389. TF0 = 0; 
  390. WG_DATA0 = 1; 
  391. } 
  392. } */