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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › HT7333供电给RC522 空载时电压为3.2V,加了模块后电压升 ...
返回列表 发新帖
查看: 629|回复: 10
收起左侧

HT7333供电给RC522 空载时电压为3.2V,加了模块后电压升到了4.2V

[复制链接]
ID:1079614 发表于 2024-7-10 19:22 | 显示全部楼层 |阅读模式
HT7333供电给RC522.空载时电压为3.2V，加了模块后电压升到了4.2V，现在读卡也读不到。电路设计是用的我之前可行的电路，程序也是之前可行的直接改的。实在没头绪查问题点。模块换过两个，7333也换了两个，还是这样。

空载

空载

负载

负载

电路

电路

原理图

原理图
回复

使用道具 举报

ID:1079614 发表于 2024-7-10 19:24 | 显示全部楼层
  1. void IC_cl(void)
  2. {
  3.         char status,kk = 0;
  4.         unsigned char snr, buf[16];  


  7.         status= PcdRequest(REQ_ALL,TagType); //寻卡
  8. //        beep();
  9.         if(!status)
  10.         {         //beep();        
  11.                 status = PcdAnticoll(SelectedSnr);        //防冲撞
  12.                 if(!status)
  13.                 {         //beep();
  14.                         status=PcdSelect(SelectedSnr); // 选定卡片
  15.                         if(!status)
  16.                         {  

  18.                                 snr = 2;  //扇区号2
  19.         
  20.                               status = PcdAuthState(KEYA, (snr*4+3), NewKey, SelectedSnr);// 校验1扇区密码，密码位于每一扇区第3块
  21.                                 {        
  22.                                         if(!status)
  23.                                         {

  25.                                                         buf[0] = 0x00;
  26.                                                         status = PcdRead((snr*4+0), buf);  // 读卡，读取1扇区0块数据到buf[0]-buf[16]
  27.                                                         if(buf[0] == 0xF4 || buf[0] == 0xE2)        //进入工作卡
  28.                                                         {
  29.                                                                 if(buf[0] == 0xF4)
  30.                                                                 {
  31.                                                                         IC_Number = buf[1] * 100 + buf[2]; //写入工作卡次数
  32.                                                                         
  33.                                                                 }
  34.                                                                 else  IC_Number = 998;
  35.                                                                 mint = buf[3]; //写入工作卡时间
  36.                                                                 if(IC_Number > 0)
  37.                                                                 {
  38.                                                                         if(buf[0] == 0xF4)
  39.                                                                         {        
  40.                                                                                 IC_Number = IC_Number - 1;
  41.                                                                                 buf[0] = 0xF4; //写入工作卡
  42.                                                                         }
  43.                                                                         else   buf[0] = 0xE2; //写入工作卡
  44.                                                                         buf[1] = IC_Number / 100; //写入工作卡次数
  45.                                                                         buf[2] = IC_Number % 100; //写入工作卡次数
  46.                                                                         buf[3] = mint; //写入工作卡时间
  47.                                                                         status = PcdWrite((snr*4+0), buf);  // 写卡，将buf[0]-buf[16]写入1扇区0块
  48.                                                                         beep_flag = 1;

  50.                         
  51.                                                                 }
  52.         
  53.                                                                 beep();         
  54.         

  56.                                                                 WaitCardOff();        //等待卡离开
  57.                                                         }
  58.                                                 }
  59.                                         }
  60.                                 }
  61.                         }
  62.                
  63.         }
  64.         

  66. }


  69. #include <intrins.h>
  70. //#include "reg52.h"
  71. #include "STC8.h"
  72. //#include "main.h"
  73. #include "mfrc522.h"
  74. #include <string.h>
  75. #define MAXRLEN 18      

  77. //////////////////////////////////
  78. //端口定义
  79. /////////////////////////////////////////////////////////////////////
  80. //MFRC522
  81. sbit     MF522_RST  =    P3^7;//P5^4;//                  //RC500片选
  82. sbit     MF522_NSS  =    P2^1;//P3^3;//
  83. sbit     MF522_SCK  =    P2^2;//P1^5;//
  84. sbit     MF522_MOSI =    P2^3;//P1^6;//
  85. sbit         MF522_MISO =    P2^0;//P1^7;//  单片机做输入脚
  86. /*********************************************************/                  
  87. /////////////////////////////////////////////////////////////////////
  88. //功    能：寻卡
  89. //参数说明: req_code[IN]:寻卡方式
  90. //                0x52 = 寻感应区内所有符合14443A标准的卡
  91. //                0x26 = 寻未进入休眠状态的卡
  92. //          pTagType[OUT]：卡片类型代码
  93. //                0x4400 = Mifare_UltraLight
  94. //                0x0400 = Mifare_One(S50)
  95. //                0x0200 = Mifare_One(S70)
  96. //                0x0800 = Mifare_Pro(X)
  97. //                0x4403 = Mifare_DESFire
  98. //返    回: 成功返回MI_OK
  99. /////////////////////////////////////////////////////////////////////
  100. char PcdRequest(unsigned char req_code,unsigned char *pTagType)
  101. {
  102.    char status;  
  103.    unsigned int  unLen;
  104.    unsigned char ucComMF522Buf[MAXRLEN];
  105. //  unsigned char xTest ;
  106.    ClearBitMask(Status2Reg,0x08);//寄存器包含接收器和发送器和数据模式检测器的状态标志
  107.    WriteRawRC(BitFramingReg,0x07);//不启动数据发送


  110.    SetBitMask(TxControlReg,0x03);//TX1、TX2输出信号将传递经发送数据调制的13.56MHz的能量载波信号。

  112.    ucComMF522Buf[0] = req_code;

  114.    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
  115.    //通过522发送req_code命令，并接收返回数据，存到ucComMF522Buf中
  116. //     if(status  == MI_OK )
  117. //   { LED_GREEN  =0 ;}
  118. //   else {LED_GREEN =1 ;}
  119.    if ((status == MI_OK) && (unLen == 0x10)) //这个为啥是0x10，因为是2个字节共16bit
  120.    {   
  121.        *pTagType     = ucComMF522Buf[0];
  122.        *(pTagType+1) = ucComMF522Buf[1]; //获取卡类型
  123.    }
  124.    else
  125.    {   status = MI_ERR;   }
  126.    
  127.    return status;
  128. }
  129. /****************************************************************/
  130. /////////////////////////////////////////////////////////////////////
  131. //功    能：防冲撞
  132. //参数说明: pSnr[OUT]:卡片序列号，4字节
  133. //返    回: 成功返回MI_OK
  134. /////////////////////////////////////////////////////////////////////  
  135. char PcdAnticoll(unsigned char *pSnr)
  136. {
  137.     char status;
  138.     unsigned char i,snr_check=0;
  139.     unsigned int  unLen;
  140.     unsigned char ucComMF522Buf[MAXRLEN];
  141.    

  143.     ClearBitMask(Status2Reg,0x08);//寄存器包含接收器和发送器和数据模式检测器的状态标志
  144.     WriteRawRC(BitFramingReg,0x00);//不启动数据发送，接收的LSB位存放在位0，接收到的第二位放在位1，定义发送的最后一个字节的位数为8
  145.     ClearBitMask(CollReg,0x80);//所有接收的位在冲突后将被清除。

  147.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  148.     ucComMF522Buf[1] = 0x20;

  150.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);

  152.     if (status == MI_OK)
  153.     {
  154.              for (i=0; i<4; i++)
  155.          {   
  156.              *(pSnr+i)  = ucComMF522Buf[i];
  157.              snr_check ^= ucComMF522Buf[i];
  158.          }
  159.          if (snr_check != ucComMF522Buf[i])//返回四个字节，最后一个字节为校验位
  160.          {   status = MI_ERR;    }
  161.     }
  162.    
  163.     SetBitMask(CollReg,0x80);
  164.     return status;
  165. }
  166. /***********************************************************/
  167. /////////////////////////////////////////////////////////////////////
  168. //功    能：选定卡片
  169. //参数说明: pSnr[IN]:卡片序列号，4字节
  170. //返    回: 成功返回MI_OK
  171. /////////////////////////////////////////////////////////////////////
  172. char PcdSelect(unsigned char *pSnr)
  173. {
  174.     char status;
  175.     unsigned char i;
  176.     unsigned int  unLen;
  177.     unsigned char ucComMF522Buf[MAXRLEN];
  178.    
  179.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  180.     ucComMF522Buf[1] = 0x70;
  181.     ucComMF522Buf[6] = 0;
  182.     for (i=0; i<4; i++)
  183.     {
  184.             ucComMF522Buf[i+2] = *(pSnr+i);
  185.             ucComMF522Buf[6]  ^= *(pSnr+i);
  186.     }
  187.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);//计算CRC装填至ucComMF522Buf[7]
  188.   
  189.     ClearBitMask(Status2Reg,0x08);//寄存器包含接收器和发送器和数据模式检测器的状态标志

  191.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
  192.    
  193.     if ((status == MI_OK) && (unLen == 0x18))//成功，返回SAK，包括1字节的SAK和2字节的CRC_A
  194.     {   status = MI_OK;  }
  195.     else
  196.     {   status = MI_ERR;    }

  198.     return status;
  199. }
  200. /**************************************************************/
  201. /////////////////////////////////////////////////////////////////////
  202. //功    能：验证卡片密码
  203. //参数说明: auth_mode[IN]: 密码验证模式
  204. //                 0x60 = 验证A密钥
  205. //                 0x61 = 验证B密钥
  206. //          addr[IN]：块地址
  207. //          pKey[IN]：密码
  208. //          pSnr[IN]：卡片序列号，4字节
  209. //返    回: 成功返回MI_OK
  210. /////////////////////////////////////////////////////////////////////               
  211. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
  212. {
  213.     char status;
  214.     unsigned int  unLen;
  215.     unsigned char i,ucComMF522Buf[MAXRLEN];

  217.     ucComMF522Buf[0] = auth_mode;
  218.     ucComMF522Buf[1] = addr;
  219.     for (i=0; i<6; i++)
  220.     {    ucComMF522Buf[i+2] = *(pKey+i);   }
  221.     for (i=0; i<6; i++)
  222.     {    ucComMF522Buf[i+8] = *(pSnr+i);   }
  223. //   memcpy(&ucComMF522Buf[2], pKey, 6);
  224. //   memcpy(&ucComMF522Buf[8], pSnr, 4);
  225.    
  226.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
  227.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
  228.     {   status = MI_ERR;   }
  229.    
  230.     return status;
  231. }
  232. /****************************************************************/
  233. /////////////////////////////////////////////////////////////////////
  234. //功    能：读取M1卡一块数据
  235. //参数说明: addr[IN]：块地址
  236. //          pData[OUT]：读出的数据，16字节
  237. //返    回: 成功返回MI_OK
  238. /////////////////////////////////////////////////////////////////////
  239. char PcdRead(unsigned char addr,unsigned char *pData)
  240. {
  241.     char status;
  242.     unsigned int  unLen;
  243.     unsigned char i,ucComMF522Buf[MAXRLEN];

  245.     ucComMF522Buf[0] = PICC_READ;
  246.     ucComMF522Buf[1] = addr;
  247.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  248.    
  249.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
  250.     if ((status == MI_OK) && (unLen == 0x90))
  251. //   {   memcpy(pData, ucComMF522Buf, 16);   }
  252.     {
  253.         for (i=0; i<16; i++)
  254.         {    *(pData+i) = ucComMF522Buf[i];  _nop_();}
  255.     }
  256.     else
  257.     {   status = MI_ERR;   _nop_();}
  258.    
  259.     return status;
  260. }
  261. /********************************************************************/
  262. /////////////////////////////////////////////////////////////////////
  263. //功    能：写数据到M1卡一块
  264. //参数说明: addr[IN]：块地址
  265. //          pData[IN]：写入的数据，16字节
  266. //返    回: 成功返回MI_OK
  267. /////////////////////////////////////////////////////////////////////                  
  268. char PcdWrite(unsigned char addr,unsigned char *pData)
  269. {
  270.     char status;
  271.     unsigned int  unLen;
  272.     unsigned char i,ucComMF522Buf[MAXRLEN];
  273.    
  274.     ucComMF522Buf[0] = PICC_WRITE;                                          //写块
  275.     ucComMF522Buf[1] = addr;                                                  //写地址
  276.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);           

  278.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  280.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  281.     {   status = MI_ERR;   _nop_();}
  282.         
  283.     if (status == MI_OK)
  284.     {
  285.         //memcpy(ucComMF522Buf, pData, 16);
  286.         for (i=0; i<16; i++)
  287.         {    ucComMF522Buf[i] = *(pData+i);   _nop_();}
  288.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);

  290.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
  291.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  292.         {   status = MI_ERR;  _nop_(); }
  293.     }
  294.    
  295.     return status;
  296. }
  297. /*******************************************************************
  298. /////////////////////////////////////////////////////////////////////
  299. //写数据到卡上的一块
  300. //input:adde=要写的绝对块号
  301. //      writedata=写入数据
  302. /////////////////////////////////////////////////////////////////////
  303. //char PcdWrite(unsigned char addr,unsigned char *pWritedata)
  304. char PcdWrite(unsigned char addr,unsigned char *pData)
  305. {
  306.     char status;
  307.     struct TranSciveBuffer MfComData;
  308.     struct TranSciveBuffer *pi;
  309.     pi = &MfComData;
  310.    
  311.     PcdSetTmo(5);
  312.     WriteRawRC(RegChannelRedundancy,0x07);
  313.     MfComData.MfCommand = PCD_TRANSCEIVE;
  314.     MfComData.MfLength  = 2;
  315.     MfComData.MfData[0] = PICC_WRITE;
  316.     MfComData.MfData[1] = addr;

  318.     status = PcdComTransceive(pi);
  319.     if (status != MI_NOTAGERR)
  320.     {
  321.         if(MfComData.MfLength != 4)
  322.         {   status=MI_BITCOUNTERR;   }
  323.         else
  324.         {
  325.            MfComData.MfData[0] &= 0x0F;
  326.            switch (MfComData.MfData[0])
  327.            {
  328.               case 0x00:
  329.                  status = MI_NOTAUTHERR;
  330.                  break;
  331.               case 0x0A:
  332.                  status = MI_OK;
  333.                  break;
  334.               default:
  335.                  status = MI_CODEERR;
  336.                  break;
  337.            }
  338.         }
  339.     }
  340.     if (status == MI_OK)
  341.     {
  342.         PcdSetTmo(5);
  343.         MfComData.MfCommand = PCD_TRANSCEIVE;
  344.         MfComData.MfLength  = 16;
  345.         memcpy(&MfComData.MfData[0], pData,16);//pWritedata, 16);
  346.         
  347.         status = PcdComTransceive(pi);
  348.         if (status != MI_NOTAGERR)
  349.         {
  350.             MfComData.MfData[0] &= 0x0F;
  351.             switch(MfComData.MfData[0])
  352.             {
  353.                case 0x00:
  354.                   status = MI_WRITEERR;
  355.                   break;
  356.                case 0x0A:
  357.                   status = MI_OK;
  358.                   break;
  359.                default:
  360.                   status = MI_CODEERR;
  361.                   break;
  362.            }
  363.         }
  364.         PcdSetTmo(4);
  365.     }
  366.     return status;
  367. }
  368. /**********************************************/
  369. /////////////////////////////////////////////////////////////////////
  370. //功    能：命令卡片进入休眠状态
  371. //返    回: 成功返回MI_OK
  372. /////////////////////////////////////////////////////////////////////
  373. char PcdHalt(void)
  374. {
  375.     char status;
  376.     unsigned int  unLen;
  377.     unsigned char ucComMF522Buf[MAXRLEN];

  379.     ucComMF522Buf[0] = PICC_HALT;
  380.     ucComMF522Buf[1] = 0;
  381.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  383.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  385.     return MI_OK;
  386. }
  387. /****************************************************************/
  388. /////////////////////////////////////////////////////////////////////
  389. //用MF522计算CRC16函数
  390. /////////////////////////////////////////////////////////////////////
  391. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
  392. {
  393.     unsigned char i,n;
  394.     ClearBitMask(DivIrqReg,0x04);
  395.     WriteRawRC(CommandReg,PCD_IDLE);
  396.     SetBitMask(FIFOLevelReg,0x80);
  397.     for (i=0; i<len; i++)
  398.     {   WriteRawRC(FIFODataReg, *(pIndata+i));   }
  399.     WriteRawRC(CommandReg, PCD_CALCCRC);
  400.     i = 0xFF;
  401.     do
  402.     {
  403.         n = ReadRawRC(DivIrqReg);
  404.         i--;
  405.     }
  406.     while ((i!=0) && !(n&0x04));
  407.     pOutData[0] = ReadRawRC(CRCResultRegL);
  408.     pOutData[1] = ReadRawRC(CRCResultRegM);
  409. }
  410. /****************************************************************/
  411. /////////////////////////////////////////////////////////////////////
  412. //功    能：复位RC522
  413. //返    回: 成功返回MI_OK
  414. /////////////////////////////////////////////////////////////////////
  415. char PcdReset(void)
  416. {
  417.     MF522_RST=1;
  418.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();  nop_();_nop_();_nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();
  419.     MF522_RST=0;
  420.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();  nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();
  421.     MF522_RST=1;
  422.      _nop_();_nop_();_nop_(); _nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();          nop_();_nop_();_nop_();_nop_();_nop_();  _nop_();_nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();
  423.     WriteRawRC(CommandReg,PCD_RESETPHASE);
  424.     _nop_();_nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();
  425.    
  426.     WriteRawRC(ModeReg,0x3D);            //和Mifare卡通讯，CRC初始值0x6363
  427.     WriteRawRC(TReloadRegL,30);           
  428.     WriteRawRC(TReloadRegH,0);
  429.     WriteRawRC(TModeReg,0x8D);
  430.     WriteRawRC(TPrescalerReg,0x3E);
  431.     WriteRawRC(TxAutoReg,0x40);     
  432.     return MI_OK;
  433. }
  434. /****************************************************************/
  435. //////////////////////////////////////////////////////////////////////
  436. //设置RC632的工作方式
  437. //////////////////////////////////////////////////////////////////////
  438. char M500PcdConfigISOType(unsigned char type)
  439. {
  440.    if (type == 'A')                     //ISO14443_A
  441.    {
  442.        ClearBitMask(Status2Reg,0x08);


  445.        WriteRawRC(ModeReg,0x3D);//3F

  447.        WriteRawRC(RxSelReg,0x86);//84
  448. //      WriteRawRC(RxThresholdReg,0x84);//as default
  449. //      WriteRawRC(DemodReg,0x4D);      //as default

  451. //      WriteRawRC(ModWidthReg,0x13);//26
  452.        WriteRawRC(RFCfgReg,0x7F);   //4F

  454.               WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
  455.            WriteRawRC(TReloadRegH,0);
  456.        WriteRawRC(TModeReg,0x8D);
  457.            WriteRawRC(TPrescalerReg,0x3E);
  458.            

  460.   //     PcdSetTmo(106);
  461.                             delay_10ms(2);
  462.        PcdAntennaOn();
  463.    }
  464.    else{ return -1; }
  465.    
  466.    return MI_OK;
  467. }
  468. /****************************************************************/
  469. /////////////////////////////////////////////////////////////////////
  470. //功    能：读RC632寄存器
  471. //参数说明：Address[IN]:寄存器地址
  472. //返    回：读出的值
  473. /////////////////////////////////////////////////////////////////////
  474. unsigned char ReadRawRC(unsigned char Address)
  475. {
  476.      unsigned char i, ucAddr;
  477.      unsigned char ucResult=0;

  479.      MF522_SCK = 0;
  480.      MF522_NSS = 0;
  481.      ucAddr = ((Address<<1)&0x7E)|0x80;

  483.      for(i=8;i>0;i--)
  484.      {
  485.          MF522_SCK = 0;
  486.                   if(ucAddr&0x80)
  487.                  {
  488.                  MF522_MOSI = 1;         _nop_();_nop_();_nop_();_nop_();
  489.                 }
  490.                  else
  491.                  {
  492.                          MF522_MOSI = 0;         _nop_();_nop_();_nop_();_nop_();
  493.                 }
  494.          MF522_SCK = 1;          _nop_();_nop_();_nop_();_nop_();
  495.          ucAddr <<= 1;          _nop_();_nop_();_nop_();_nop_();
  496.      }

  498.      for(i=8;i>0;i--)
  499.      {
  500.          MF522_SCK = 0;
  501.          ucResult <<= 1;_nop_();_nop_();_nop_();_nop_();
  502.          MF522_SCK = 1;
  503.                  if(MF522_MISO == 1)
  504.                  ucResult |= 1;
  505.                 _nop_();_nop_();_nop_();_nop_();
  506.      }

  508.      MF522_NSS = 1;
  509.      MF522_SCK = 1;
  510.      return ucResult;
  511. }
  512. /****************************************************************/
  513. /////////////////////////////////////////////////////////////////////
  514. //功    能：写RC632寄存器
  515. //参数说明：Address[IN]:寄存器地址
  516. //          value[IN]:写入的值
  517. /////////////////////////////////////////////////////////////////////
  518. void WriteRawRC(unsigned char Address, unsigned char value)
  519. {  
  520.     unsigned char i, ucAddr;

  522.     MF522_SCK = 0;
  523.     MF522_NSS = 0;
  524.     ucAddr = ((Address<<1)&0x7E);

  526.     for(i=8;i>0;i--)
  527.     {
  528.                 if(ucAddr&0x80)
  529.                 MF522_MOSI = 1;
  530.                 else
  531.                         MF522_MOSI = 0;
  532.                 _nop_();_nop_();_nop_();_nop_(); _nop_();_nop_();_nop_();_nop_();
  533.         MF522_SCK = 1; _nop_();_nop_();_nop_();_nop_();        _nop_();_nop_();_nop_();_nop_();
  534.         ucAddr <<= 1;
  535.         MF522_SCK = 0;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  536.     }

  538.     for(i=8;i>0;i--)
  539.     {
  540.                 if(value&0x80)
  541.                 MF522_MOSI = 1;
  542.                 else
  543.                         MF522_MOSI = 0;
  544.                 _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  545.         MF522_SCK = 1; _nop_();_nop_();_nop_();_nop_();        _nop_();_nop_();_nop_();_nop_();
  546.         value <<= 1;
  547.         MF522_SCK = 0; _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  548.     }
  549.     MF522_NSS = 1;
  550.     MF522_SCK = 1;
  551. }
  552. /****************************************************************/
  553. /////////////////////////////////////////////////////////////////////
  554. //功    能：置RC522寄存器位
  555. //参数说明：reg[IN]:寄存器地址
  556. //          mask[IN]:置位值
  557. /////////////////////////////////////////////////////////////////////
  558. void SetBitMask(unsigned char reg,unsigned char mask)  
  559. {
  560.     char tmp = 0x0;
  561.     tmp = ReadRawRC(reg);
  562.     WriteRawRC(reg,tmp | mask);  // set bit mask
  563. }
  564. /****************************************************************/
  565. /////////////////////////////////////////////////////////////////////
  566. //功    能：清RC522寄存器位
  567. //参数说明：reg[IN]:寄存器地址
  568. //          mask[IN]:清位值
  569. /////////////////////////////////////////////////////////////////////
  570. void ClearBitMask(unsigned char reg,unsigned char mask)  
  571. {
  572.     char tmp = 0x0;
  573.     tmp = ReadRawRC(reg);
  574.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
  575. }
  576. /****************************************************************/
  577. /////////////////////////////////////////////////////////////////////
  578. //功    能：通过RC522和ISO14443卡通讯
  579. //参数说明：Command[IN]:RC522命令字
  580. //          pInData[IN]:通过RC522发送到卡片的数据
  581. //          InLenByte[IN]:发送数据的字节长度
  582. //          pOutData[OUT]:接收到的卡片返回数据
  583. //          *pOutLenBit[OUT]:返回数据的位长度
  584. /////////////////////////////////////////////////////////////////////
  585. char PcdComMF522(unsigned char Command,
  586.                  unsigned char *pInData,
  587.                  unsigned char InLenByte,
  588.                  unsigned char *pOutData,
  589.                  unsigned int  *pOutLenBit)
  590. {
  591.     char status = MI_ERR;
  592.     unsigned char irqEn   = 0x00;
  593.     unsigned char waitFor = 0x00;
  594.     unsigned char lastBits;
  595.     unsigned char n;
  596.     unsigned int i;
  597.     switch (Command)                                          
  598.     {
  599.        case PCD_AUTHENT:
  600.           irqEn   = 0x12;
  601.           waitFor = 0x10;
  602.           break;
  603.        case PCD_TRANSCEIVE:
  604.           irqEn   = 0x77;
  605.           waitFor = 0x30;
  606.           break;
  607.        default:
  608.          break;
  609.     }
  610.    
  611.     WriteRawRC(ComIEnReg,irqEn|0x80);
  612.     ClearBitMask(ComIrqReg,0x80);
  613.     WriteRawRC(CommandReg,PCD_IDLE);
  614.     SetBitMask(FIFOLevelReg,0x80);
  615.    
  616.     for (i=0; i<InLenByte; i++)
  617.     {   WriteRawRC(FIFODataReg, pInData[i]);    }
  618.     WriteRawRC(CommandReg, Command);
  619.    
  620.    
  621.     if (Command == PCD_TRANSCEIVE)
  622.     {    SetBitMask(BitFramingReg,0x80);  }
  623.    
  624. //    i = 600;//根据时钟频率调整，操作M1卡最大等待时间25ms
  625. i = 2000;
  626.     do
  627.     {
  628.          n = ReadRawRC(ComIrqReg);
  629.          i--;
  630.     }
  631.     while ((i!=0) && !(n&0x01) && !(n&waitFor));
  632.     ClearBitMask(BitFramingReg,0x80);
  633.               
  634.     if (i!=0)
  635.     {   
  636.          if(!(ReadRawRC(ErrorReg)&0x1B))
  637.          {
  638.              status = MI_OK;
  639.              if (n & irqEn & 0x01)
  640.              {   status = MI_NOTAGERR;   }
  641.              if (Command == PCD_TRANSCEIVE)
  642.              {
  643.                        n = ReadRawRC(FIFOLevelReg);
  644.                       lastBits = ReadRawRC(ControlReg) & 0x07;
  645.                 if (lastBits)
  646.                 {   *pOutLenBit = (n-1)*8 + lastBits;   }
  647.                 else
  648.                 {   *pOutLenBit = n*8;   }
  649.                 if (n == 0)
  650.                 {   n = 1;    }
  651.                 if (n > MAXRLEN)
  652.                 {   n = MAXRLEN;   }
  653.                 for (i=0; i<n; i++)
  654.                 {   pOutData[i] = ReadRawRC(FIFODataReg);    }
  655.             }
  656.          }
  657.          else
  658.          {   status = MI_ERR;   }
  659.         
  660.    }
  661.    

  663.    SetBitMask(ControlReg,0x80);           // stop timer now
  664.    WriteRawRC(CommandReg,PCD_IDLE);
  665.    return status;
  666. }

  668. /****************************************************************/
  669. /////////////////////////////////////////////////////////////////////
  670. //开启天线  
  671. //每次启动或关闭天险发射之间应至少有1ms的间隔
  672. /////////////////////////////////////////////////////////////////////
  673. void PcdAntennaOn()
  674. {
  675.     unsigned char i;
  676.     i = ReadRawRC(TxControlReg);
  677.     if (!(i & 0x03))
  678.     {
  679.         SetBitMask(TxControlReg, 0x03);
  680.     }
  681. }

  683. /****************************************************************/
  684. /////////////////////////////////////////////////////////////////////
  685. //关闭天线
  686. /////////////////////////////////////////////////////////////////////
  687. void PcdAntennaOff()
  688. {
  689.     ClearBitMask(TxControlReg, 0x03);
  690. }
  691. //------------------------------------------------------------------
  692. //等待卡离开
  693. void WaitCardOff(void)
  694. {
  695.         char status, TagType[2];

  697.         while(1)
  698.         {
  699.                 status = PcdRequest(REQ_ALL, TagType);
  700.                 if(status)
  701.                 {
  702.                         status = PcdRequest(REQ_ALL, TagType);
  703.                         if(status)
  704.                         {
  705.                                 status = PcdRequest(REQ_ALL, TagType);
  706.                                 if(status)
  707.                                 {
  708.                                         return;
  709.                                 }
  710.                         }
  711.                 }
  712.                 delay_10ms(1);
  713.         }
  714. }
  715. /****************************************************************/
  716. /////////////////////////////////////////////////////////////////////
  717. //功    能：扣和充
  718. //参数说明: dd_mode[IN]：命令字
  719. //               0xC0 = 扣
  720. //               0xC1 = 充
  721. //          addr[IN]：包地址
  722. //          pValue[IN]：4字节增(减)值，低位在前
  723. //返    回: 成功返回MI_OK
  724. /////////////////////////////////////////////////////////////////////                 
  725. char PcdValue(unsigned char dd_mode,unsigned char addr,unsigned char *pValue)
  726. {
  727.     char status;
  728.     unsigned int  unLen;
  729.     unsigned char ucComMF522Buf[MAXRLEN];
  730.    
  731.     ucComMF522Buf[0] = dd_mode;
  732.     ucComMF522Buf[1] = addr;
  733.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  735.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  737.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  738.     {   status = MI_ERR;   }
  739.         
  740.     if (status == MI_OK)
  741.     {
  742.         memcpy(ucComMF522Buf, pValue, 4);
  743. //       for (i=0; i<16; i++)
  744. //       {    ucComMF522Buf[i] = *(pValue+i);   }
  745.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
  746.         unLen = 0;
  747.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
  748.         if (status != MI_ERR)
  749.         {    status = MI_OK;    }
  750.     }
  751.    
  752.     if (status == MI_OK)
  753.     {
  754.         ucComMF522Buf[0] = PICC_TRANSFER;
  755.         ucComMF522Buf[1] = addr;
  756.         CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  757.    
  758.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  760.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  761.         {   status = MI_ERR;   }
  762.     }
  763.     return status;
  764. }
  765. /****************************************************************/
  766. /////////////////////////////////////////////////////////////////////
  767. //功    能：备份包
  768. //参数说明: sourceaddr[IN]：源地址
  769. //          goaladdr[IN]：目标地址
  770. //返    回: 成功返回MI_OK
  771. /////////////////////////////////////////////////////////////////////
  772. char PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr)
  773. {
  774.     char status;
  775.     unsigned int  unLen;
  776.     unsigned char ucComMF522Buf[MAXRLEN];

  778.     ucComMF522Buf[0] = PICC_RESTORE;
  779.     ucComMF522Buf[1] = sourceaddr;
  780.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  782.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  784.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  785.     {   status = MI_ERR;   }
  786.    
  787.     if (status == MI_OK)
  788.     {
  789.         ucComMF522Buf[0] = 0;
  790.         ucComMF522Buf[1] = 0;
  791.         ucComMF522Buf[2] = 0;
  792.         ucComMF522Buf[3] = 0;
  793.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);

  795.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
  796.         if (status != MI_ERR)
  797.         {    status = MI_OK;    }
  798.     }
  799.    
  800.     if (status != MI_OK)
  801.     {    return MI_ERR;   }
  802.    
  803.     ucComMF522Buf[0] = PICC_TRANSFER;
  804.     ucComMF522Buf[1] = goaladdr;

  806.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  808.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  810.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  811.     {   status = MI_ERR;   }

  813.     return status;
  814. }
  815. /********************************************************/

  817. /********************************************************/
  818. void delay_50us(unsigned char k)                //@22.1184MHz
  819. {
  820.         unsigned char i, j;

  822.         _nop_();
  823.         _nop_();
  824.         i = 2;
  825.         j = 15;
  826.         do
  827.         {
  828.                 do
  829.                 {
  830.                         while (--j);
  831.                 } while (--i);
  832.         }while (--k);
  833. }
  834. /********************************************************/
  835. ///////////////////////////////////////////////////////////////////////
  836. // Delay 10ms
  837. ///////////////////////////////////////////////////////////////////////
  838. void delay_10ms(unsigned int _10ms)
  839. {
  840. #ifndef NO_TIMER2

  842.         unsigned char i, j, k;

  844.         _nop_();
  845.         _nop_();
  846.         i = 1;
  847.         j = 216;
  848.         k = 35;
  849.         do
  850.         {
  851.                 do
  852.                 {
  853.                         do
  854.                         {
  855.                                 while (--k);
  856.                         } while (--j);
  857.                 } while (--i);
  858.         }while (--_10ms);

  860. #else
  861.     while (_10ms--)
  862.     {
  863.             delay_50us(19);
  864.             if (CmdValid)
  865.                 return;
  866.             delay_50us(20);
  867.             if (CmdValid)
  868.                 return;
  869.             delay_50us(20);
  870.             if (CmdValid)
  871.                 return;
  872.             delay_50us(20);
  873.             if (CmdValid)
  874.                 return;
  875.             delay_50us(20);
  876.             if (CmdValid )
  877.                 return;
  878.             delay_50us(20);
  879.             if (CmdValid)
  880.                 return;
  881.             delay_50us(20);
  882.             if (CmdValid)
  883.                 return;
  884.             delay_50us(20);
  885.             if (CmdValid)
  886.                 return;
  887.             delay_50us(20);
  888.             if (CmdValid)
  889.                 return;
  890.             delay_50us(19);
  891.             if (CmdValid)
  892.                 return;
  893.     }
  894. #endif
  895. }
  896. /********************************************************/
复制代码
回复

使用道具 举报

ID:1034262 发表于 2024-7-10 21:59 | 显示全部楼层
HT7xxx系列的LDO十几年来都不敢再用，当年，2006年，用的HT7533,12V一接上，先冲到10V再回到3.3V，烧单片机。
回复

使用道具 举报

ID:401564 发表于 2024-7-10 23:33 | 显示全部楼层
蜂鸣器如果没有加二极管,我认为问题就出在蜂鸣器上
回复

使用道具 举报

ID:466250 发表于 2024-7-11 00:07 | 显示全部楼层
coody_sz 发表于 2024-7-10 21:59
HT7xxx系列的LDO十几年来都不敢再用，当年，2006年，用的HT7533,12V一接上，先冲到10V再回到3.3V，烧单片机 ...

我这里有没有过冲的75与73系列，而且也才0.1x
回复

使用道具 举报

ID:466250 发表于 2024-7-11 00:11 | 显示全部楼层
升到4.2的原因是模块的电流不稳定，使用的73系列在供电时动态响应不够快，就会出现上下冲的问题。
解决方法：
第一种是在3.3V输出端并100uf或以上的电解电容作为动态不足的缓冲
第二种换动态响应足够快的73系列，可提供，可私信。
回复

使用道具 举报

ID:344848 发表于 2024-7-11 02:11 | 显示全部楼层
蓝蓝小星星 发表于 2024-7-11 00:11
升到4.2的原因是模块的电流不稳定，使用的73系列在供电时动态响应不够快，就会出现上下冲的问题。
解决方 ...

明显要销售产品了，
回复

使用道具 举报

ID:466250 发表于 2024-7-11 10:05 | 显示全部楼层
donglw 发表于 2024-7-11 02:11
明显要销售产品了，

能解决问题才是关键
回复

使用道具 举报

ID:879348 发表于 2024-7-11 10:59 | 显示全部楼层
LDO在差的动态响应应该也不会这么离谱，好好检查一下实物高压是从哪里来的
回复

使用道具 举报

ID:1123773 发表于 2024-7-11 13:52 | 显示全部楼层
看俩个测试图，感觉你这也不是测的一个点呢，第二个表显示的时负4.2V时，红表笔测的是排线3脚，这脚是地，你的黑表笔没接第一图的电容上啊，你黑表笔接哪里了？
回复

使用道具 举报

ID:1079614 发表于 2024-7-11 15:28 | 显示全部楼层
土豆我是地瓜 发表于 2024-7-11 13:52
看俩个测试图，感觉你这也不是测的一个点呢，第二个表显示的时负4.2V时，红表笔测的是排线3脚，这脚是地， ...

都接地
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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