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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > RFID编程 > 查看源码
RFModuleFunc.C
资源名称：93317463main_Uv2.rar　[点击查看]
上传用户：shyuanyi
上传日期：2008-05-24
资源大小：69k
文件大小：10k
源码类别：

RFID编程

开发平台：

C/C++

RFModuleFunc.C：源码内容
  3. #include <Reg52.H>
  4. #include <string.h>
  5. #include <INTRINS.H>
  6. #include "RfModuleFunc.H"
  9. //各延时定义
  10. #define DELAY_TIME0 100
  11. #define DELAY_TIME1 2500
  12. #define DELAY_TIME2 3000
  13. #define DELAY_TIME3 55000
  15. #define SPI_CMD_GET_VERSION 0x32 //读机内版本号
  16. #define SPI_CMD_GET_INFO 0x34 //读取RF模块固件信息序列号
  17. #define SPI_CMD_SET_CONTROL_BIT 0x50 //设置RC500中的控制位
  18. #define SPI_CMD_CLR_CONTROL_BIT 0x51 //清除RC500中的控制位
  19. #define SPI_CMD_BUZZER 0x60 //输出驱动无源蜂鸣器信号
  20. //Mifare模块基本命令部分
  21. #define SPI_CMD_MIFARE_CONFIG 0x52 //复位且配置RC500
  22. #define SPI_CMD_MIFARE_CLOSE 0x3F //关闭RC500，使读写模块进入掉电模式
  23. #define SPI_CMD_MIFARE_REQUEST 0x41 //寻卡
  24. #define SPI_CMD_MIFARE_ANTICOLL 0x42 //防冲突
  25. #define SPI_CMD_MIFARE_ANTICOLL2 0x71 //防冲突2，允许多张卡进入
  26. #define SPI_CMD_MIFARE_SELECT 0x43 //选择卡
  27. #define SPI_CMD_MIFARE_AUTH 0x44 //开始校验密钥
  28. #define SPI_CMD_MIFARE_AUTH2 0x72 //可选择密钥区验证
  29. #define SPI_CMD_MIFARE_AUTHKEY 0x73 //直接校验密钥
  30. #define SPI_CMD_MIFARE_HALT_CARD 0x45 //停止当前卡
  31. #define SPI_CMD_MIFARE_READ 0x46 //读卡
  32. #define SPI_CMD_MIFARE_WRITE 0x47 //写卡
  33. #define SPI_CMD_MIFARE_INC 0x48 //增值操作
  34. #define SPI_CMD_MIFARE_DEC 0x49 //减值操作
  35. #define SPI_CMD_MIFARE_RESORE 0x4A //将所访问单元块的字节数保存在卡的内部寄存器中
  36. #define SPI_CMD_MIFARE_TRANS 0x4B //将卡内部寄存器的内容转输到访问快的字节数
  37. #define SPI_CMD_MIFARE_VALUE 0x70 //增减值操作
  38. #define SPI_CMD_MIFARE_LOADKEY 0x4C //改变存贮在EEPROM 中的密钥
  39. #define SPI_CMD_MIFARE_RESET_CARD 0x4E //关闭天线输出数ms 使卡复位
  40. #define SPI_CMD_MIFARE_AUTHE2KEY 0x56 //从Mifare模块的E2校验密钥
  41. #define SPI_CMD_MIFARE_CHECK_WRITE 0x53 //将所传送的数据和上一次所写的数据进行比较
  42. #define SPI_CMD_MIFARE_READ_E2 0x61 //读RC500 内EEPROM 的内容
  43. #define SPI_CMD_MIFARE_WRITE_E2 0x62 //写数据到RC500 内EEPROM
  44. //卡操作命令部分
  45. #define SPI_CMD_SET_CARD_APP_SECTOR 0x80 //设置卡扇区应用参数
  46. #define SPI_CMD_GET_CARD_APP_SECTOR 0x81 //读取卡扇区应用参数
  47. #define SPI_CMD_SET_BASE_KEY 0x82 //设置基密钥
  48. #define SPI_CMD_GET_BASE_KEY 0x83 //读取基密钥
  49. #define SPI_CMD_GET_CARD_KEY 0x84 //取得卡密钥
  50. #define SPI_CMD_IS_CARD_IN 0x85 //是否有卡进入读卡区
  51. #define SPI_CMD_READ_COMPANY_INFO 0x86 //读卡上公司信息
  52. #define SPI_CMD_READ_CARDHOLDER_INFO 0x87 //读卡上持卡人信息
  53. #define SPI_CMD_READ_BUSINESS_INFO 0x88 //读卡上交易数据(含卡恢复流程)
  54. #define SPI_CMD_CONSUME 0x89 //消费
  55. #define SPI_CMD_FILL 0x8A //充值
  56. #define SPI_CMD_READ_ORDER_DINNER_INFO 0x8B //读卡上订餐信息
  57. #define SPI_CMD_WRITE_ORDER_DINNER_INFO 0x8C //写订餐信息到卡上
  58. #define SPI_CMD_READ_TIME_COUNT_INFO 0x8D //读卡上计时消费信息
  59. #define SPI_CMD_WRITE_TIME_COUNT_INFO 0x8E //写计时消费信息到卡上
  60. #define SPI_CMD_SET_CARD_STATE 0x8F //设置卡状态
  61. //============================管脚定义====================================
  62. sbit   RF_RST   =  P2^6;
  63. sbit   RF_CS    =  P3^2;       //INT0
  64. sbit   RF_SCLK  =  P3^5;
  65. sbit   RF_SDAT  =  P3^4;
  66. #define   RF_OPEN()  IE0=0;EX0=1;
  67. #define   RF_CLOSE() EX0=0;
  68. //============================常量定义================================
  69. #define RF_BUFFER_MAX_ZIAE 64 //不能超255，否则需加长度字节数
  70. unsigned char pdata  Rf_Buffer[RF_BUFFER_MAX_ZIAE];
  71. bit  newdata  = 0;
  73. //BCC校验计算
  74. unsigned char GetBCC(unsigned char *Buffer, unsigned char Len)
  75. {
  76. unsigned char value=0;
  77. while(Len--)
  78. {
  79. value ^= *Buffer;
  80. Buffer++;
  81. }
  82. return ~value;
  83. }
  85. //外部提供延时1ms的子程序
  86. //extern Delay1ms(unsigned char _1ms);
  88. extern void  do_nop(unsigned char Count);
  90. void  Rf_Int0(void) interrupt 0 using 1  //rf_rcv(Rf_Buffer);
  91. {
  92.    unsigned char  Rf_count;
  93.    unsigned char  i,j,ch;
  94.    RF_SCLK = 0;
  95.    RF_SDAT = 1;
  96.    for(i=10;i--;);//delay;
  97.    Rf_count= 0;
  98.    while(!RF_CS)
  99.    {
  100.     for(i=0;i<8;i++)
  101.       {
  102.    RF_SCLK = 1;ch <<=1;
  103.    ch |= RF_SDAT;for(j=2;j--;);//delay;
  104.    RF_SCLK = 0;for(j=2;j--;);//delay;
  105.   }
  106. Rf_Buffer[Rf_count]= ch;
  107. if(++Rf_count>=RF_BUFFER_MAX_ZIAE)break;
  108.    }
  109.    RF_SDAT = 0;
  110.    newdata = 1;
  111. }
  114. void  Rf_Init(void)
  115. {
  116. EA  =  0;
  118. IP  &= ~0X01;     //X0优先级0
  119. //IPH &= ~0X01;
  120. IT0 = 1;        //INT1 is falling edg trig
  122. EA  =  1;
  124. RF_CS   = 1;
  125. RF_SCLK = 0;
  126. RF_SDAT = 0;
  127. // 模块复位(模块已由外部阻容电路复位)
  128. // RF_RST = 0; Delay1ms(45);
  129. // RF_RST = 1; Delay1ms(45);
  130. }
  133. unsigned char  Rf_Send(unsigned char *buf,unsigned char Count)
  134. {
  135.     unsigned char  i,j,ch;
  137. RF_CLOSE();
  139. RF_SDAT  = 1;
  140. RF_SCLK  = 0;
  142.     i=200;
  143.     while(RF_SDAT) i--;
  144. if(!i) return(RF_ERR);
  146. RF_CS  = 0;
  148.     i=200;
  149.     while(!RF_SDAT) i--;
  150. if(!i) return(RF_ERR);
  152. for(i=0;i<Count;i++)
  153.     {
  154.  ch=buf[i];
  155.  for(j=0;j<8;j++)
  156.   {
  157.    RF_SDAT = (bit)(ch&0x80);do_nop(1);
  158.    RF_SCLK = 1;do_nop(3);
  159.    RF_SCLK = 0;ch<<=1;do_nop(1);
  160.   }
  161. }
  163. RF_CS    = 1;
  164. RF_SDAT  = 0;
  165. //TR1    = 0;
  166.     return(MI_OK);
  167. }
  169. unsigned char Rf_Command(unsigned int DelayTime)
  170. {
  171. unsigned char Len,BCC_Value;
  173. Len = Rf_Buffer[LENGTH] + 3; //计算总长度
  174. Rf_Buffer[Len]=GetBCC(Rf_Buffer,Len); //计算BCC
  175. if(Rf_Send(Rf_Buffer,Len+1)!=MI_OK) return RF_ERR;   
  176. RF_OPEN();
  177. while(!newdata && DelayTime)  DelayTime--;
  178. RF_CLOSE();
  179. if(newdata==0)  return RF_ERR;  //接收超时判断
  180. newdata=0;
  181. Len = Rf_Buffer[LENGTH] + 3; //计算总长度(不含BCC)
  182. BCC_Value=GetBCC(Rf_Buffer,Len); //计算BCC
  183.     if(BCC_Value == Rf_Buffer[Len])
  184. return RF_OK;
  185. return MI_CRCERR;
  186. }
  190. //=========================卡操作基本函数=================================
  191. unsigned char mifs_request(unsigned char _Mode,unsigned char *_TagType)
  192. {
  193. Rf_Buffer[SEQNR]=1;
  194. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_REQUEST;
  195. Rf_Buffer[LENGTH]=0x01;
  196. Rf_Buffer[MODE]=_Mode;
  198. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  200. if(Rf_Buffer[STATUS]==MI_OK)
  201. {
  202.   _TagType[0]=Rf_Buffer[TAGTYPE];
  203.   _TagType[1]=Rf_Buffer[TAGTYPE+1];
  204. }
  205. return Rf_Buffer[STATUS];
  206. }
  209. unsigned char mifs_anticoll(unsigned char _Bcnt,unsigned char *_SNR)
  210. {
  211. Rf_Buffer[SEQNR]=1;
  212. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_ANTICOLL;
  213. Rf_Buffer[LENGTH]=0x01;
  214. Rf_Buffer[MODE]=_Bcnt;
  216. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  218. if(Rf_Buffer[STATUS]==MI_OK)
  219. {
  220. memcpy(_SNR,&Rf_Buffer[SERNR],4);
  221. }
  222. return Rf_Buffer[STATUS];
  223. }
  226. unsigned char mifs_select(unsigned char *_SNR,unsigned char *_Size)
  227. {
  228. Rf_Buffer[SEQNR]=1;
  229. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_SELECT;
  230. Rf_Buffer[LENGTH]=0x04;
  231. memcpy(&Rf_Buffer[SERNR],_SNR,4);
  233. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  235. if(Rf_Buffer[STATUS]==MI_OK)
  236. {
  237. *_Size=Rf_Buffer[SIZE];
  238. }
  239. return Rf_Buffer[STATUS];
  240. }
  242. unsigned char mifs_authentication(unsigned char _Mode,unsigned char _SecNr)
  243. {
  244. Rf_Buffer[SEQNR]=1;
  245. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_AUTH;
  246. Rf_Buffer[LENGTH]=0x02;
  247. Rf_Buffer[MODE]=_Mode;
  248. Rf_Buffer[SECNR]=_SecNr;
  250. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  252. return Rf_Buffer[STATUS];
  253. }
  256. unsigned char mifs_halt(void)
  257. {
  258. Rf_Buffer[SEQNR]=0;
  259. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_HALT_CARD;
  260. Rf_Buffer[LENGTH]=0x00;
  262. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  264. return Rf_Buffer[STATUS];
  265. }
  267. unsigned char mifs_read(unsigned char _Adr,unsigned char *_Data)
  268. {
  269. Rf_Buffer[SEQNR]=0;
  270. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_READ;
  271. Rf_Buffer[LENGTH]=0x01;
  272. Rf_Buffer[ADR]=_Adr;
  274. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  276. if(Rf_Buffer[STATUS]==MI_OK)
  277. memcpy(_Data,&Rf_Buffer[DATABYTES-1],16);
  278. return Rf_Buffer[STATUS];
  279. }
  281. unsigned char mifs_load_key(unsigned char _Mode,unsigned char _SecNr,unsigned char *_Nkey)
  282. {
  283. Rf_Buffer[SEQNR]=0;
  284. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_LOADKEY;
  285. Rf_Buffer[LENGTH]=0x08;
  286. Rf_Buffer[MODE]=_Mode;
  287. Rf_Buffer[SECNR]=_SecNr;
  288. memcpy(&Rf_Buffer[NKEY],_Nkey,6);
  290. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  292. return Rf_Buffer[STATUS];
  293. }
  295. unsigned char mifs_reset(unsigned char _Msec)
  296. {
  297. Rf_Buffer[SEQNR]=0;
  298. Rf_Buffer[COMMAND]=SPI_CMD_MIFARE_RESET_CARD;
  299. Rf_Buffer[LENGTH]=1;
  300. Rf_Buffer[TIME]=_Msec;
  302. if(Rf_Command(DELAY_TIME1)!=MI_OK) return RF_ERR;
  304. return Rf_Buffer[STATUS];
  305. }
  308. char SetCardApplicationSector(sttCardStruct *pstCardStruct)
  309. {
  310. Rf_Buffer[SEQNR]=0;
  311. Rf_Buffer[COMMAND]=SPI_CMD_SET_CARD_APP_SECTOR;
  312. Rf_Buffer[LENGTH]=16;
  313. memcpy(&Rf_Buffer[DATA],pstCardStruct,16);
  314. if(Rf_Command(DELAY_TIME0)!=MI_OK)return RF_ERR;
  315. return Rf_Buffer[STATUS];
  316. }
  319. char ReadCardholderInfo(unsigned char CardSerialNo[],
  320. unsigned char AuthMode,
  321. unsigned char Key[],
  322.     sttCardholderInfo *pstCardholderInfo)
  323. {
  324. Rf_Buffer[SEQNR]=0;
  325. Rf_Buffer[COMMAND]=SPI_CMD_READ_CARDHOLDER_INFO;
  326. Rf_Buffer[LENGTH]=11;
  327. memcpy(&Rf_Buffer[DATA],CardSerialNo,4);
  328. Rf_Buffer[DATA+4] = AuthMode;
  329. memcpy(&Rf_Buffer[DATA+5],Key,6);
  330. if(Rf_Command(DELAY_TIME2)!=MI_OK) return RF_ERR;
  331. if(Rf_Buffer[STATUS]==MI_OK)
  332. memcpy(pstCardholderInfo,&Rf_Buffer[DATA],41);
  333. return Rf_Buffer[STATUS];
  334. }
  337. char ReadBusinessInfo(unsigned char CardSerialNo[],
  338.   unsigned char AuthMode,
  339.   unsigned char Key[],
  340.   sttBusinessInfo *pstBusinessInfo)
  341. {
  342. Rf_Buffer[SEQNR]=0;
  343. Rf_Buffer[COMMAND]=SPI_CMD_READ_BUSINESS_INFO;
  344. Rf_Buffer[LENGTH]=23;
  345. memcpy(&Rf_Buffer[DATA],CardSerialNo,4);
  346. Rf_Buffer[DATA+4] = AuthMode;
  347. memcpy(&Rf_Buffer[DATA+5],Key,18);
  348. if(Rf_Command(DELAY_TIME3)!=MI_OK) return RF_ERR;
  349. if(Rf_Buffer[STATUS]==MI_OK)
  350. memcpy(pstBusinessInfo,&Rf_Buffer[DATA],44);
  351. return Rf_Buffer[STATUS];
  352. }
  355. char SetCardState(unsigned char CardSerialNo[],
  356.   unsigned char AuthMode,
  357.       unsigned char Key[],
  358.   unsigned char State)
  359. {
  360. Rf_Buffer[SEQNR]=0;
  361. Rf_Buffer[COMMAND]=SPI_CMD_SET_CARD_STATE;
  362. Rf_Buffer[LENGTH]=12;
  363. memcpy(&Rf_Buffer[DATA],CardSerialNo,4);
  364. Rf_Buffer[DATA+4] = AuthMode;
  365. memcpy(&Rf_Buffer[DATA+5],Key,6);
  366. Rf_Buffer[DATA+11] = State;
  367. if(Rf_Command(DELAY_TIME2)!=MI_OK) return RF_ERR;
  368. return Rf_Buffer[STATUS];
  369. }
  372. char Fill(unsigned char CardSerialNo[], 
  373.   sttBusinessInfo *pstBusinessInfo)
  374. {
  375. Rf_Buffer[SEQNR]=0;
  376. Rf_Buffer[COMMAND]=SPI_CMD_FILL;
  377. Rf_Buffer[LENGTH]=20;
  378. memcpy(&Rf_Buffer[DATA],CardSerialNo,4);
  379. memcpy(&Rf_Buffer[DATA+4],&pstBusinessInfo->stFillInfo,18);
  380. if(Rf_Command(DELAY_TIME3)!=MI_OK) return RF_ERR;
  381. if(Rf_Buffer[STATUS]==MI_OK)
  382. memcpy(pstBusinessInfo,&Rf_Buffer[DATA],22);
  383. return Rf_Buffer[STATUS];
  384. }