设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › rc522 rc523 pn512的底层代码和14443A 和14443B
返回列表 发新帖
查看: 7906|回复: 3
打印 上一主题 下一主题
收起左侧

rc522 rc523 pn512的底层代码和14443A 和14443B

[复制链接]
跳转到指定楼层
楼主
ID:244139 发表于 2018-11-12 17:17 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
关于rc522 rc523 pn512的底层代码和14443A 和14443B 只要掌握了这些代码就可以开发对应的M1卡和CPU卡读写程序


单片机源程序如下:
  1. // 文 件 名:    PN512.c
  2. // 文件描述:    PN512底层函数
  3. // 版    本:    V1.00
  4. // 创 建 人:        曾本森
  5. // 创建日期:        2010.01.26
  6. // 说    明:        注意超时变量g_ucPCDTimeOutCnt定义和有关源代码。
  7. //=================================================================================================
  8. //-----------------修改记录------------------------------------------------------------------------

  10. //-------------------------------------------------------------------------------------------------
  11. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  12. #define PN512_GLOBALS
  13. #include <string.h>
  14. #include "PcdInclude.h"
  15. //============= 常量定义 ==========================================================================
  16. #define PCD_FIFO_MAX_SIZE                        64                        // PCD FIFO的最大为64 - 2字节
  17. #define PCD_FIFO_WATER_LEVEL                16                        // PCD FIFO警戒线
  18. //============= 全局变量定义 ======================================================================
  19. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  20. // 函数原型:        void ResetInfo(void)
  21. // 函数功能:        复位命令信息
  22. // 入口参数:        -
  23. // 出口参数:        -
  24. // 返 回 值:        -
  25. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  26. void ResetInfo(void)
  27. {
  28.         INT8U i;
  29.         INT8U *BfrPtr = (INT8U *)(&MInfo);
  30.        
  31.         for(i=0 ; i<sizeof(MfCmdInfo); i++)
  32.                 BfrPtr[i] = 0;
  33. }
  34. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  35. // 函数原型:    void WriteReg(INT8U ucReg,INT8U ucValue)
  36. // 函数功能:    写寄存器
  37. // 入口参数:    INT8U Reg               // 寄存器地址
  38. //              INT8U Value             // 写入的数据
  39. // 出口参数:    -
  40. // 返 回 值:    -
  41. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  42. #if PCD_WRITE_REG_EN
  43. void WriteReg(INT8U ucReg,INT8U  ucValue)
  44. {
  45.         if(ucReg == JREG_TXCONTROL)
  46.         {
  47.                 g_ucTxConMask = ucValue & 0x03;
  48.         }
  49.         RcSetReg(ucReg, ucValue);
  50. }
  51. #endif                                // PCD_WRITE_REG_EN
  52. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  53. // 函数原型:    INT8U ReadReg(INT8U ucReg)
  54. // 函数功能:    写寄存器
  55. // 入口参数:    INT8U ucReg                                // 寄存器地址
  56. // 出口参数:    -
  57. // 返 回 值:    读出的数据
  58. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  59. #if PCD_READ_REG_EN
  60. INT8U ReadReg(INT8U ucReg)
  61. {
  62.         return RcGetReg(ucReg);
  63. }
  64. #endif                                // PCD_READ_REG_EN
  65. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  66. // 函数原型:   void PcdHardRst(void)
  67. // 函数功能:   PCD硬件复位
  68. // 入口参数:   -
  69. // 出口参数:   -
  70. // 返 回 值:   -
  71. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  72. void PcdHardRst(void)
  73. {
  74.         INTU i;

  76.         PcdClrTPD();
  77.         for(i = 0; i < 75; i++);                                        // 低电平脉冲宽度大于100ns即可
  78.         PcdSetTPD();
  79.         for(i = 0;i < 2500; i++);                                        // 等待晶振稳定，根据晶振起振情况调整此延时时间
  80. }
  81. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  82. // 函数原型:        void PcdClose(void)
  83. // 函数功能:        关闭PCD
  84. // 入口参数:        -
  85. // 出口参数:        -
  86. // 返 回 值:        -
  87. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  88. #if        PCD_CLOSE_EN
  89. void PcdClose()
  90. {
  91. #if        HARDWARE_MODE
  92.         PcdClrTPD();
  93. #else
  94.         RcSetReg(JREG_COMMAND, JCMD_SOFTRESET);                // 软件复位
  95. #endif                                // HARDWARE_MODE
  96. }
  97. #endif                                // PCD_CLOSE_EN
  98. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  99. // 函数原型:        void SetTimeOut(INT32U _302us)
  100. // 函数功能:        设置定时器超时。
  101. // 入口参数:        INT32U _302us                        ; 超时时间 = (_302us) * 302 (us)
  102. // 出口参数:        -
  103. // 返 回 值:        -
  104. // 说    明:        在PcdConfig()中已将预分频器设置为每302us输出一计数脉冲。
  105. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  106. void SetTimeOut(INT32U _302us)
  107. {
  108.     RcSetReg(JREG_TRELOADLO, ((INT8U)(_302us & 0xff)));
  109.     RcSetReg(JREG_TRELOADHI, ((INT8U)((_302us >> 8) & 0xff)));
  110. }
  111. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  112. // 函数原型:        void PcdISOType(INT8U ucType)
  113. // 函数功能:        修改PCD的模式
  114. // 入口参数:        INT8U ucType                                        // ISO14443_TYPEA,
  115. //                                                                                                // ISO14443_TYPEB
  116. //                                                                                                // ISO18092_NFCIP
  117. // 出口参数:        -
  118. // 返 回 值:        -
  119. // 说    明:        默认模式为TYPEA
  120. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  121. void PcdISOType(INT8U ucType)
  122. {
  123. #if PCD_MODE == PN512
  124. // 使用PN512
  125.         if(ucType == ISO18092_NFCIP)
  126.         {
  127.                 RcSetReg(JREG_CONTROL, 0x10);
  128.                 RcSetReg(JREG_TXMODE, 0x92);
  129.                 RcSetReg(JREG_RXMODE, 0x96);
  130.                 //RcSetReg(JREG_TXCONTROL, 0x80);
  131.                 RcSetReg(JREG_TXASK, 0x37);       
  132.                 RcSetReg(JREG_RXTHRESHOLD, 0x55);
  133.                 RcSetReg(JREG_DEMOD, 0x41);
  134. //                RcSetReg(JREG_MIFNFC, 0x62);
  135. //                RcSetReg(JREG_TXBITPHASE, (RcGetReg(JREG_TXASK) & 0x80) | 0x0f);
  136.                 RcSetReg(JREG_RFCFG, 0x59);               
  137.                 RcSetReg(JREG_GSN, 0xFF);
  138.                 RcSetReg(JREG_CWGSP, 0x3F);       
  139.                 RcSetReg(JREG_MODGSP, 0x0F);
  140.         }
  141.         else if (ucType == ISO14443_TYPEB)
  142.         {
  143.                 RcSetReg(JREG_TXASK, 0x00);               
  144.                 RcSetReg(JREG_CONTROL, 0x10);               
  145.                 RcSetReg(JREG_TXMODE, 0x03);
  146.                 RcSetReg(JREG_RXMODE, 0x0B);
  147.                 RcSetReg(JREG_TYPEB, 0x03);               
  148.                                                                                                
  149.                 RcSetReg(JREG_DEMOD, 0x4D);
  150.                 RcSetReg(JREG_GSN, 0xFF);
  151.                 RcSetReg(JREG_CWGSP, 0x3F);               
  152.                 //                RcSetReg(JREG_MODGSP, 0x1b);
  153.                 RcSetReg(JREG_MODGSP, 0x18);       
  154.                 RcSetReg(JREG_RXTHRESHOLD, 0x55);       
  155.                 RcSetReg(JREG_RFCFG, 0x68);               
  156.         }
  157.         else
  158.         {
  159.                 RcSetReg(JREG_TXASK, 0x40);        
  160.                 RcSetReg(JREG_CONTROL, 0x10);       
  161.                 RcSetReg(JREG_TXMODE, 0x00);       
  162.                 RcSetReg(JREG_RXMODE, 0x08);       

  164.                 RcSetReg(JREG_DEMOD, 0x4D);
  165.                 RcSetReg(JREG_CWGSP, 0x3F);                       
  166.                 RcSetReg(JREG_RXTHRESHOLD, 0x84);       
  167.                 RcSetReg(JREG_RFCFG, 0x48);                       
  168.    }
  169. #elif PCD_MODE == RC523
  170. // 使用RC523
  171.    if(ucType == ISO14443_TYPEB)
  172.    {
  173.              RcSetReg(JREG_TXASK, 0x00);               
  174.                 RcSetReg(JREG_CONTROL, 0x10);               
  175.              RcSetReg(JREG_TXMODE, 0x03);               
  176.                 RcSetReg(JREG_RXMODE, 0x0B);       
  177.                 RcSetReg(JREG_TYPEB, 0x03);                       
  178.                                                                                                                
  179.                 RcSetReg(JREG_DEMOD, 0x4d);
  180.                 RcSetReg(JREG_GSN, 0xff);
  181.                 RcSetReg(JREG_CWGSP, 0x3f);                       
  182. //                RcSetReg(JREG_MODGSP, 0x1b);       
  183.                 RcSetReg(JREG_MODGSP, 0x18);               
  184.                 RcSetReg(JREG_RXTHRESHOLD, 0x55);       
  185.                 RcSetReg(JREG_RFCFG, 0x68);                       
  186.         }
  187.         else
  188.         {
  189.                 RcSetReg(JREG_TXASK, 0x40);                
  190.                 RcSetReg(JREG_CONTROL, 0x10);               
  191.                 RcSetReg(JREG_TXMODE, 0x00);               
  192.                 RcSetReg(JREG_RXMODE, 0x08);               

  194.                 RcSetReg(JREG_DEMOD, 0x4D);
  195.                 RcSetReg(JREG_CWGSP, 0x3F);                       
  196.                 RcSetReg(JREG_RXTHRESHOLD, 0x84);       
  197.                 RcSetReg(JREG_RFCFG, 0x48);                       
  198.    }
  199. #else
  200. // 使用RC522
  201.         ucType = ucType;
  202.         RcSetReg(JREG_TXASK, 0x40);        
  203.         RcSetReg(JREG_CONTROL, 0x10);       
  204.         RcSetReg(JREG_TXMODE, 0x00);               
  205.         RcSetReg(JREG_RXMODE, 0x08);               

  207.         RcSetReg(JREG_DEMOD, 0x4D);
  208.         RcSetReg(JREG_CWGSP, 0x3F);                       
  209.         RcSetReg(JREG_RXTHRESHOLD, 0x84);               
  210.         RcSetReg(JREG_RFCFG, 0x48);                       
  211. #endif
  212. }
  213. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  214. // 函数原型:        INT8U PcdConfig(INT8U ucType)
  215. // 函数功能:        配置芯片
  216. // 入口参数:        INT8U ucType                                        // TYPEA -- ISO14443A,TYPEB -- ISO14443B
  217. // 出口参数:        -
  218. // 返 回 值:        STATUS_SUCCESS -- 操作成功，其他值 -- 操作失败
  219. // 说    明:        -
  220. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  221. INT8U PcdConfig(INT8U ucType)
  222. {
  223.         INT8U ucRegVal;

  225. #if        HARDWARE_MODE
  226.         PcdHardRst();                                                                // 硬件复位
  227. #else
  228.         RcSetReg(JREG_COMMAND, JCMD_SOFTRESET);                // 复位芯片
  229. #endif                                // HARDWARE_MODE
  230.        
  231.         PcdISOType(ucType);
  232.        
  233.         RcSetReg(JREG_GSN, 0xF0 | 0x04);       
  234.         ucRegVal = RcGetReg(JREG_GSN);
  235.         if(ucRegVal != 0xF4)                       
  236.                 return STATUS_INIT_ERROR;



  240.         RcSetReg(JREG_TPRESCALER, FREQ_SPLI_302us & 0xff);
  241.         RcSetReg(JREG_TMODE, JBIT_TAUTO | ((FREQ_SPLI_302us >> 8) & JMASK_TPRESCALER_HI));                                               

  243.         SetTimeOut(RIC_DELAY5MS);                       
  244.        

  246.     RcModifyReg(JREG_TXCONTROL, 1, JBIT_TX2RFEN | JBIT_TX1RFEN);

  248.     RcModifyReg(JREG_CONTROL, 1, JBIT_TSTARTNOW);

  250.     do {
  251.         ucRegVal = RcGetReg(JREG_COMMIRQ);
  252.     }while(!(ucRegVal & JBIT_TIMERI));

  254.     RcSetReg(JREG_COMMIRQ, JBIT_TIMERI);       
  255.         RcSetReg(JREG_COMMAND, JCMD_IDLE);
  256.         RcSetReg(JREG_ANALOGTEST, 0xCD);
  257.        
  258.         RcSetReg(JREG_TXSEL, 0x17);
  259.        
  260. #if PCD_IRQ_EN
  261.         RcSetReg(JREG_WATERLEVEL, PCD_FIFO_WATER_LEVEL);       
  262. #endif                                // INIT_MODE_EN

  264.         g_ucTxConMask = 0x03;

  266.         return STATUS_SUCCESS;
  267. }
  268. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  269. // 函数原型:        void PCDISR (void)
  270. // 函数功能:        Pcd中断服务程序
  271. // 入口参数:        -
  272. // 出口参数:        -
  273. // 返 回 值:        -
  274. // 说    明:        -
  275. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  276. #if PCD_IRQ_EN

  278. #ifdef __C51__
  279. void PCDISR (void) interrupt 0 using 1       
  280. {       
  281.         IE0 = 0;                                                        
  282. #else
  283. void PCDISR (void)
  284. {
  285. #endif                        // __C51__
  286.        
  287.         MInfo.Irq = (INT8U)(RcGetReg(JREG_COMMIRQ) & MInfo.CommIrqEn);
  288. //        MInfo.Irq  = RcGetReg(JREG_COMMIRQ);       
  289. //        MInfo.Irq &= MInfo.CommIrqEn;
  290.         if (MInfo.Irq & JBIT_LOALERTI)       
  291.         {// FIFO空中断
  292.                 MInfo.nBytes = MInfo.nBytesToSend - MInfo.nBytesSent;
  293.                 if (MInfo.nBytes < PCD_FIFO_MAX_SIZE - 2 * PCD_FIFO_WATER_LEVEL)
  294.                 {
  295.                         if(MInfo.nBytes)                       
  296.                         {
  297.                                 WriteFIFO(MInfo.pExBuf + MInfo.nBytesSent, MInfo.nBytes);
  298.                                 MInfo.nBytesSent += MInfo.nBytes;
  299.                         }
  300.                         if (MInfo.DoRcv)                       
  301.                                 MInfo.CommIrqEn |= JBIT_RXI | JBIT_HIALERTI;
  302.                         MInfo.CommIrqEn &= ~JBIT_LOALERTI;       
  303.                         RcSetReg(JREG_COMMIEN, (INT8U)(JBIT_IRQINV | MInfo.CommIrqEn));               
  304.                         RcSetReg(JREG_COMMIRQ, JBIT_LOALERTI);                                                                       

  306.                 }
  307.                 else
  308.                 {
  309.                         WriteFIFO(MInfo.pExBuf + MInfo.nBytesSent, PCD_FIFO_MAX_SIZE - 2 * PCD_FIFO_WATER_LEVEL);
  310.                         RcSetReg(JREG_COMMIRQ, JBIT_LOALERTI);               
  311.                         MInfo.nBytesSent += PCD_FIFO_MAX_SIZE - 2 * PCD_FIFO_WATER_LEVEL;
  312.                 }
  313.         }
  314.         if (MInfo.Irq & JBIT_TXI)
  315.         {
  316.                 MInfo.CommIrqEn &= ~(JBIT_TXI | JBIT_LOALERTI);       
  317.                 if (MInfo.DoRcv)                                                               
  318.                         MInfo.CommIrqEn |= JBIT_RXI | JBIT_HIALERTI;
  319.                 RcSetReg(JREG_COMMIEN, (INT8U)(JBIT_IRQINV | MInfo.CommIrqEn));       
  320.                 RcSetReg(JREG_COMMIRQ, JBIT_TXI | JBIT_LOALERTI);       
  321.                
  322.         }

  324.         if (MInfo.Irq & (JBIT_HIALERTI | JBIT_IDLEI |JBIT_RXI))       
  325.         {
  326.                 if(MInfo.DoRcv)
  327.                 {
  328.                         MInfo.nBitsReceived =  RcGetReg(JREG_FIFOLEVEL);
  329.                         ReadFIFO(MInfo.pExBuf + MInfo.nBytesReceived, MInfo.nBitsReceived);
  330.                         MInfo.nBytesReceived += MInfo.nBitsReceived;
  331.                         MInfo.nBitsReceived = (INT8U)(RcGetReg(JREG_CONTROL) & 0x07);
  332.             if(MInfo.nBitsReceived && MInfo.nBytesReceived)       
  333.                 MInfo.nBytesReceived --;
  334.                         RcSetReg(JREG_COMMIRQ, JBIT_HIALERTI | JBIT_RXI | JBIT_IDLEI);
  335.                 }
  336.         }

  338.         if (MInfo.Irq & JBIT_IDLEI)
  339.         {
  340.                 RcModifyReg(JREG_COMMIEN, 0, JBIT_TIMERI| JBIT_IDLEI);
  341.                 RcSetReg(JREG_COMMIRQ, JBIT_TIMERI | JBIT_IDLEI);       
  342.         }
  343.        
  344.         if (MInfo.Irq & JBIT_TIMERI)
  345.         {
  346.                 RcModifyReg(JREG_COMMIEN, 0, JBIT_TIMERI);
  347.                 RcSetReg(JREG_COMMIRQ, JBIT_TIMERI);
  348.                 MInfo.Status = STATUS_IO_TIMEOUT;
  349.         }
  350.        
  351.         if (MInfo.Irq & JBIT_ERRI)
  352.         {
  353.                 MInfo.nBytes = RcGetReg(JREG_ERROR);
  354.                 if(MInfo.nBytes)                               
  355.                 {
  356.                         if(MInfo.nBytes & JBIT_COLLERR)
  357.                                 MInfo.Status = STATUS_COLLISION_ERROR;
  358.                         else if(MInfo.nBytes & JBIT_PARITYERR)
  359.                                 MInfo.Status = STATUS_PARITY_ERROR;

  361.                         if(MInfo.nBytes & JBIT_PROTERR)
  362.                                 MInfo.Status = STATUS_PROTOCOL_ERROR;
  363.                         else if(MInfo.nBytes & JBIT_BUFFEROVFL)
  364.                                 MInfo.Status = STATUS_BUFFER_OVERFLOW;
  365.                         else if(MInfo.nBytes & JBIT_CRCERR)
  366.                         {                                                                          
  367.                                 if(MInfo.nBytesReceived == 0x01 &&
  368.                                         (MInfo.nBitsReceived == 0x04 ||
  369.                                          MInfo.nBitsReceived == 0x00))
  370.                                 {  
  371.                                         MInfo.pExBuf[0] = RcGetReg(JREG_FIFODATA);
  372.                                         MInfo.nBytesReceived = 1;
  373.                                         MInfo.Status = STATUS_ACK_SUPPOSED;
  374.                                 }
  375.                                 else
  376.                                         MInfo.Status = STATUS_CRC_ERROR;
  377.                         }
  378.                         else if(MInfo.nBytes & JBIT_TEMPERR)
  379.                                 MInfo.Status = STATUS_TEMP_ERROR;   

  381.                         if(MInfo.nBytes & JBIT_WRERR)
  382.                                 MInfo.Status = STATUS_FIFO_WRITE_ERROR;
  383.                         if(MInfo.Status == STATUS_SUCCESS)
  384.                                 MInfo.Status = STATUS_ERROR_NY_IMPLEMENTED;
  385.                                
  386.                 }

  388.                 RcSetReg(JREG_ERROR, 0);
  389.                 RcSetReg(JREG_COMMIRQ, JBIT_ERRI);               
  390.         }
  391.         MInfo.AllCommIrq |= MInfo.Irq;                       

  393.         MInfo.Irq  = (INT8U)(RcGetReg(JREG_DIVIRQ) & MInfo.DivIrqEn);
  394.         if (MInfo.Irq)
  395.         {
  396.                 if (MInfo.Irq & JBIT_SIGINACTI)
  397.                 {
  398.                         RcSetReg(JREG_DIVIRQ, JBIT_SIGINACTI);       
  399.                 }

  401.                 if (MInfo.Irq & JBIT_MODE)
  402.                 {
  403.                         RcSetReg(JREG_DIVIRQ, JBIT_MODE);       
  404.                 }

  406.                 if (MInfo.Irq & JBIT_CRCI)
  407.                 {
  408.                         RcSetReg(JREG_DIVIRQ, JBIT_CRCI);
  409.                 }

  411.                 if (MInfo.Irq & JBIT_RFON)
  412.                 {
  413.                         RcSetReg(JREG_DIVIRQ, JBIT_RFON);
  414.                 }

  416.                 if (MInfo.Irq & JBIT_RFOFF)
  417.                 {       
  418.                         RcSetReg(JREG_DIVIRQ, JBIT_RFOFF);       
  419.                 }
  420.                 MInfo.AllDivIrq |= MInfo.Irq;       
  421.         }       
  422. }
  423. #endif                                // PCD_IRQ_EN
  424. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  425. // 函数原型:        INT8U  PcdCmd(INT8U ucCmd,INT16U nCmdLen,INT8U *pExchangeBuf)
  426. // 函数功能:        Pcd将数据发送到卡，然后等待接收从卡返回的数据。
  427. // 入口参数:        INT8U ucCmd                                                // 命令
  428. //                                INT16U nCmdLen                                        // 命令长度
  429. //                                INT8U *pExchangeBuf                                // 发送数据缓冲区首址。
  430. // 出口参数:        INT8U *pExchangeBuf                                // 接收数据缓冲区首址。
  431. // 返 回 值:        STATUS_SUCCESS -- 操作成功，其他值 -- 操作失败
  432. // 说    明:        -
  433. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  434. #if        PCD_IRQ_EN
  435. // 使用中断模式
  436. INT8U  PcdCmd(INT8U ucCmd,INT16U nCmdLen,INT8U *pExchangeBuf)
  437. {
  438.         INT8U  ucRegVal;
  439.        
  440.         MInfo.Status = STATUS_SUCCESS;
  441.         MInfo.Cmd = ucCmd;
  442.         MInfo.pExBuf = pExchangeBuf;
  443.         MInfo.nBytesToSend = nCmdLen;
  444. //        MInfo.nBytesSent = 0;
  445.                
  446. //        RcSetReg(JREG_COMMIEN, 0x00);       
  447. //    RcSetReg(JREG_DIVIEN, 0x00);
  448.     RcSetReg(JREG_COMMIRQ, 0x7F);       
  449.     RcSetReg(JREG_DIVIRQ, 0x7F);
  450.     RcSetReg(JREG_FIFOLEVEL, JBIT_FLUSHBUFFER);

  452.     ucRegVal = RcGetReg(JREG_COMMAND);   
  453.     if(MInfo.Cmd == JCMD_TRANSCEIVE)
  454.     {                                                                               
  455.         RcSetReg(JREG_COMMAND, (INT8U)((ucRegVal & ~JMASK_COMMAND) | JCMD_TRANSCEIVE));
  456.     }
  457.     else
  458.     {                                                                       
  459.         RcSetReg(JREG_COMMAND, (INT8U)(ucRegVal & ~JMASK_COMMAND));
  460.     }
  461.     switch(MInfo.Cmd)
  462.     {
  463.                case JCMD_IDLE:
  464.                         MInfo.WaitForComm = 0;
  465.             MInfo.WaitForDiv  = 0;
  466.             break;
  467. #ifndef RC522
  468.                 case JCMD_MEM:
  469.                         MInfo.CommIrqEn = JBIT_IDLEI;
  470.             MInfo.WaitForComm = JBIT_IDLEI;
  471.             break;
  472. #endif
  473.         case JCMD_CALCCRC:
  474.             MInfo.WaitForComm = 0;
  475.             MInfo.WaitForDiv  = 0;
  476.             break;
  477.         case JCMD_TRANSMIT:
  478.             MInfo.CommIrqEn   = JBIT_TXI | JBIT_TIMERI| JBIT_LOALERTI | JBIT_ERRI;
  479.             MInfo.WaitForComm = JBIT_TXI | JBIT_ERRI;
  480.             break;
  481.         case JCMD_RECEIVE:
  482.             MInfo.CommIrqEn   = JBIT_RXI | JBIT_TIMERI | JBIT_HIALERTI |JBIT_ERRI;
  483.             MInfo.WaitForComm = JBIT_RXI | JBIT_TIMERI | JBIT_ERRI;
  484.                         MInfo.DoRcv = 1;
  485.             break;
  486.         case JCMD_TRANSCEIVE:
  487.             MInfo.CommIrqEn   = JBIT_RXI | JBIT_TIMERI | JBIT_LOALERTI | JBIT_ERRI;
  488.             MInfo.WaitForComm = JBIT_RXI | JBIT_TIMERI | JBIT_ERRI;
  489.                         MInfo.DoRcv = 1;
  490.             break;
  491.         case JCMD_AUTHENT:
  492.             MInfo.CommIrqEn   = JBIT_IDLEI | JBIT_TIMERI | JBIT_ERRI;
  493.             MInfo.WaitForComm = JBIT_IDLEI | JBIT_TIMERI | JBIT_ERRI;
  494.             break;
  495.         case JCMD_SOFTRESET:
  496.             MInfo.WaitForComm = 0;
  497.             MInfo.WaitForDiv  = 0;
  498.             break;
  499.         default:
  500.             MInfo.Status = STATUS_UNSUPPORTED_COMMAND;
  501.     }
  502.        
  503.     if(MInfo.Status == STATUS_SUCCESS)
  504.     {

  506.                 OS_ENTER_CRITICAL();               
  507.         RcSetReg(JREG_COMMIEN,         JBIT_IRQINV | MInfo.CommIrqEn);
  508. //     RcSetReg(JREG_DIVIEN,  MInfo.DivIrqEn);       
  509.                 RcSetReg(JREG_DIVIEN,  JBIT_IRQPUSHPULL | MInfo.DivIrqEn);
  510.         OS_EXIT_CRITICAL();                       
  511.         
  512.         if(MInfo.Cmd == JCMD_TRANSCEIVE)
  513.         {                                                       
  514.             RcModifyReg(JREG_BITFRAMING, 1, JBIT_STARTSEND);
  515.         }
  516.         else
  517.             RcSetReg(JREG_COMMAND, (INT8U)((RcGetReg(JREG_COMMAND) & ~JMASK_COMMAND) | MInfo.Cmd));
  518.             
  519.       
  520.         while(!(MInfo.WaitForComm ? (MInfo.WaitForComm & MInfo.AllCommIrq) : 1) ||
  521.               !(MInfo.WaitForDiv  ? (MInfo.WaitForDiv  & MInfo.AllDivIrq ) : 1))
  522.         {      
  523.                          OSSemPend(PcdIntSem,100,&ucRegVal);
  524.                     if(ucRegVal != OS_NO_ERR)
  525.                     {
  526.                                 MInfo.Status = STATUS_ACCESS_TIMEOUT;
  527.                                 break;                      
  528.                     }      
  529.                
  530.         }
  531.     }

  533. //    RcModifyReg(JREG_COMMIEN, 0, MInfo.CommIrqEn);
  534. //    RcModifyReg(JREG_DIVIEN,  0, MInfo.DivIrqEn);
  535.         RcSetReg(JREG_COMMIEN, 0x80);               
  536.     RcSetReg(JREG_DIVIEN, 0x00);

  538.     RcSetReg(JREG_COMMIRQ, 0x7F);
  539.     RcSetReg(JREG_DIVIRQ, 0X7F);
  540.     RcSetReg(JREG_FIFOLEVEL, JBIT_FLUSHBUFFER);

  542.     RcSetReg(JREG_BITFRAMING, 0);
  543.    
  544.    
  545.     return MInfo.Status;
  546. }
  547. #else
  548. // 使用查询模式
  549. INT8U  PcdCmd(INT8U ucCmd,INT16U ucCmdLen,INT8U *pExchangeBuf)
  550. {
  551.     INT8U  ucStatus = STATUS_SUCCESS;
  552.        
  553.     INT8U  CommIrqEn   = 0;
  554.     INT8U  divIrqEn    = 0;
  555.     INT8U  WaitForComm = JBIT_ERRI | JBIT_TXI;
  556.     INT8U  WaitForDiv  = 0;
  557.     INT8U  doReceive   = 0;
  558.     INT8U  getRegVal,setRegVal;
  559.     INT8U  nbytes;
  560.         INT16U nbits;
  561.    
  562.         MInfo.Cmd = ucCmd;
  563.         MInfo.nBytesToSend = (INT8U)(ucCmdLen & 0xFF);       
  564.     RcSetReg(JREG_COMMIRQ, 0x7F);                               
  565.     RcSetReg(JREG_DIVIRQ, 0x7F);
  566.     RcSetReg(JREG_FIFOLEVEL, JBIT_FLUSHBUFFER);

  568.     getRegVal = RcGetReg(JREG_COMMAND);                   
  569.     if(MInfo.Cmd == JCMD_TRANSCEIVE)
  570.     {                                                                                       
  571.         setRegVal = (getRegVal & ~JMASK_COMMAND) | JCMD_TRANSCEIVE;
  572.         RcSetReg(JREG_COMMAND, setRegVal);
  573.     }
  574.     else
  575.     {                                                                                       
  576.         setRegVal = (getRegVal & ~JMASK_COMMAND);
  577.         RcSetReg(JREG_COMMAND, setRegVal);
  578.     }
  579.     switch(MInfo.Cmd)
  580.     {
  581.                case JCMD_IDLE:
  582.                         WaitForComm = 0;
  583.             WaitForDiv  = 0;
  584.             break;
  585. #ifndef RC522
  586.                 case JCMD_MEM:
  587.                         CommIrqEn = JBIT_IDLEI;
  588.             WaitForComm = JBIT_IDLEI;
  589.             break;
  590. #endif
  591.         case JCMD_CALCCRC:
  592.             WaitForComm = 0;
  593.             WaitForDiv  = 0;
  594.             break;
  595.         case JCMD_TRANSMIT:
  596.             CommIrqEn = JBIT_TXI | JBIT_TIMERI;
  597.             WaitForComm = JBIT_TXI;
  598.             break;
  599.         case JCMD_RECEIVE:
  600.             CommIrqEn = JBIT_RXI | JBIT_TIMERI;                //| JBIT_ERRI;
  601.             WaitForComm = JBIT_RXI | JBIT_TIMERI;         //| JBIT_ERRI;
  602.             doReceive = 1;
  603.             break;
  604.         case JCMD_TRANSCEIVE:
  605.             CommIrqEn = JBIT_RXI | JBIT_TIMERI;         //| JBIT_ERRI;
  606.             WaitForComm = JBIT_RXI | JBIT_TIMERI;        //| JBIT_ERRI;
  607.             doReceive = 1;
  608.             break;
  609.         case JCMD_AUTHENT:
  610.             CommIrqEn = JBIT_IDLEI | JBIT_TIMERI;        //| JBIT_ERRI;
  611.             WaitForComm = JBIT_IDLEI | JBIT_TIMERI;        //| JBIT_ERRI;
  612.             break;
  613.         case JCMD_SOFTRESET:
  614.             WaitForComm = 0;
  615.             WaitForDiv  = 0;
  616.             break;
  617.         default:
  618.             ucStatus = STATUS_UNSUPPORTED_COMMAND;
  619.     }
  620.        
  621.     if(ucStatus == STATUS_SUCCESS)
  622.     {                                                                               
  623.         getRegVal = RcGetReg(JREG_COMMIEN);
  624.         RcSetReg(JREG_COMMIEN, (INT8U)(getRegVal | CommIrqEn));

  626.         getRegVal = RcGetReg(JREG_DIVIEN);
  627.         RcSetReg(JREG_DIVIEN, (INT8U)(getRegVal | divIrqEn));

  629.         WriteFIFO(pExchangeBuf,MInfo.nBytesToSend);

  631.         
  632.         if(MInfo.Cmd == JCMD_TRANSCEIVE)               
  633.         {                                                                               
  634.             RcModifyReg(JREG_BITFRAMING, 1, JBIT_STARTSEND);
  635.         }
  636.         else
  637.         {
  638.             getRegVal = RcGetReg(JREG_COMMAND);
  639.             RcSetReg(JREG_COMMAND, (INT8U)((getRegVal & ~JMASK_COMMAND) | MInfo.Cmd));
  640.         }
  641.         getRegVal = 0;                                       
  642.         setRegVal = 0;
  643.         
  644.                 g_ucPCDTmOut = PCD_DELAY555MS;               
  645.         while(!(WaitForComm ? (WaitForComm & setRegVal) : 1) ||
  646.               !(WaitForDiv ? (WaitForDiv & getRegVal) :1))
  647.         {
  648.             setRegVal = RcGetReg(JREG_COMMIRQ);
  649.             getRegVal = RcGetReg(JREG_DIVIRQ);
  650.             if(g_ucPCDTmOut == 0)
  651.                 break;                                               
  652.         }
  653.                 if(g_ucPCDTmOut == 0)
  654.                 {
  655.                         ucStatus = STATUS_ACCESS_TIMEOUT;
  656.                 }
  657.                 else
  658.                 {                                                               
  659.                 WaitForComm = (INT8U)(WaitForComm & setRegVal);
  660.                 WaitForDiv  = (INT8U)(WaitForDiv & getRegVal);
  661.        
  662.                 if (setRegVal & JBIT_TIMERI)          
  663.                 {
  664.                     ucStatus = STATUS_IO_TIMEOUT;
  665.                 }
  666.                 }
  667.     }

  669.     RcModifyReg(JREG_COMMIEN, 0, CommIrqEn);  
  670.     RcModifyReg(JREG_DIVIEN, 0, divIrqEn);

  672.     if(doReceive && (ucStatus == STATUS_SUCCESS))
  673.     {                                                                                
  674.         MInfo.nBytesReceived = RcGetReg(JREG_FIFOLEVEL);
  675.         nbytes = MInfo.nBytesReceived;
  676.         getRegVal = RcGetReg(JREG_CONTROL);
  677.         MInfo.nBitsReceived = (INT8U)(getRegVal & 0x07);
  678.         nbits = MInfo.nBitsReceived;

  680.         getRegVal = RcGetReg(JREG_ERROR);

  682.         if(getRegVal)                               
  683.         {
  684.             if(getRegVal & JBIT_COLLERR)
  685.                 ucStatus = STATUS_COLLISION_ERROR;
  686.             else if(getRegVal & JBIT_PARITYERR)
  687.                 ucStatus = STATUS_PARITY_ERROR;     

  689.             if(getRegVal & JBIT_PROTERR)
  690.                 ucStatus = STATUS_PROTOCOL_ERROR;  
  691.             else if(getRegVal & JBIT_BUFFEROVFL)
  692.                 ucStatus = STATUS_BUFFER_OVERFLOW;  
  693.             else if(getRegVal & JBIT_CRCERR)
  694.             {                                                                  
  695.                 if(MInfo.nBytesReceived == 0x01 &&
  696.                     (MInfo.nBitsReceived == 0x04 ||
  697.                      MInfo.nBitsReceived == 0x00))
  698.                 {  
  699.                     pExchangeBuf[0] = RcGetReg(JREG_FIFODATA);
  700.                     MInfo.nBytesReceived = 1;
  701.                     ucStatus = STATUS_ACK_SUPPOSED;       
  702.                 }
  703.                 else
  704.                     ucStatus = STATUS_CRC_ERROR;   
  705.             }
  706.             else if(getRegVal & JBIT_TEMPERR)
  707.                 ucStatus = STATUS_TEMP_ERROR;  
  708.             if(getRegVal & JBIT_WRERR)
  709.                 ucStatus = STATUS_FIFO_WRITE_ERROR;
  710.             if(ucStatus == STATUS_SUCCESS)
  711.                 ucStatus = STATUS_ERROR_NY_IMPLEMENTED;

  713.             RcSetReg(JREG_ERROR, 0);
  714.         }

  716.         if(ucStatus != STATUS_ACK_SUPPOSED)       
  717.         {
  718.             ReadFIFO(pExchangeBuf,MInfo.nBytesReceived);
  719.             if(MInfo.nBitsReceived && MInfo.nBytesReceived)       
  720.                 MInfo.nBytesReceived --;
  721.         }
  722.     }
  723.     RcSetReg(JREG_COMMIRQ, WaitForComm);
  724.     RcSetReg(JREG_DIVIRQ, WaitForDiv);
  725.     RcSetReg(JREG_FIFOLEVEL, JBIT_FLUSHBUFFER);
  726.     RcSetReg(JREG_COMMIRQ, JBIT_TIMERI);
  727.     RcSetReg(JREG_BITFRAMING, 0);
  728.     return ucStatus;
  729. }
  730. #endif                                // PCD_IRQ_EN
  731. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  732. // 函数原型:        void CardReset(INT8U ucPause_1ms,INT8U ucWait_1ms)
  733. // 函数功能:        使RF场产生1个暂停，让卡复位
  734. // 入口参数:        INT8U ucPause_1ms                ; 暂停时间，关闭RF场该时间后重新打开，
  735. //                                                                                                ; 若为0则不重新打开
  736. //                                INT8U ucWait_1ms                ; RF场重新打开后持续等待该时间，若为0则不等待
  737. // 出口参数:        -
  738. // 返 回 值:        -
  739. // 说    明:        等待时间可根据卡的功耗而定，如Mifare1卡的功耗较小，等待数毫秒即可，
  740. //                                而CPU卡功耗较大，需要等待80毫秒左右。
  741. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  742. #if PCD_CARD_REST_EN
  743. void CardReset(INT8U ucPause_1ms,INT8U ucWait_1ms)
  744. {
  745.         INT8U RegVal;

  747.         // 关闭RF场
  748. ……………………

  750. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
Driver.zip (33.43 KB, 下载次数: 137)


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:482193 发表于 2019-8-23 09:07 | 只看该作者
有使用示例吗??
回复

使用道具 举报

板凳
ID:369226 发表于 2020-6-22 13:08 | 只看该作者
谢谢分享
回复

使用道具 举报

地板
ID:888543 发表于 2024-12-20 10:06 | 只看该作者
整合需要，下载试试。
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表