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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › MH523芯片 MH1608C单片机开发程序源码
返回列表 发新帖
查看: 3868|回复: 1
收起左侧

MH523芯片 MH1608C单片机开发程序源码

[复制链接]
ID:400401 发表于 2018-9-20 09:52 | 显示全部楼层 |阅读模式
MH1608C开发程序    RC523芯片
0.png

单片机源程序如下:
  1. /**
  2. ****************************************************************
  3. * @file rc523.c
  4. *
  5. * @brief  rc523 driver.
  6. *
  7. * @author
  8. *
  9. *
  10. ****************************************************************
  11. */

  13. /*
  14. * INCLUDE FILES
  15. ****************************************************************
  16. */
  17. #include "define.h"

  19. #include<stdlib.h>
  20. #include<stdio.h>
  21. #include<string.h>

  23. #include "stc_new_8051.h"
  24. #include "spi.h"
  25. #include "uart.h"
  26. #include "timer.h"
  27. #include "iso14443_4.h"
  28. #include "mh523.h"


  31. #define FIFO_SIZE        64
  32. #define FSD 256 //Frame Size for proximity coupling Device


  35. #define        READ_REG_CTRL        0x80
  36. #define        TP_FWT_302us        2048
  37. #define TP_dFWT        192

  39. #define MAX_RX_REQ_WAIT_MS        5000 // 命令等待超时时间100ms


  42. transceive_buffer XDATA mf_com_data;

  44. /**
  45. ****************************************************************
  46. * @brief pcd_init()
  47. *
  48. * 初始化芯片
  49. *
  50. * @param:   
  51. * @return:
  52. * @retval:
  53. ****************************************************************
  54. */
  55. void pcd_init()
  56. {
  57.         pcd_poweron();
  58.         mdelay(5);
  59.        
  60.         pcd_reset();
  61.         mdelay(5);
  62.         pcd_config('A');       
  63. }


  66. /**
  67. ****************************************************************
  68. * @brief pcd_config()
  69. *
  70. * 配置芯片的A/B模式
  71. *
  72. * @param: u8 type   
  73. * @return:
  74. * @retval:
  75. ****************************************************************
  76. */
  77. char pcd_config(u8 type)
  78. {
  79.         pcd_antenna_off();
  80.         mdelay(7);

  82.         if ('A' == type)
  83.         {
  84.             clear_bit_mask(Status2Reg, BIT3);
  85.                 clear_bit_mask(ComIEnReg, BIT7); // 高电平
  86.         write_reg(ModeReg,0x3D);        // 11 // CRC seed:6363
  87.         write_reg(RxSelReg, 0x86);//RxWait
  88.                 write_reg(RFCfgReg, 0x58); //
  89.                 write_reg(TxASKReg, 0x40);//15  //typeA
  90.                 write_reg(TxModeReg, 0x00);//12 //Tx Framing A
  91.                 write_reg(RxModeReg, 0x00);//13 //Rx framing A
  92.                 write_reg(0x0C, 0x10);        //^_^

  94.                 //兼容配置
  95.                 {
  96.                         u8 backup, adc;
  97.                         backup = read_reg(0x37);
  98.                         write_reg(0x37, 0x00);       
  99.                         adc = read_reg(0x37);
  100.                        
  101.                         if (adc == 0x11)
  102.                         {
  103.                                 write_reg(0x26, 0x48);
  104.                                 write_reg(0x37, 0x5E);
  105.                                 write_reg(0x17, 0x88);
  106.                                 write_reg(0x38, 0x6B);                       
  107.                                 write_reg(0x3A, 0x23);
  108.                                 write_reg(0x29, 0x12);//0x0F); //调制指数
  109.                                 write_reg(0x3b, 0x25);
  110.                         }                       
  111.                         else if (adc == 0x12)
  112.                         {
  113.                                 // 以下寄存器必须按顺序配置
  114.                                 write_reg(0x37, 0x5E);
  115.                                 write_reg(0x26, 0x48);
  116.                                 write_reg(0x17, 0x88);
  117.                                 write_reg(0x29, 0x12);//0x0F); //调制指数       
  118.                                 write_reg(0x35, 0xED);
  119.                                 write_reg(0x3b, 0xA5);
  120.                                 write_reg(0x37, 0xAE);
  121.                                 write_reg(0x3b, 0x72);
  122.                                
  123.                         }
  124.                         write_reg(0x37, backup);
  125.                 }
  126.                        
  127.         }
  128.         else if ('B' == type)
  129.         {
  130.                 write_reg(Status2Reg, 0x00);        //清MFCrypto1On
  131.                 clear_bit_mask(ComIEnReg, BIT7);// 高电平触发中断
  132.     write_reg(ModeReg, 0x3F);        // CRC seed:FFFF
  133.     write_reg(RxSelReg, 0x88);        //RxWait
  134.                 //Tx
  135.                 write_reg(GsNReg, 0xF8);        //调制系数
  136.                 write_reg(CWGsPReg, 0x3F);        //
  137.                 write_reg(ModGsPReg, 0x12);        //调制指数
  138.                 write_reg(AutoTestReg, 0x00);
  139.                 write_reg(TxASKReg, 0x00);        // typeB
  140.                 write_reg(TypeBReg, 0x13);
  141.                 write_reg(TxModeReg, 0x83);        //Tx Framing B
  142.                 write_reg(RxModeReg, 0x83);        //Rx framing B
  143.                 write_reg(BitFramingReg, 0x00);        //TxLastBits=0

  145.                 //兼容配置
  146.                 {
  147.                         u8 backup, adc;
  148.                         backup = read_reg(0x37);
  149.                         write_reg(0x37, 0x00);
  150.                         adc = read_reg(0x37);

  152.                         if (adc == 0x11)
  153.                         {
  154.                                 write_reg(0x37, 0x5E);
  155.                                 write_reg(0x17, 0x88);
  156.                                 write_reg(0x3A, 0x23);               
  157.                                 write_reg(0x38, 0x6B);       
  158.                                 write_reg(0x29, 0x12);//0x0F); //调制指数
  159.                                 write_reg(0x3b, 0x25);
  160.                         }
  161.                         else if (adc == 0x12)
  162.                         {       
  163.                                 write_reg(0x37, 0x5E);
  164.                                 write_reg(0x26, 0x48);
  165.                                 write_reg(0x17, 0x88);
  166.                                 write_reg(0x29, 0x12);
  167.                                 write_reg(0x35, 0xED);
  168.                                 write_reg(0x3b, 0xE5);//改为E5 write_reg(0x3b, 0xA5);
  169.                                 //write_reg(0x37, 0xAE);//去掉
  170.                                 //write_reg(0x3b, 0x72);//去掉
  171.                         }
  172.                         write_reg(0x37, backup);
  173.                 }
  174.         }
  175.         else
  176.         {
  177.                 return USER_ERROR;
  178.         }
  179.        
  180.         pcd_antenna_on();
  181.         mdelay(2);
  182.        
  183.         return MI_OK;
  184. }

  186. /**
  187. ****************************************************************
  188. * @brief pcd_com_transceive()
  189. *
  190. * 通过芯片和ISO14443卡通讯
  191. *
  192. * @param: pi->mf_command = 芯片命令字
  193. * @param: pi->mf_length  = 发送的数据长度
  194. * @param: pi->mf_data[]  = 发送数据
  195. * @return: status 值为MI_OK:成功
  196. * @retval: pi->mf_length  = 接收的数据BIT长度
  197. * @retval: pi->mf_data[]  = 接收数据
  198. ****************************************************************
  199. */
  200. char pcd_com_transceive(struct transceive_buffer *pi)
  201. {
  202.         u8 XDATA recebyte;
  203.         char XDATA status;
  204.         u8 XDATA irq_en;
  205.         u8 XDATA wait_for;
  206.         u8 XDATA last_bits;
  207.         u8 XDATA j;
  208.         u8 XDATA val;
  209.         u8 XDATA err;
  210.        
  211.         u8 irq_inv;
  212.         u16  len_rest;
  213.         u8  len;
  214.         u8 WATER_LEVEL;
  215.        
  216.         len = 0;
  217.         len_rest = 0;
  218.         err = 0;
  219.         recebyte = 0;
  220.         irq_en = 0;
  221.         wait_for = 0;

  223.         switch (pi->mf_command)
  224.         {
  225.           case PCD_IDLE:
  226.              irq_en   = 0x00;
  227.              wait_for = 0x00;
  228.              break;
  229.           case PCD_AUTHENT:   
  230.                 irq_en = IdleIEn | TimerIEn;
  231.                 wait_for = IdleIRq;
  232.                 break;
  233.           case PCD_RECEIVE:
  234.              irq_en   = RxIEn | IdleIEn;
  235.              wait_for = RxIRq;
  236.              recebyte=1;
  237.              break;
  238.           case PCD_TRANSMIT:
  239.              irq_en   = TxIEn | IdleIEn;
  240.              wait_for = TxIRq;
  241.              break;
  242.           case PCD_TRANSCEIVE:   
  243.                  irq_en = RxIEn | IdleIEn | TimerIEn | TxIEn;
  244.              wait_for = RxIRq;
  245.              recebyte=1;
  246.              break;
  247.           default:
  248.              pi->mf_command = MI_UNKNOWN_COMMAND;
  249.              break;
  250.         }

  252.         WATER_LEVEL = read_reg(WaterLevelReg);
  253.           
  254.         if (pi->mf_command != MI_UNKNOWN_COMMAND
  255.                 && (((pi->mf_command == PCD_TRANSCEIVE || pi->mf_command == PCD_TRANSMIT) && pi->mf_length > 0)
  256.                 || (pi->mf_command != PCD_TRANSCEIVE && pi->mf_command != PCD_TRANSMIT))
  257.                 )
  258.         {               
  259.                 write_reg(CommandReg, PCD_IDLE);
  260.                
  261.                 irq_inv = read_reg(ComIEnReg) & BIT7;
  262.                 write_reg(ComIEnReg, irq_inv |irq_en | BIT0);//使能Timer 定时器中断
  263.                 write_reg(ComIrqReg, 0x7F); //Clear INT
  264.                 write_reg(DivIrqReg, 0x7F); //Clear INT
  265.                 //Flush Fifo
  266.                 set_bit_mask(FIFOLevelReg, BIT7);
  267.                 if (pi->mf_command == PCD_TRANSCEIVE || pi->mf_command == PCD_TRANSMIT || pi->mf_command == PCD_AUTHENT)
  268.                 {
  269.                         #if (NFC_DEBUG)
  270.                         printf(" PCD_tx:");
  271.                         #endif
  272.                         for (j = 0; j < pi->mf_length; j++)
  273.                         {
  274.                                
  275.                                 #if (NFC_DEBUG)
  276.                                 printf("%02x ", (u16)pi->mf_data[j]);
  277.                                 #endif
  278.                         }
  279.                         #if (NFC_DEBUG)
  280.                         printf("\n");
  281.                         #endif
  282.                
  283.                         len_rest = pi->mf_length;
  284.                         if (len_rest >= FIFO_SIZE)
  285.                         {
  286.                                 len = FIFO_SIZE;
  287.                         }else
  288.                         {
  289.                                 len = len_rest;
  290.                         }
  291.                        
  292.                         for (j = 0; j < len; j++)
  293.                         {
  294.                                 write_reg(FIFODataReg, pi->mf_data[j]);
  295.                         }
  296.                         len_rest -= len;//Rest bytes
  297.                         if (len_rest != 0)
  298.                         {
  299.                                 write_reg(ComIrqReg, BIT2); // clear LoAlertIRq
  300.                                 set_bit_mask(ComIEnReg, BIT2);// enable LoAlertIRq
  301.                         }

  303.                         write_reg(CommandReg, pi->mf_command);
  304.                         if (pi->mf_command == PCD_TRANSCEIVE)
  305.                     {   
  306.                                 set_bit_mask(BitFramingReg,0x80);  
  307.                         }
  308.                
  309.                         while (len_rest != 0)
  310.                         {
  311.                                 while(INT_PIN == 0);//Wait LoAlertIRq               
  312.                                 if (len_rest > (FIFO_SIZE - WATER_LEVEL))
  313.                                 {
  314.                                         len = FIFO_SIZE - WATER_LEVEL;
  315.                                 }
  316.                                 else
  317.                                 {
  318.                                         len = len_rest;
  319.                                 }
  320.                                 for (j = 0; j < len; j++)
  321.                                 {
  322.                                         write_reg(FIFODataReg, pi->mf_data[pi->mf_length - len_rest + j]);
  323.                                 }

  325.                                 write_reg(ComIrqReg, BIT2);//在write fifo之后，再清除中断标记才可以
  326.                        
  327.                                 //printf("\n8 comirq=%02bx,ien=%02bx,INT= %bd \n", read_reg(ComIrqReg), read_reg(ComIEnReg), (u8)INT_PIN);
  328.                                 len_rest -= len;//Rest bytes
  329.                                 if (len_rest == 0)
  330.                                 {
  331.                                         clear_bit_mask(ComIEnReg, BIT2);// disable LoAlertIRq
  332.                                         //printf("\n9 comirq=%02bx,ien=%02bx,INT= %bd \n", read_reg(ComIrqReg), read_reg(ComIEnReg), (u8)INT_PIN);
  333.                                 }
  334.                         }
  335.                         //Wait TxIRq
  336.                         while (INT_PIN == 0);
  337.                         val = read_reg(ComIrqReg);
  338.                         if (val & TxIRq)
  339.                         {
  340.                                 write_reg(ComIrqReg, TxIRq);
  341.                                 if(pi->mf_command == PCD_TRANSMIT)
  342.                                 {
  343.                                         return 0;
  344.                                 }
  345.                         }
  346.                 }
  347.                 if (PCD_RECEIVE == pi->mf_command)
  348.                 {       
  349.                         set_bit_mask(ControlReg, BIT6);// TStartNow
  350.                 }
  351.        
  352.                 len_rest = 0; // bytes received
  353.                 write_reg(ComIrqReg, BIT3); // clear HoAlertIRq
  354.                 set_bit_mask(ComIEnReg, BIT3); // enable HoAlertIRq
  355.        
  356.                 //等待命令执行完成
  357.                 while(INT_PIN == 0);
  358.                
  359.        
  360.                 while(1)
  361.                 {
  362.                         while(0 == INT_PIN);
  363.                         val = read_reg(ComIrqReg);
  364.                         if ((val & BIT3) && !(val & BIT5))
  365.                         {
  366.                                 if (len_rest + FIFO_SIZE - WATER_LEVEL > 255)
  367.                                 {
  368.                                         #if (NFC_DEBUG)
  369.                                         printf("AF RX_LEN > 255B\n");
  370.                                         #endif
  371.                                         break;
  372.                                 }
  373.                         for (j = 0; j <FIFO_SIZE - WATER_LEVEL; j++)
  374.                         {
  375.                                         pi->mf_data[len_rest + j] = read_reg(FIFODataReg);
  376.                         }
  377.                                 write_reg(ComIrqReg, BIT3);//在read fifo之后，再清除中断标记才可以
  378.                                 len_rest += FIFO_SIZE - WATER_LEVEL;
  379.                         }
  380.                         else
  381.                         {
  382.                                 clear_bit_mask(ComIEnReg, BIT3);//disable HoAlertIRq
  383.                                 break;
  384.                         }                       
  385.                 }


  388.                 val = read_reg(ComIrqReg);
  389.                 #if (NFC_DEBUG)
  390.                 printf(" INT:fflvl=%d,rxlst=%02bx ,ien=%02bx,cirq=%02bx\n", (u16)read_reg(FIFOLevelReg),read_reg(ControlReg)&0x07,read_reg(ComIEnReg), val);//XU
  391.                 #endif
  392.                 write_reg(ComIrqReg, val);// 清中断
  393.                
  394.                 if (val & BIT0)
  395.                 {//发生超时
  396.                         status = MI_NOTAGERR;
  397.                 }
  398.                 else
  399.                 {
  400.                         err = read_reg(ErrorReg);
  401.                        
  402.                         status = MI_COM_ERR;
  403.                         if ((val & wait_for) && (val & irq_en))
  404.                         {
  405.                                 if (!(val & ErrIRq))
  406.                                  {//指令执行正确
  407.                                     status = MI_OK;

  409.                                     if (recebyte)
  410.                                     {
  411.                                                 val = 0x7F & read_reg(FIFOLevelReg);
  412.                                               last_bits = read_reg(ControlReg) & 0x07;
  413.                                                 if (len_rest + val > MAX_TRX_BUF_SIZE)
  414.                                                 {//长度过长超出缓存
  415.                                                         status = MI_COM_ERR;
  416.                                                         #if (NFC_DEBUG)
  417.                                                         printf("RX_LEN > 255B\n");
  418.                                                         #endif
  419.                                                 }
  420.                                                 else
  421.                                                 {       
  422.                                                         if (last_bits && val) //防止spi读错后 val-1成为负值
  423.                                                 {
  424.                                                    pi->mf_length = (val-1)*8 + last_bits;
  425.                                                 }
  426.                                                 else
  427.                                                 {
  428.                                                    pi->mf_length = val*8;
  429.                                                 }
  430.                                                         pi->mf_length += len_rest*8;

  432.                                                         #if (NFC_DEBUG)
  433.                                                         printf(" RX:len=%02x,dat:", (u16)pi->mf_length);
  434.                                                         #endif
  435.                                                 if (val == 0)
  436.                                                 {
  437.                                                    val = 1;
  438.                                                 }
  439.                                                 for (j = 0; j < val; j++)
  440.                                                 {
  441.                                                                 pi->mf_data[len_rest + j] = read_reg(FIFODataReg);
  442.                                                 }                                       

  444.                                                         #if (NFC_DEBUG)
  445.                                                     for (j = 0; j < pi->mf_length/8 + !!(pi->mf_length%8); j++)
  446.                                                 {
  447.                                                         //        if (j > 4)
  448.                                                         //        {
  449.                                                         //                printf("..");
  450.                                                         //                break;
  451.                                                         //        }
  452.                                                         //        else
  453.                                                         //        {
  454.                                                                         printf("%02X ", (u16)pi->mf_data[j]);
  455.                                                         //        }
  456.                                                                 //printf("%02X ", (u16)pi->mf_data[j]);
  457.                                                 }
  458.                                                         //printf("l=%d", pi->mf_length/8 + !!(pi->mf_length%8));
  459.                                                         printf("\n");
  460.                                                         #endif
  461.                                                 }
  462.                                     }
  463.                                  }                                       
  464.                                  else if ((err & CollErr) && (!(read_reg(CollReg) & BIT5)))
  465.                                  {//a bit-collision is detected                                        
  466.                                     status = MI_COLLERR;
  467.                                     if (recebyte)
  468.                                     {
  469.                                                 val = 0x7F & read_reg(FIFOLevelReg);
  470.                                               last_bits = read_reg(ControlReg) & 0x07;
  471.                                                 if (len_rest + val > MAX_TRX_BUF_SIZE)
  472.                                                 {//长度过长超出缓存
  473.                                                         #if (NFC_DEBUG)
  474.                                                         printf("COLL RX_LEN > 255B\n");
  475.                                                         #endif
  476.                                                 }
  477.                                                 else
  478.                                                 {
  479.                                                 if (last_bits && val) //防止spi读错后 val-1成为负值
  480.                                                 {
  481.                                                    pi->mf_length = (val-1)*8 + last_bits;
  482.                                                 }
  483.                                                 else
  484.                                                 {
  485.                                                    pi->mf_length = val*8;
  486.                                                 }               
  487.                                                         pi->mf_length += len_rest*8;
  488.                                                         #if (NFC_DEBUG)
  489.                                                         printf(" RX: pi_cmd=%02x,pi_len=%02x,pi_dat:", (u16)pi->mf_command, (u16)pi->mf_length);
  490.                                                         #endif
  491.                                                 if (val == 0)
  492.                                                 {
  493.                                                    val = 1;
  494.                                                 }
  495.                                                         for (j = 0; j < val; j++)
  496.                                                 {
  497.                                                                 pi->mf_data[len_rest + j +1] = read_reg(FIFODataReg);                               
  498.                                                 }                               
  499.                                                         #if (NFC_DEBUG)
  500.                                                 for (j = 0; j < pi->mf_length/8 + !!(pi->mf_length%8); j++)
  501.                                                 {
  502.                                                                 printf("%02X ", (u16)pi->mf_data[j+1]);
  503.                                                 }
  504.                                                         printf("\n");
  505.                                                         #endif
  506.                                                 }
  507.                                     }
  508.                                         pi->mf_data[0] = (read_reg(CollReg) & CollPos);
  509.                                         if (pi->mf_data[0] == 0)
  510.                                         {
  511.                                                 pi->mf_data[0] = 32;
  512.                                         }
  513.                                 #if(NFC_DEBUG)
  514.                                         printf("\n COLL_DET pos=%02x\n", (u16)pi->mf_data[0]);
  515.                                 #endif
  516.                                         pi->mf_data[0]--;// 与之前版本有点映射区别，为了不改变上层代码，这里直接减一；

  518.                                 }
  519.                                 else if ((err & CollErr) && (read_reg(CollReg) & BIT5))
  520.                                 {
  521.                                         //printf("COLL_DET,but CollPosNotValid=1\n");               
  522.                                 }
  523.                                 //else if (err & (CrcErr | ParityErr | ProtocolErr))
  524.                                 else if (err & (ProtocolErr))
  525.                                 {
  526.                                         #if (NFC_DEBUG)
  527.                                         printf("protocol err=%b02x\n", err);
  528.                                         #endif
  529.                                         status = MI_FRAMINGERR;                               
  530.                                 }
  531.                                 else if ((err & (CrcErr | ParityErr)) && !(err &ProtocolErr) )
  532.                                 {
  533.                                         //EMV  parity err EMV 307.2.3.4               
  534.                                         val = 0x7F & read_reg(FIFOLevelReg);
  535.                                       last_bits = read_reg(ControlReg) & 0x07;
  536.                                         if (len_rest + val > MAX_TRX_BUF_SIZE)
  537.                                         {//长度过长超出缓存
  538.                                                 status = MI_COM_ERR;
  539.                                                 #if (NFC_DEBUG)
  540.                                                 printf("RX_LEN > 255B\n");
  541.                                                 #endif
  542.                                         }
  543.                                         else
  544.                                         {
  545.                                         if (last_bits && val)
  546.                                         {
  547.                                            pi->mf_length = (val-1)*8 + last_bits;
  548.                                         }
  549.                                         else
  550.                                         {
  551.                                            pi->mf_length = val*8;
  552.                                         }
  553.                                                 pi->mf_length += len_rest*8;
  554.                                         }
  555.                                         #if (NFC_DEBUG)
  556.                                         printf("crc-parity err=%b02x\n", err);
  557.                                         printf("l=%d\n", pi->mf_length );
  558.                                         #endif


  561.                                        
  562.                                         status = MI_INTEGRITY_ERR;
  563.                                 }                               
  564.                                 else
  565.                                 {
  566.                                         #if (NFC_DEBUG)
  567.                                         printf("unknown ErrorReg=%02bx\n", err);
  568.                                         #endif
  569.                                         status = MI_INTEGRITY_ERR;
  570.                                 }
  571.                         }
  572.                         else
  573.                         {   
  574.                                 status = MI_COM_ERR;
  575.                                 #if (NFC_DEBUG)
  576.                                 printf(" MI_COM_ERR\n");
  577.                                 #endif
  578.                         }
  579.                 }
  580.        
  581.                 set_bit_mask(ControlReg, BIT7);// TStopNow =1,必要的；
  582.                 write_reg(ComIrqReg, 0x7F);// 清中断0
  583.                 write_reg(DivIrqReg, 0x7F);// 清中断1
  584.                 clear_bit_mask(ComIEnReg, 0x7F);//清中断使能,最高位是控制位
  585.                 clear_bit_mask(DivIEnReg, 0x7F);//清中断使能,最高位是控制位
  586.                 write_reg(CommandReg, PCD_IDLE);

  588.         }
  589.         else
  590.         {
  591.                 status = USER_ERROR;
  592.                 #if (NFC_DEBUG)
  593.                 printf("USER_ERROR\n");
  594.                 #endif
  595.         }
  596.         #if (NFC_DEBUG)
  597.                 printf(" pcd_com: sta=%bd,err=%02bx\n", status, err);
  598.         #endif       
  599.         return status;
  600. }

  602. void pcd_reset()
  603. {       
  604.         #if(NFC_DEBUG)
  605.                 printf("pcd_reset\n");
  606.         #endif
  607.         write_reg(CommandReg, PCD_RESETPHASE); //软复位数字芯片
  608. }

  610. void pcd_antenna_on()
  611. {
  612.         write_reg(TxControlReg, read_reg(TxControlReg) | 0x03); //Tx1RFEn=1 Tx2RFEn=1
  613. }

  615. void pcd_antenna_off()
  616. {
  617.         write_reg(TxControlReg, read_reg(TxControlReg) & (~0x03));
  618. }
  619. /////////////////////////////////////////////////////////////////////
  620. //设置PCD定时器
  621. //input:fwi=0~15
  622. /////////////////////////////////////////////////////////////////////
  623. void pcd_set_tmo(u8 fwi)
  624. {
  625.         write_reg(TPrescalerReg, (TP_FWT_302us) & 0xFF);
  626.         write_reg(TModeReg, BIT7 | (((TP_FWT_302us)>>8) & 0xFF));

  628.         write_reg(TReloadRegL, (1 << fwi)  & 0xFF);
  629.         write_reg(TReloadRegH, ((1 << fwi)  & 0xFF00) >> 8);
  630. }



  634. void pcd_delay_sfgi(u8 sfgi)
  635. {
  636.         //SFGT = (SFGT+dSFGT) = [(256 x 16/fc) x 2^SFGI] + [384/fc x 2^SFGI]
  637.         //dSFGT =  384 x 2^FWI / fc
  638.                 write_reg(TPrescalerReg, (TP_FWT_302us + TP_dFWT) & 0xFF);
  639.                 write_reg(TModeReg, BIT7 | (((TP_FWT_302us + TP_dFWT)>>8) & 0xFF));

  641.                 if (sfgi > 14 || sfgi < 1)
  642.                 {//FDTA,PCD,MIN = 6078 * 1 / fc
  643.                         sfgi = 1;
  644.                 }

  646.                 write_reg(TReloadRegL, (1 << sfgi) & 0xFF);
  647.                 write_reg(TReloadRegH, ((1 << sfgi) >> 8) & 0xFF);

  649.                 write_reg(ComIrqReg, 0x7F);//清除中断
  650.                 write_reg(ComIEnReg, BIT0);
  651.                 clear_bit_mask(TModeReg,BIT7);// clear TAuto
  652.                 set_bit_mask(ControlReg,BIT6);// set TStartNow
  653.                
  654.                 while(!INT_PIN);// wait new INT
  655.                 //set_bit_mask(TModeReg,BIT7);// recover TAuto
  656.                 pcd_set_tmo(g_pcd_module_info.ui_fwi); //recover timeout set
  657.                
  658. }


  661. void pcd_lpcd_config_start(u8 delta, u32 t_inactivity_ms, u8 skip_times, t_detect_us)
  662. {
  663.         u8 XDATA WUPeriod;
  664.         u8 XDATA SwingsCnt;
  665. #if (NFC_DEBUG)
  666.         printf("pcd_lpcd_config_start\n");
  667. #endif
  668.         WUPeriod = t_inactivity_ms * 32.768 / 256  + 0.5;
  669.         SwingsCnt = t_detect_us * 27.12 / 2 / 16 + 0.5;

  671.         write_reg(0x01,0x0F); //先复位寄存器再进行lpcd

  673.         write_reg(0x14, 0x8B);        // Tx2CW = 1 ，continue载波发射打开
  674.         write_reg(0x37, 0x00);//恢复版本号
  675.         write_reg(0x37, 0x5e);        // 打开私有寄存器保护开关
  676.         write_reg(0x3c, 0x30 | delta);        //设置Delta[3:0]的值, 开启32k
  677.         write_reg(0x3d, WUPeriod);        //设置休眠时间       
  678.         write_reg(0x3e, 0x80 | ((skip_times & 0x07) << 4) | (SwingsCnt & 0x0F));        //开启LPCD_en设置,跳过探测次数，探测时间
  679.         write_reg(0x37, 0x00);        // 关闭私有寄存器保护开关
  680.         write_reg(0x03, 0x20);        //打开卡探测中断使能
  681.         write_reg(0x01, 0x10);        //PCD soft powerdown

  683.         //具体应用相关，本示例工程配置为高电平为有中断
  684.         clear_bit_mask(0x02, BIT7);
  685. }

  687. /*
  688.         lpcd功能开始函数
  689. */
  690. void pcd_lpcd_start()
  691. {
  692. #if (NFC_DEBUG)
  693.         printf("pcd_lpcd_start\n");
  694. #endif

  696.         write_reg(0x01,0x0F); //先复位寄存器再进行lpcd
  697.        
  698.         write_reg(0x37, 0x00);//恢复版本号
  699.         if (read_reg(0x37) == 0x10)
  700.         {
  701.                 write_reg(0x01, 0x00);        // idle
  702.         }
  703.         write_reg(0x14, 0x8B);        // Tx2CW = 1 ，continue载波发射打开
  704.        
  705.         write_reg(0x37, 0x5e);        // 打开私有寄存器保护开关

  707.         //write_reg(0x3c, 0x30);        //设置Delta[3:0]的值, 开启32k //0 不能使用
  708.         //write_reg(0x3c, 0x31);        //设置Delta[3:0]的值, 开启32k
  709.         //write_reg(0x3c, 0x32);        //设置Delta[3:0]的值, 开启32k
  710.         //write_reg(0x3c, 0x33);        //设置Delta[3:0]的值, 开启32k
  711.         //write_reg(0x3c, 0x34);        //设置Delta[3:0]的值, 开启32k
  712.         //write_reg(0x3c, 0x35);        //设置Delta[3:0]的值, 开启32k XU
  713.         write_reg(0x3c, 0x37);        //设置Delta[3:0]的值, 开启32k XU
  714.         //write_reg(0x3c, 0x3A);        //设置Delta[3:0]的值, 开启32k XU
  715.         //write_reg(0x3c, 0x3F);        //设置Delta[3:0]的值, 开启32k XU
  716.        
  717.         write_reg(0x3d, 0x0d);        //设置休眠时间       
  718.         write_reg(0x3e, 0x95);        //设置连续探测次数，开启LPCD_en
  719.         write_reg(0x37, 0x00);        // 关闭私有寄存器保护开关
  720.         write_reg(0x03, 0x20);        //打开卡探测中断使能
  721.         write_reg(0x01, 0x10);        //PCD soft powerdown               

  723.         //具体应用相关，配置为高电平为有中断
  724.         clear_bit_mask(0x02, BIT7);
  725.        
  726. }

  728. void pcd_lpcd_end()
  729. {
  730. #if (NFC_DEBUG)
  731.         printf("pcd_lpcd_end\n");
  732. #endif
  733.         write_reg(0x01,0x0F); //先复位寄存器再进行lpcd
  734. }

  736. u8 pcd_lpcd_check()
  737. {
  738.         if (INT_PIN && (read_reg(DivIrqReg) & BIT5)) //TagDetIrq
  739.         {
  740.                 write_reg(DivIrqReg, BIT5); //清除卡检测到中断
  741.                 pcd_lpcd_end();
  742.                 return TRUE;
  743.         }
  744.         return FALSE;
  745. }

  747. #if 0
  748. void page45_lock()
  749. {
  750.         write_reg(VersionReg, 0);
  751. }

  753. //打开芯片的page4私有寄存器的写保护
  754. void page4_unlock()
  755. {
  756.         write_reg(VersionReg, 0x5E);
  757. }
  758. //打开芯片的page5私有寄存器的写保护
  759. void page5_unlock();
  760. {
  761.         write_reg(VersionReg, 0xAE);
  762. }
  763. #endif

  765. void pcd_set_rate(u8 rate)
  766. {
  767.         u8 val,rxwait;
  768.         switch(rate)
  769.         {
  770.                 case '1':
  771.                         clear_bit_mask(TxModeReg, BIT4 | BIT5 | BIT6);
  772.                         clear_bit_mask(RxModeReg, BIT4 | BIT5 | BIT6);
  773.                         write_reg(ModWidthReg, 0x26);//Miller Pulse Length

  775.                         write_reg(RxSelReg, 0x88);
  776.                        
  777.                         break;

  779.                 case '2':
  780.                         clear_bit_mask(TxModeReg, BIT4 | BIT5 | BIT6);
  781.                         set_bit_mask(TxModeReg, BIT4);
  782.                         clear_bit_mask(RxModeReg, BIT4 | BIT5 | BIT6);
  783.                         set_bit_mask(RxModeReg, BIT4);
  784.                         write_reg(ModWidthReg, 0x12);//Miller Pulse Length
  785.                         //rxwait相对于106基本速率需增加相应倍数
  786.                         val = read_reg(RxSelReg);
  787.                         rxwait = ((val & 0x3F)*2);
  788.                         if (rxwait > 0x3F)
  789.                         {
  790.                                 rxwait = 0x3F;
  791.                         }                       
  792.                         write_reg(RxSelReg,(rxwait | (val & 0xC0)));
  793.                        
  794.                         break;

  796.                 case '4':                       
  797.                         clear_bit_mask(TxModeReg, BIT4 | BIT5 | BIT6);
  798.                         set_bit_mask(TxModeReg, BIT5);
  799.                         clear_bit_mask(RxModeReg, BIT4 | BIT5 | BIT6);
  800.                         set_bit_mask(RxModeReg, BIT5);
  801.                         write_reg(ModWidthReg, 0x0A);//Miller Pulse Length
  802.                         //rxwait相对于106基本速率需增加相应倍数
  803.                         val = read_reg(RxSelReg);
  804.                         rxwait = ((val & 0x3F)*4);
  805.                         if (rxwait > 0x3F)
  806.                         {
  807.                                 rxwait = 0x3F;
  808.                         }                       
  809.                         write_reg(RxSelReg,(rxwait | (val & 0xC0)));       

  811.                         break;
  812.                        
  813.                        
  814.                 default:
  815.                         clear_bit_mask(TxModeReg, BIT4 | BIT5 | BIT6);
  816.                         clear_bit_mask(RxModeReg, BIT4 | BIT5 | BIT6);
  817.                         write_reg(ModWidthReg, 0x26);//Miller Pulse Length
  818.                        
  819.                         break;
  820.         }

  822.         {//不同速率选择不同带宽
  823.                 u8 adc;
  824.                 write_reg(0x37, 0x00);
  825.                 adc = read_reg(0x37);

  827.                 if (adc == 0x12)
  828.                 {
  829.                         if (rate == '8' || rate == '4')//848k,424k
  830.                         {
  831.                                 write_reg(0x3B, 0x25);
  832.                         }
  833.                         else if (rate == '2' || rate == '1')// 212k, 106k
  834.                         {
  835.                                 write_reg(0x3B, 0xE5);
  836.                         }
  837.                 }
  838.         }
  839. }

  841. #if 0
  842. void calculate_crc(u8 *pin, u8 len, u8 *pout)
  843. {
  844.         u8 XDATA i, n;

  846.         clear_bit_mask(DivIrqReg, 0x04);
  847.         write_reg(CommandReg, PCD_IDLE);
  848.         set_bit_mask(FIFOLevelReg, 0x80);

  850.         for (i = 0; i < len; i++)
  851.         {
  852.                 write_reg(FIFODataReg, *(pin + i));
  853.         }
  854.         write_reg(CommandReg, PCD_CALCCRC);
  855.         i = 0xFF;
  856.         do
  857.         {
  858.                 n = read_reg(DivIrqReg);
  859.                 i--;
  860.         }while((i!=0) && !(n&0x04));

  862.         #if (NFC_DEBUG)
  863. ……………………

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

所有资料51hei提供下载:
N12_SDK_STC_V1.9.0-MH523.zip (202.2 KB, 下载次数: 30)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:174087 发表于 2019-4-4 09:36 | 显示全部楼层
老哥能不能请教下，523芯片在已经能读A卡的情况下，如何设置才能读B卡，程序是不是只需要修改“配置读卡类型”部分的函数就可以呢？我从有些资料上看读B卡对天线的要求还有挺高的，不知道你这个程序调试的时候有没有针对天线进行设置呢
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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