devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

RFID射频卡与存储模块AT24X_mf522寄存器定义

作者：不正经 | 2024-03-07 13:18:34

赞

踩

mf522寄存器定义

RC522（RFID模块）实践总结

此次使用RC522模块和S50卡实现近场通讯功能（开发板与RC522通讯方式为硬件SPI），就实践过程中的一些知识点进行总结：

  • RC522模块和M1卡要点介绍；

  • 驱动代码；

  • 出现问题及解决方法；

RFID 射频卡工作原理

S50 卡内置了几组线圈，读写器向卡发一组固定频率的电磁波，卡片内有一个 LC 串联谐振电路，其频率与 读写器发射的频率相同，在电磁波的激励下，LC 谐振电路产生共振，从而使电容内有了电荷，在这个电容的另一端，接有一个单向导通的电子泵，将电容内的电荷送到另一个电容内储存，当所积累的电荷达到 2V 时，此电 容可做为电源为其它电路提供工作电压，将卡内数据发射出去或接取读写器的数据。

RFID 射频卡通信协议

RC522 模块提供了两种通信接口，分别是 I 2C 串行通信、SPI 串行通信。数据传输顺序为先传高位，再传低 位。在 I 2C 串行通信模式下，支持快速模式（400Kbit/s）和高速模式（3400Kbit/s）。在 SPI 串行通信模式下，最 大的传输速度为 10Mbit/s，数据与时钟相位关系满足“空闲态时钟为低电平，在时钟上升沿同步接收和发送数据， 在下降沿数据转换”的约束关系。

本实验用的是SPI接口，时钟主频84MHZ，所以分频系数最小8分频。

原理图分析

RC522 模块通过标准的 SPI 通信接口与 MCU 进行数据传输，使用标准 SPI 通信协议对 RC522 进行操作， 就可以完成对卡片进行读取和写操作。

1. RC522模块和M1卡要点介绍：

M1卡存储结构

存储结构：

在这里插入图片描述

其中第0扇区的块0是用于存放厂商代码的，已经固化，不可更改，为32位（4Bytes）；

每个扇区的块0、块1和块2位数据块，可用于存储数据，每块16个字节（只有S50卡是这样）；

每个扇区的块3位控制块，包含了密码A、存取控制、密码B，具体结构如下图所示；

在这里插入图片描述

2.工作原理

原理：

读写器向M1卡发一组固定频率的电磁波，卡片内有一个LC串联谐振电路，其频率与读写器发射的频率相同，在电磁波的激励下，LC谐振电路产生共振，从而使电容内有了电荷，在这个电容的另一端，接有一个单向导通的电子泵，将电容内的电荷送到另一个电容内储存，当所积累的电荷达到2V时，此电容可做为电源为其它电路提供工作电压，将卡内数据发射出去或接取读写器的数据。

3.RFID卡识别过程：

（1）寻卡

（2）防冲突

　　 在很多应用场合，读写器要在很短时间内尽快识别多个标签。由于读写器和标签通信共享无线信道，读写器或标签的信号可能发生冲突，使读写器不能正确识别标签，即发生了碰撞(Collision),

（3）选卡

　　 选择被选中的卡的序列号，并同时返回卡的容量代码。

(4）操作卡

　　选定要处理的卡片之后，读写器就确定要访问的扇区号，并对该扇区密码进行密码校验，在三次相互认证之后就可以通过加密流进行通讯。（在选择另一扇区时，则必须进行另一扇区密码校验。）

4.M1射频卡与读写器的通讯

  • 复位应答（Answer to request）

　　　　　　M1射频卡的通讯协议和通讯波特率是定义好的，当有卡片进入读写器的操作范围时，读写器以特定的协议与它通讯，从而 确定该卡是否为M1射频卡，即验证卡片的卡型。

  • 防冲突机制 (Anticollision Loop)

　　　　　　当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作，未选中的则处于空闲模式等待下一次选卡，该过程会返回被选卡的序列号。

  • 选择卡片(Select Tag)

　　　　　　选择被选中的卡的序列号，并同时返回卡的容量代码。

  • 三次互相确认(3 Pass Authentication)

　　　　　　选定要处理的卡片之后，读写器就确定要访问的扇区号，并对该扇区密码进行密码校验，在三次相互认证之后就可以通过加密流进行通讯。（在选择另一扇区时，则必须进行另一扇区密码校验。）

3. 驱动代码

RC522.h

  1.  #ifndef __RC522_H
  2.  #define __RC522_H   
  3.  #include "stm32f10x.h"
  4.  #include "stm32f10x_spi.h"
  5.  #include <string.h>
  6.  #include <stdio.h>
  7.  ​
  8.  /*******************************
  9.  *连线说明：
  10.  *1--SDA  <----->PA4
  11.  *2--SCK  <----->PA5
  12.  *3--MOSI <----->PA7
  13.  *4--MISO <----->PA6
  14.  *5--悬空
  15.  *6--GND <----->GND
  16.  *7--RST <----->PB0
  17.  *8--VCC <----->VCC
  18.  ************************************/
  19.  ​
  20.  //MF522命令代码
  21.  #define PCD_IDLE              0x00               //取消当前命令
  22.  #define PCD_AUTHENT           0x0E               //验证密钥
  23.  #define PCD_RECEIVE           0x08               //接收数据
  24.  #define PCD_TRANSMIT          0x04               //发送数据
  25.  #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
  26.  #define PCD_RESETPHASE        0x0F               //复位
  27.  #define PCD_CALCCRC           0x03               //CRC计算
  28.  ​
  29.  //Mifare_One卡片命令代码
  30.  #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
  31.  #define PICC_REQALL           0x52               //寻天线区内全部卡
  32.  #define PICC_ANTICOLL1        0x93               //防冲撞
  33.  #define PICC_ANTICOLL2        0x95               //防冲撞
  34.  #define PICC_AUTHENT1A        0x60               //验证A密钥
  35.  #define PICC_AUTHENT1B        0x61               //验证B密钥
  36.  #define PICC_READ             0x30               //读块
  37.  #define PICC_WRITE            0xA0               //写块
  38.  #define PICC_DECREMENT        0xC0               //扣款
  39.  #define PICC_INCREMENT        0xC1               //充值
  40.  #define PICC_RESTORE          0xC2               //调块数据到缓冲区
  41.  #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
  42.  #define PICC_HALT             0x50               //休眠
  43.  ​
  44.  #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
  45.  #define MAXRLEN  18
  46.  ​
  47.  //MF522寄存器定义
  48.  ​
  49.  // PAGE 0
  50.  #define     RFU00                 0x00    
  51.  #define     CommandReg            0x01    
  52.  #define     ComIEnReg             0x02    
  53.  #define     DivlEnReg             0x03    
  54.  #define     ComIrqReg             0x04    
  55.  #define     DivIrqReg             0x05
  56.  #define     ErrorReg              0x06    
  57.  #define     Status1Reg            0x07    
  58.  #define     Status2Reg            0x08    
  59.  #define     FIFODataReg           0x09
  60.  #define     FIFOLevelReg          0x0A
  61.  #define     WaterLevelReg         0x0B
  62.  #define     ControlReg            0x0C
  63.  #define     BitFramingReg         0x0D
  64.  #define     CollReg               0x0E
  65.  #define     RFU0F                 0x0F
  66.  // PAGE 1     
  67.  #define     RFU10                 0x10
  68.  #define     ModeReg               0x11
  69.  #define     TxModeReg             0x12
  70.  #define     RxModeReg             0x13
  71.  #define     TxControlReg          0x14
  72.  #define     TxAutoReg             0x15
  73.  #define     TxSelReg              0x16
  74.  #define     RxSelReg              0x17
  75.  #define     RxThresholdReg        0x18
  76.  #define     DemodReg              0x19
  77.  #define     RFU1A                 0x1A
  78.  #define     RFU1B                 0x1B
  79.  #define     MifareReg             0x1C
  80.  #define     RFU1D                 0x1D
  81.  #define     RFU1E                 0x1E
  82.  #define     SerialSpeedReg        0x1F
  83.  // PAGE 2    
  84.  #define     RFU20                 0x20  
  85.  #define     CRCResultRegM         0x21
  86.  #define     CRCResultRegL         0x22
  87.  #define     RFU23                 0x23
  88.  #define     ModWidthReg           0x24
  89.  #define     RFU25                 0x25
  90.  #define     RFCfgReg              0x26
  91.  #define     GsNReg                0x27
  92.  #define     CWGsCfgReg            0x28
  93.  #define     ModGsCfgReg           0x29
  94.  #define     TModeReg              0x2A
  95.  #define     TPrescalerReg         0x2B
  96.  #define     TReloadRegH           0x2C
  97.  #define     TReloadRegL           0x2D
  98.  #define     TCounterValueRegH     0x2E
  99.  #define     TCounterValueRegL     0x2F
  100.  // PAGE 3      
  101.  #define     RFU30                 0x30
  102.  #define     TestSel1Reg           0x31
  103.  #define     TestSel2Reg           0x32
  104.  #define     TestPinEnReg          0x33
  105.  #define     TestPinValueReg       0x34
  106.  #define     TestBusReg            0x35
  107.  #define     AutoTestReg           0x36
  108.  #define     VersionReg            0x37
  109.  #define     AnalogTestReg         0x38
  110.  #define     TestDAC1Reg           0x39  
  111.  #define     TestDAC2Reg           0x3A   
  112.  #define     TestADCReg            0x3B   
  113.  #define     RFU3C                 0x3C   
  114.  #define     RFU3D                 0x3D   
  115.  #define     RFU3E                 0x3E   
  116.  #define     RFU3F                 0x3F
  117.  ​
  118.  //和RC522通讯时返回的M1卡状态
  119.  #define     MI_OK                 0x26
  120.  #define     MI_NOTAGERR           0xcc
  121.  #define     MI_ERR                0xbb
  122.  ​
  123.  //和MF522通讯时返回的错误代码
  124.  #define     SHAQU1                0X01
  125.  #define     KUAI4                 0X04
  126.  #define     KUAI7                 0X07
  127.  #define     REGCARD               0xa1
  128.  #define     CONSUME               0xa2
  129.  #define     READCARD              0xa3
  130.  #define     ADDMONEY              0xa4
  131.  ​
  132.  #define SPI_RC522_ReadByte()          SPI_RC522_SendByte(0)
  133.  ​
  134.  #define SET_SPI_CS  (GPIOF->BSRR=0X01)
  135.  #define CLR_SPI_CS  (GPIOF->BRR=0X01)
  136.  ​
  137.  #define SET_RC522RST  GPIOF->BSRR=0X02
  138.  #define CLR_RC522RST  GPIOF->BRR=0X02
  139.  ​
  140.  ​
  141.  /***********************RC522 函数宏定义**********************/
  142.  #define          RC522_CS_Enable()         GPIO_ResetBits ( GPIOA, GPIO_Pin_4 )
  143.  #define          RC522_CS_Disable()        GPIO_SetBits ( GPIOA, GPIO_Pin_4 )
  144.  ​
  145.  #define          RC522_Reset_Enable()      GPIO_ResetBits( GPIOB, GPIO_Pin_0 )
  146.  #define          RC522_Reset_Disable()     GPIO_SetBits ( GPIOB, GPIO_Pin_0 )
  147.  ​
  148.  #define          RC522_SCK_0()             GPIO_ResetBits( GPIOA, GPIO_Pin_5 )
  149.  #define          RC522_SCK_1()             GPIO_SetBits ( GPIOA, GPIO_Pin_5 )
  150.  ​
  151.  #define          RC522_MOSI_0()            GPIO_ResetBits( GPIOA, GPIO_Pin_7 )
  152.  #define          RC522_MOSI_1()            GPIO_SetBits ( GPIOA, GPIO_Pin_7 )
  153.  ​
  154.  #define          RC522_MISO_GET()          GPIO_ReadInputDataBit ( GPIOA, GPIO_Pin_6 )
  155.  ​
  156.  u8       SPI_RC522_SendByte         ( u8 byte);
  157.  u8       ReadRawRC                  ( u8 ucAddress );
  158.  void     WriteRawRC                 ( u8 ucAddress, u8 ucValue );
  159.  void     SPI1_Init                  ( void );
  160.  void     RC522_Handel               ( void );
  161.  void     RC522_Init                 ( void );                       //初始化
  162.  void     PcdReset                   ( void );                       //复位
  163.  void     M500PcdConfigISOType       ( u8 type );                    //工作方式
  164.  char     PcdRequest                 ( u8 req_code, u8 * pTagType ); //寻卡
  165.  char     PcdAnticoll                ( u8 * pSnr);                   //防冲撞
  166.  ​
  167.  void     PcdAntennaOn               ( void );                 //开启天线
  168.  void     PcdAntennaOff              ( void );                 //关闭天线
  169.  void     SetBitMask                 ( u8 ucReg, u8 ucMask );
  170.  void     ClearBitMask               ( u8 ucReg, u8 ucMask );
  171.  char     PcdSelect                  ( u8 * pSnr );            //选择卡片
  172.  char     PcdAuthState               ( u8 ucAuth_mode, u8 ucAddr, u8 * pKey, u8 * pSnr );                                              //验证密码
  173.  char     PcdWrite                   ( u8 ucAddr, u8 * pData );
  174.  char     PcdRead                    ( u8 ucAddr, u8 * pData );
  175.  void     ShowID                     ( u16 x,u16 y, u8 *p, u16 charColor, u16 bkColor);   //显示卡的卡号，以十六进制显示
  176.  char             PcdHalt            ( void );           //命令卡片进入休眠状态
  177.  void             CalulateCRC                ( u8 * pIndata, u8 ucLen, u8 * pOutData );
  178.  ​
  179.  #endif
  180.  ​
  181.  
  182.  
  183. RC522.c
  184.  
  185.  #include "rc522.h"
  186.  #include "./SysTick/bsp_SysTick.h"
  187.  #include "./usart/bsp_usart.h"
  188.  #include "stm32f10x_spi.h"
  189.  ​
  190.  // M1卡分为16个扇区，每个扇区由四个块（块0、块1、块2、块3）组成
  191.  // 将16个扇区的64个块按绝对地址编号为：0~63
  192.  // 第0个扇区的块0（即绝对地址0块），用于存放厂商代码，已经固化不可更改 
  193.  // 每个扇区的块0、块1、块2为数据块，可用于存放数据
  194.  // 每个扇区的块3为控制块（绝对地址为:块3、块7、块11.....）包括密码A，存取控制、密码B等
  195.  ​
  196.  /*******************************
  197.  *连线说明：
  198.  *1--SDA  <----->PA4
  199.  *2--SCK  <----->PA5
  200.  *3--MOSI <----->PA7
  201.  *4--MISO <----->PA6
  202.  *5--悬空
  203.  *6--GND <----->GND
  204.  *7--RST <----->PB0
  205.  *8--VCC <----->VCC
  206.  ************************************/
  207.  ​
  208.  #define   RC522_DELAY()  delay_us( 2 ) 
  209.  ​
  210.  /*全局变量*/
  211.  unsigned char CT[2];            //卡类型
  212.  unsigned char SN[4];            //卡号
  213.  unsigned char RFID[16];             //存放RFID 
  214.  unsigned char lxl_bit=0;
  215.  unsigned char card1_bit=0;
  216.  unsigned char card2_bit=0;
  217.  unsigned char card3_bit=0;
  218.  unsigned char card4_bit=0;
  219.  unsigned char total=0;
  220.  unsigned char lxl[4]={196,58,104,217};
  221.  unsigned char card_1[4]={83,106,11,1};
  222.  unsigned char card_2[4]={208,121,31,57};
  223.  unsigned char card_3[4]={176,177,143,165};
  224.  unsigned char card_4[4]={5,158,10,136};
  225.  u8 KEY[6]={0xff,0xff,0xff,0xff,0xff,0xff};
  226.  u8 AUDIO_OPEN[6] = {0xAA, 0x07, 0x02, 0x00, 0x09, 0xBC};
  227.  unsigned char RFID1[16]={0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x07,0x80,0x29,0xff,0xff,0xff,0xff,0xff,0xff};
  228.  /*函数声明*/
  229.  unsigned char status;
  230.  unsigned char s=0x08;
  231.  ​
  232.  /* 函数名：RC522_Init
  233.   * 描述  ：初始化RC522配置
  234.   * 输入  ：无
  235.   * 返回  : 无
  236.   * 调用  ：外部调用              */
  237.  void RC522_Init ( void )
  238.  {
  239.      SPI1_Init(); 
  240.      RC522_Reset_Disable();        //将RST置高，启动内部复位阶段；
  241.    PcdReset ();                  //复位RC522 
  242.    PcdAntennaOff();              //关闭天线
  243.      RC522_DELAY();                //delay 1ms
  244.    PcdAntennaOn();               //打开天线
  245.      M500PcdConfigISOType ( 'A' ); //设置工作方式
  246.  }
  247.  ​
  248.  /* 函数名：SPI1_Init
  249.   * 描述  ：初始化SPI1的配置
  250.   * 输入  ：无
  251.   * 返回  : 无
  252.   * 调用  ：外部调用              */
  253.  void SPI1_Init (void)   
  254.  {
  255.        SPI_InitTypeDef  SPI_InitStructure; 
  256.        GPIO_InitTypeDef GPIO_InitStructure;
  257.        RCC_APB2PeriphClockCmd(   RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能 
  258.      
  259.        // CS
  260.      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;    
  261.      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;         //推挽输出
  262.      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        //IO口速度为50MHz
  263.      GPIO_Init(GPIOA, &GPIO_InitStructure);                   //根据设定参数初始化PF0、PF1
  264.      
  265.      // SCK
  266.      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;    
  267.      GPIO_Init(GPIOA, &GPIO_InitStructure);
  268.      
  269.      // MISO
  270.      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;    
  271.      GPIO_Init(GPIOA, &GPIO_InitStructure);
  272.      
  273.      // MOSI
  274.      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;    
  275.      GPIO_Init(GPIOA, &GPIO_InitStructure);
  276.      
  277.      // RST
  278.      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;    
  279.      GPIO_Init(GPIOB, &GPIO_InitStructure);
  280.          
  281.          //置高CS口
  282.      RC522_CS_Disable();
  283.  ​
  284.      //其他SPI1配置
  285.      SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;            //全双工；
  286.      SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                //主机模式；
  287.      SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                            //传输数据为8位；
  288.      SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;                                   //时钟极性CPOL为空闲时低电平；
  289.      SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;                                 //时钟采样点为时钟奇数沿（上升沿）；
  290.      SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                    //NSS引脚由软件改变；
  291.      SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;          //预分频系数64；
  292.      SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                           //MSB先行模式；
  293.      SPI_InitStructure.SPI_CRCPolynomial = 7;                                     //CRC校验；
  294.          
  295.     //初始化SPI1
  296.      SPI_Init(SPI1 , &SPI_InitStructure);
  297.          
  298.     //使能SPI1
  299.      SPI_Cmd(SPI1 , ENABLE); 
  300.   }
  301.  ​
  302.  /* 函数名：PcdRese
  303.   * 描述  ：复位RC522 
  304.   * 输入  ：无
  305.   * 返回  : 无
  306.   * 调用  ：外部调用              */
  307.  void PcdReset ( void )
  308.  {
  309.      RC522_Reset_Disable();
  310.      delay_us ( 1 );
  311.      RC522_Reset_Enable();
  312.      delay_us ( 1 );
  313.      RC522_Reset_Disable();
  314.      delay_us ( 1 );
  315.      WriteRawRC ( CommandReg, 0x0f );
  316.  ​
  317.      while ( ReadRawRC ( CommandReg ) & 0x10 );
  318.      
  319.      delay_us ( 1 );
  320.      WriteRawRC ( ModeReg, 0x3D );                //定义发送和接收常用模式 和Mifare卡通讯，CRC初始值0x6363
  321.      WriteRawRC ( TReloadRegL, 30 );              //16位定时器低位    
  322.      WriteRawRC ( TReloadRegH, 0 );               //16位定时器高位
  323.      WriteRawRC ( TModeReg, 0x8D );               //定义内部定时器的设置
  324.      WriteRawRC ( TPrescalerReg, 0x3E );          //设置定时器分频系数
  325.      WriteRawRC ( TxAutoReg, 0x40 );              //调制发送信号为100%ASK       
  326.  }
  327.  ​
  328.  /* 函数名：SPI_RC522_SendByte
  329.   * 描述  ：向RC522发送1 Byte 数据
  330.   * 输入  ：byte，要发送的数据
  331.   * 返回  : RC522返回的数据
  332.   * 调用  ：内部调用                 */
  333.  u8 SPI_RC522_SendByte ( u8 byte )
  334.  {
  335.        while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);         
  336.      SPI_I2S_SendData(SPI1, byte);                     
  337.      while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET); 
  338.      return  SPI_I2S_ReceiveData(SPI1);
  339.  }
  340.  ​
  341.  ​
  342.  /* 函数名：ReadRawRC
  343.   * 描述  ：读RC522寄存器
  344.   * 输入  ：ucAddress，寄存器地址
  345.   * 返回  : 寄存器的当前值
  346.   * 调用  ：内部调用                 */
  347.  u8 ReadRawRC ( u8 ucAddress )
  348.  {
  349.      u8 ucAddr, ucReturn;
  350.      ucAddr = ( ( ucAddress << 1 ) & 0x7E ) | 0x80;      
  351.  ​
  352.      RC522_CS_Enable();
  353.      SPI_RC522_SendByte ( ucAddr );
  354.      ucReturn = SPI_RC522_ReadByte ();
  355.      RC522_CS_Disable();
  356.      return ucReturn;
  357.  }
  358.  ​
  359.  ​
  360.   /* 函数名：WriteRawRC
  361.   * 描述  ：写RC522寄存器
  362.   * 输入  ：ucAddress，寄存器地址  、 ucValue，写入寄存器的值
  363.   * 返回  : 无
  364.   * 调用  ：内部调用   */
  365.  void WriteRawRC ( u8 ucAddress, u8 ucValue )
  366.  {  
  367.      u8 ucAddr;
  368.      ucAddr = ( ucAddress << 1 ) & 0x7E;   
  369.      
  370.      RC522_CS_Enable();  
  371.      SPI_RC522_SendByte ( ucAddr );
  372.      SPI_RC522_SendByte ( ucValue );
  373.      RC522_CS_Disable(); 
  374.  }
  375.  ​
  376.  /* 函数名：M500PcdConfigISOType
  377.   * 描述  ：设置RC522的工作方式
  378.   * 输入  ：ucType，工作方式
  379.   * 返回  : 无
  380.   * 调用  ：外部调用        */
  381.  void M500PcdConfigISOType ( u8 ucType )
  382.  {
  383.      if ( ucType == 'A')                     //ISO14443_A
  384.    {
  385.          ClearBitMask ( Status2Reg, 0x08 );      
  386.  ​
  387.      WriteRawRC ( ModeReg, 0x3D );//3F   
  388.          WriteRawRC ( RxSelReg, 0x86 );//84
  389.          WriteRawRC ( RFCfgReg, 0x7F );   //4F
  390.          WriteRawRC ( TReloadRegL, 30 );//tmoLength);// TReloadVal = 'h6a =tmoLength(dec) 
  391.          WriteRawRC ( TReloadRegH, 0 );
  392.          WriteRawRC ( TModeReg, 0x8D );
  393.          WriteRawRC ( TPrescalerReg, 0x3E );
  394.          delay_us   ( 2 );
  395.          
  396.          PcdAntennaOn ();//开天线
  397.     }
  398.  }
  399.  ​
  400.  /*
  401.   * 函数名：SetBitMask
  402.   * 描述  ：对RC522寄存器置位
  403.   * 输入  ：ucReg，寄存器地址
  404.   *         ucMask，置位值
  405.   * 返回  : 无
  406.   * 调用  ：内部调用
  407.   */
  408.  void SetBitMask ( u8 ucReg, u8 ucMask )  
  409.  {
  410.      u8 ucTemp;
  411.  ​
  412.      ucTemp = ReadRawRC ( ucReg );
  413.      WriteRawRC ( ucReg, ucTemp | ucMask );         // set bit mask
  414.  }
  415.  ​
  416.  /* 函数名：ClearBitMask
  417.   * 描述  ：对RC522寄存器清位
  418.   * 输入  ：ucReg，寄存器地址
  419.   *         ucMask，清位值
  420.   * 返回  : 无
  421.   * 调用  ：内部调用           */
  422.  void ClearBitMask ( u8 ucReg, u8 ucMask )  
  423.  {
  424.      u8 ucTemp;
  425.      ucTemp = ReadRawRC ( ucReg );
  426.      
  427.      WriteRawRC ( ucReg, ucTemp & ( ~ ucMask) );  // clear bit mask
  428.      
  429.  }
  430.  ​
  431.  /* 函数名：PcdAntennaOn
  432.   * 描述  ：开启天线 
  433.   * 输入  ：无
  434.   * 返回  : 无
  435.   * 调用  ：内部调用            */
  436.  void PcdAntennaOn ( void )
  437.  {
  438.      u8 uc;
  439.      uc = ReadRawRC ( TxControlReg );
  440.      
  441.      if ( ! ( uc & 0x03 ) )
  442.              SetBitMask(TxControlReg, 0x03);
  443.  ​
  444.  }
  445.  ​
  446.  /* 函数名：PcdAntennaOff
  447.   * 描述  ：开启天线 
  448.   * 输入  ：无
  449.   * 返回  : 无
  450.   * 调用  ：内部调用             */
  451.  void PcdAntennaOff ( void )
  452.  {
  453.      ClearBitMask ( TxControlReg, 0x03 );
  454.  }
  455.  ​
  456.  void ShowID(u16 x,u16 y, u8 *p, u16 charColor, u16 bkColor)  //显示卡的卡号，以十六进制显示
  457.  {
  458.      u8 num[9];
  459.  ​
  460.      printf("ID>>>%s\r\n", num);
  461.  ​
  462.  }
  463.  ​
  464.  /* 函数名：PcdComMF522
  465.   * 描述  ：通过RC522和ISO14443卡通讯
  466.   * 输入  ：ucCommand，RC522命令字
  467.   *         pInData，通过RC522发送到卡片的数据
  468.   *         ucInLenByte，发送数据的字节长度
  469.   *         pOutData，接收到的卡片返回数据
  470.   *         pOutLenBit，返回数据的位长度
  471.   * 返回  : 状态值
  472.   *         = MI_OK，成功
  473.   * 调用  ：内部调用              */
  474.  char PcdComMF522 ( u8 ucCommand, u8 * pInData, u8 ucInLenByte, u8 * pOutData, u32 * pOutLenBit )        
  475.  {
  476.      char cStatus = MI_ERR;
  477.      u8 ucIrqEn   = 0x00;
  478.      u8 ucWaitFor = 0x00;
  479.      u8 ucLastBits;
  480.      u8 ucN;
  481.      u32 ul;
  482.  ​
  483.      switch ( ucCommand )
  484.      {
  485.         case PCD_AUTHENT:        //Mifare认证
  486.            ucIrqEn   = 0x12;     //允许错误中断请求ErrIEn  允许空闲中断IdleIEn
  487.            ucWaitFor = 0x10;     //认证寻卡等待时候 查询空闲中断标志位
  488.            break;
  489.               
  490.         case PCD_TRANSCEIVE:     //接收发送 发送接收
  491.            ucIrqEn   = 0x77;     //允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
  492.            ucWaitFor = 0x30;     //寻卡等待时候 查询接收中断标志位与 空闲中断标志位
  493.            break;
  494.               
  495.         default:
  496.           break;
  497.               
  498.      }
  499.     
  500.      WriteRawRC ( ComIEnReg, ucIrqEn | 0x80 );       //IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反 
  501.      ClearBitMask ( ComIrqReg, 0x80 );           //Set1该位清零时，CommIRqReg的屏蔽位清零
  502.      WriteRawRC ( CommandReg, PCD_IDLE );        //写空闲命令
  503.      SetBitMask ( FIFOLevelReg, 0x80 );          //置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
  504.      
  505.      for ( ul = 0; ul < ucInLenByte; ul ++ )
  506.          WriteRawRC ( FIFODataReg, pInData [ ul ] );         //写数据进FIFOdata
  507.              
  508.      WriteRawRC ( CommandReg, ucCommand );                   //写命令
  509.     
  510.      
  511.      if ( ucCommand == PCD_TRANSCEIVE )
  512.              SetBitMask(BitFramingReg,0x80);                 //StartSend置位启动数据发送 该位与收发命令使用时才有效
  513.      
  514.      ul = 1000;//根据时钟频率调整，操作M1卡最大等待时间25ms
  515.          
  516.      do                                                      //认证 与寻卡等待时间    
  517.      {
  518.           ucN = ReadRawRC ( ComIrqReg );                         //查询事件中断
  519.           ul --;
  520.      } while ( ( ul != 0 ) && ( ! ( ucN & 0x01 ) ) && ( ! ( ucN & ucWaitFor ) ) );       //退出条件i=0,定时器中断，与写空闲命令
  521.          
  522.      ClearBitMask ( BitFramingReg, 0x80 );                   //清理允许StartSend位
  523.          
  524.      if ( ul != 0 )
  525.      {
  526.          if ( ! (( ReadRawRC ( ErrorReg ) & 0x1B )) )            //读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
  527.          {
  528.              cStatus = MI_OK;
  529.              
  530.              if ( ucN & ucIrqEn & 0x01 )                 //是否发生定时器中断
  531.                cStatus = MI_NOTAGERR;   
  532.                  
  533.              if ( ucCommand == PCD_TRANSCEIVE )
  534.              {
  535.                  ucN = ReadRawRC ( FIFOLevelReg );           //读FIFO中保存的字节数
  536.                  
  537.                  ucLastBits = ReadRawRC ( ControlReg ) & 0x07;   //最后接收到得字节的有效位数
  538.                  
  539.                  if ( ucLastBits )
  540.                      * pOutLenBit = ( ucN - 1 ) * 8 + ucLastBits;    //N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
  541.                  else
  542.                      * pOutLenBit = ucN * 8;                     //最后接收到的字节整个字节有效
  543.                  
  544.                  if ( ucN == 0 ) 
  545.                      ucN = 1;    
  546.                  
  547.                  if ( ucN > MAXRLEN )
  548.                      ucN = MAXRLEN;   
  549.                  
  550.                  for ( ul = 0; ul < ucN; ul ++ )
  551.                    pOutData [ ul ] = ReadRawRC ( FIFODataReg );   
  552.              }       
  553.          }
  554.              else
  555.                  cStatus = MI_ERR;   
  556.      }
  557.     
  558.     SetBitMask ( ControlReg, 0x80 );           // stop timer now
  559.     WriteRawRC ( CommandReg, PCD_IDLE ); 
  560.      
  561.     return cStatus;
  562.  }
  563.  ​
  564.  ​
  565.  /* 函数名：PcdRequest
  566.   * 描述  ：寻卡
  567.   * 输入  ：ucReq_code，寻卡方式
  568.   *                     = 0x52，寻感应区内所有符合14443A标准的卡
  569.   *                     = 0x26，寻未进入休眠状态的卡
  570.   *         pTagType，卡片类型代码
  571.   *                   = 0x4400，Mifare_UltraLight
  572.   *                   = 0x0400，Mifare_One(S50)
  573.   *                   = 0x0200，Mifare_One(S70)
  574.   *                   = 0x0800，Mifare_Pro(X))
  575.   *                   = 0x4403，Mifare_DESFire
  576.   * 返回  : 状态值
  577.   *         = MI_OK，成功
  578.   * 调用  ：外部调用            */
  579.  char PcdRequest ( u8 ucReq_code, u8 * pTagType )
  580.  {
  581.      char cStatus;  
  582.      u8 ucComMF522Buf [ MAXRLEN ]; 
  583.      u32 ulLen;
  584.  ​
  585.      ClearBitMask ( Status2Reg, 0x08 );  //清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
  586.      WriteRawRC ( BitFramingReg, 0x07 ); //  发送的最后一个字节的 七位
  587.      SetBitMask ( TxControlReg, 0x03 );  //TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
  588.  ​
  589.      ucComMF522Buf [ 0 ] = ucReq_code;       //存入 卡片命令字
  590.  ​
  591.      cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 1, ucComMF522Buf, & ulLen ); //寻卡  
  592.  ​
  593.      if ( ( cStatus == MI_OK ) && ( ulLen == 0x10 ) )    //寻卡成功返回卡类型 
  594.      {    
  595.         * pTagType = ucComMF522Buf [ 0 ];
  596.         * ( pTagType + 1 ) = ucComMF522Buf [ 1 ];
  597.      }
  598.       
  599.      else
  600.       cStatus = MI_ERR;
  601.  ​
  602.      return cStatus;
  603.  }
  604.  ​
  605.  /* 函数名：PcdAnticoll
  606.   * 描述  ：防冲撞
  607.   * 输入  ：pSnr，卡片序列号，4字节
  608.   * 返回  : 状态值
  609.   *         = MI_OK，成功
  610.   * 调用  ：外部调用           */
  611.  char PcdAnticoll ( u8 * pSnr )
  612.  {
  613.      char cStatus;
  614.      u8 uc, ucSnr_check = 0;
  615.      u8 ucComMF522Buf [ MAXRLEN ]; 
  616.        u32 ulLen;
  617.  ​
  618.      ClearBitMask ( Status2Reg, 0x08 );      //清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
  619.      WriteRawRC ( BitFramingReg, 0x00);      //清理寄存器 停止收发
  620.      ClearBitMask ( CollReg, 0x80 );         //清ValuesAfterColl所有接收的位在冲突后被清除
  621.     
  622.      ucComMF522Buf [ 0 ] = 0x93; //卡片防冲突命令
  623.      ucComMF522Buf [ 1 ] = 0x20;
  624.     
  625.      cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 2, ucComMF522Buf, & ulLen);//与卡片通信
  626.      
  627.      if ( cStatus == MI_OK)      //通信成功
  628.      {
  629.          for ( uc = 0; uc < 4; uc ++ )
  630.          {
  631.              * ( pSnr + uc )  = ucComMF522Buf [ uc ];            //读出UID
  632.              ucSnr_check ^= ucComMF522Buf [ uc ];
  633.          }
  634.              
  635.          if ( ucSnr_check != ucComMF522Buf [ uc ] )
  636.                  cStatus = MI_ERR;    
  637.                   
  638.      }
  639.      
  640.      SetBitMask ( CollReg, 0x80 );
  641.  ​
  642.      return cStatus;
  643.  }
  644.  ​
  645.  /* 函数名：PcdSelect
  646.   * 描述  ：选定卡片
  647.   * 输入  ：pSnr，卡片序列号，4字节
  648.   * 返回  : 状态值
  649.   *         = MI_OK，成功
  650.   * 调用  ：外部调用         */
  651.  char PcdSelect ( u8 * pSnr )
  652.  {
  653.      char ucN;
  654.      u8 uc;
  655.        u8 ucComMF522Buf [ MAXRLEN ]; 
  656.      u32  ulLen;
  657.  ​
  658.      ucComMF522Buf [ 0 ] = PICC_ANTICOLL1;
  659.      ucComMF522Buf [ 1 ] = 0x70;
  660.      ucComMF522Buf [ 6 ] = 0;
  661.      
  662.      for ( uc = 0; uc < 4; uc ++ )
  663.      {
  664.          ucComMF522Buf [ uc + 2 ] = * ( pSnr + uc );
  665.          ucComMF522Buf [ 6 ] ^= * ( pSnr + uc );
  666.      }
  667.          
  668.      CalulateCRC ( ucComMF522Buf, 7, & ucComMF522Buf [ 7 ] );
  669.      ClearBitMask ( Status2Reg, 0x08 );
  670.      ucN = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 9, ucComMF522Buf, & ulLen );
  671.      
  672.      if ( ( ucN == MI_OK ) && ( ulLen == 0x18 ) )
  673.        ucN = MI_OK;  
  674.      else
  675.        ucN = MI_ERR;    
  676.  ​
  677.      return ucN; 
  678.  }
  679.  ​
  680.  /* 函数名：CalulateCRC
  681.   * 描述  ：用RC522计算CRC16
  682.   * 输入  ：pIndata，计算CRC16的数组
  683.   *         ucLen，计算CRC16的数组字节长度
  684.   *         pOutData，存放计算结果存放的首地址
  685.   * 返回  : 无
  686.   * 调用  ：内部调用              */
  687.  void CalulateCRC ( u8 * pIndata, u8 ucLen, u8 * pOutData )
  688.  {
  689.      u8 uc, ucN;
  690.  ​
  691.      ClearBitMask(DivIrqReg,0x04);
  692.      WriteRawRC(CommandReg,PCD_IDLE);
  693.      SetBitMask(FIFOLevelReg,0x80);
  694.      
  695.      for ( uc = 0; uc < ucLen; uc ++)
  696.          WriteRawRC ( FIFODataReg, * ( pIndata + uc ) );   
  697.  ​
  698.      WriteRawRC ( CommandReg, PCD_CALCCRC );
  699.      uc = 0xFF;
  700.  ​
  701.      do {
  702.          ucN = ReadRawRC ( DivIrqReg );
  703.          uc --;} 
  704.      while ( ( uc != 0 ) && ! ( ucN & 0x04 ) );
  705.          
  706.      pOutData [ 0 ] = ReadRawRC ( CRCResultRegL );
  707.      pOutData [ 1 ] = ReadRawRC ( CRCResultRegM );
  708.      
  709.  }
  710.  ​
  711.  /* 函数名：PcdAuthState
  712.   * 描述  ：验证卡片密码
  713.   * 输入  ：ucAuth_mode，密码验证模式
  714.   *                     = 0x60，验证A密钥
  715.   *                     = 0x61，验证B密钥
  716.   *         u8 ucAddr，块地址
  717.   *         pKey，密码
  718.   *         pSnr，卡片序列号，4字节
  719.   * 返回  : 状态值
  720.   *         = MI_OK，成功
  721.   * 调用  ：外部调用          */
  722.  char PcdAuthState ( u8 ucAuth_mode, u8 ucAddr, u8 * pKey, u8 * pSnr )
  723.  {
  724.      char cStatus;
  725.      u8 uc, ucComMF522Buf [ MAXRLEN ];
  726.      u32 ulLen;
  727.  ​
  728.      ucComMF522Buf [ 0 ] = ucAuth_mode;
  729.      ucComMF522Buf [ 1 ] = ucAddr;
  730.      
  731.      for ( uc = 0; uc < 6; uc ++ )
  732.          ucComMF522Buf [ uc + 2 ] = * ( pKey + uc );   
  733.      
  734.      for ( uc = 0; uc < 6; uc ++ )
  735.          ucComMF522Buf [ uc + 8 ] = * ( pSnr + uc );   
  736.  ​
  737.      cStatus = PcdComMF522 ( PCD_AUTHENT, ucComMF522Buf, 12, ucComMF522Buf, & ulLen );
  738.      
  739.      if ( ( cStatus != MI_OK ) || ( ! ( ReadRawRC ( Status2Reg ) & 0x08 ) ) ){
  740.              cStatus = MI_ERR; 
  741.      }
  742.          
  743.      return cStatus;    
  744.  }
  745.  ​
  746.  /* 函数名：PcdWrite
  747.   * 描述  ：写数据到M1卡一块
  748.   * 输入  ：u8 ucAddr，块地址
  749.   *         pData，写入的数据，16字节
  750.   * 返回  : 状态值
  751.   *         = MI_OK，成功
  752.   * 调用  ：外部调用           */
  753.  char PcdWrite ( u8 ucAddr, u8 * pData )
  754.  {
  755.      char cStatus;
  756.        u8 uc, ucComMF522Buf [ MAXRLEN ];
  757.      u32 ulLen;
  758.  ​
  759.      ucComMF522Buf [ 0 ] = PICC_WRITE;
  760.      ucComMF522Buf [ 1 ] = ucAddr;
  761.      
  762.      CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
  763.   
  764.      cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen );
  765.  ​
  766.      if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
  767.        cStatus = MI_ERR;   
  768.          
  769.      if ( cStatus == MI_OK )
  770.      {
  771.        memcpy(ucComMF522Buf, pData, 16);
  772.        for ( uc = 0; uc < 16; uc ++ )
  773.                ucComMF522Buf [ uc ] = * ( pData + uc );  
  774.              
  775.        CalulateCRC ( ucComMF522Buf, 16, & ucComMF522Buf [ 16 ] );
  776.  ​
  777.        cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 18, ucComMF522Buf, & ulLen );
  778.              
  779.              if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
  780.          cStatus = MI_ERR;   
  781.              
  782.      } 
  783.  ​
  784.      return cStatus;
  785.      
  786.  }
  787.  ​
  788.  /* 函数名：PcdRead
  789.   * 描述  ：读取M1卡一块数据
  790.   * 输入  ：u8 ucAddr，块地址
  791.   *         pData，读出的数据，16字节
  792.   * 返回  : 状态值
  793.   *         = MI_OK，成功
  794.   * 调用  ：外部调用             */
  795.  char PcdRead ( u8 ucAddr, u8 * pData )
  796.  {
  797.      char cStatus;
  798.        u8 uc, ucComMF522Buf [ MAXRLEN ]; 
  799.      u32 ulLen;
  800.  ​
  801.      ucComMF522Buf [ 0 ] = PICC_READ;
  802.      ucComMF522Buf [ 1 ] = ucAddr;
  803.      
  804.      CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
  805.     
  806.      cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen );
  807.      
  808.      if ( ( cStatus == MI_OK ) && ( ulLen == 0x90 ) )
  809.      {
  810.              for ( uc = 0; uc < 16; uc ++ )
  811.          * ( pData + uc ) = ucComMF522Buf [ uc ];   
  812.      }
  813.          
  814.      else
  815.        cStatus = MI_ERR;   
  816.      
  817.      return cStatus;
  818.  ​
  819.  }
  820.  ​
  821.  /* 函数名：PcdHalt
  822.   * 描述  ：命令卡片进入休眠状态
  823.   * 输入  ：无
  824.   * 返回  : 状态值
  825.   *         = MI_OK，成功
  826.   * 调用  ：外部调用        */
  827.  char PcdHalt( void )
  828.  {
  829.      u8 ucComMF522Buf [ MAXRLEN ]; 
  830.      u32  ulLen;
  831.  ​
  832.      ucComMF522Buf [ 0 ] = PICC_HALT;
  833.      ucComMF522Buf [ 1 ] = 0;
  834.  ​
  835.      CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
  836.      PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen );
  837.  ​
  838.      return MI_OK;   
  839.  }

  • SPI传输速率设置问题：SPI口例程中的预分频默认为4，而RC522中的SPI最高速率为10MHz/S，计算可知，预分频指数至少为8，所以适当升高预分频数，据反馈，预分频为8也容易出错，所以建议32或者64甚至为256；

  • SPI时序问题：根据文档中的时序图，仔细设置SPI_InitStructure.SPI_CPOL和SPI_InitStructure.SPI_CPHA这两个参数；

  • SPI口的GPIO模式设置：我以前在设计TM1638芯片为核心的灯、按键模组时也出现过这个问题，后来一般全部设置为推挽输出就基本不在出现这个问题；

  • 天线在复位时需要先关闭再开启；

低功耗

查阅资料没明白这个低功耗应该怎么设置，翻阅了一个前辈的方法。

1，使用RTC，定时唤醒读卡。

2，添加外部检测卡的传感器，单片机正常情况下处于断电模式（这是终极省电），由外部的检测部分唤醒，然后运行程序；在程序的最开始判断是被那个部分唤醒的，然后进行响应的处理。

采用一个检测卡的传感器，一旦扫描到卡就将信号传出去通过或门电路唤醒单片机，单片机自锁上电信号，判断到卡片。然后开始寻卡

- 如果没有扫到卡，就关闭自锁信号，再次关机，回到低功耗模式

关于RC522刷卡低功耗解决方案 - 简书 (jianshu.com)

EEPROM规格

项目中使用AT24C02存储了RFID识别的卡号以及绑定的手机号数据

卡号数据：4位

在项目中，卡号与手机号绑定，即

  1. typedef struct {      
  2.  
  3.     uint8_t icCardNumber[4];    //IC卡号
  4.  
  5.     uint8_t phoneNumber[12];    //绑定手机号
  6.  
  7. } Part1Data;

AT24C04的每页有16字节空间，刚好够一页。

读写数据代码：

  1.  
  2. /*
  3. ****************************************************************************************
  4. * INCLUDES (头文件包含)
  5. ****************************************************************************************
  6. */
  7. #include "at24c04.h"
  8. #include "iic3.h"
  9. #include "delay.h"
  10. #include "stdio.h"
  11. #include <string.h>
  12.  
  13. /*
  14. ****************************************************************************************
  15. * Function: At24c04Init
  16. * Description: At24c04初始化
  17. * Input: None
  18. * Output: None
  19. * Return: None
  20. ****************************************************************************************
  21. */
  22. void At24c02Init(void)
  23. {
  24. 	IIC3_Pin_Init( );
  25. }
  26.  
  27. /*
  28. ****************************************************************************************
  29. * Function: At24c02WriteByte
  30. * Description: -----------------------------------------------------写1字节数据到At24c02
  31. * Input: addr内部地址（0~255）  data待写入的数据
  32. * Output: None
  33. * Return: 0成功写入  其他：错误码
  34. ****************************************************************************************
  35. */
  36. uint8_t At24c04WriteByte(uint16_t addr,uint8_t data)
  37. {
  38. 	uint8_t ack;
  39. 	
  40. 	/* 1,发送起始信号  */
  41. 	IIC3_Start( );        
  42. 	
  43. 	/*   2,发送写操作  并等待应答信号    */
  44. 	ack=IIC3_Send_Byte(AT24C02_ADDR_W);
  45. 	if(ack)
  46. 	{
  47. 		IIC3_Stop( );
  48. 		return WRITE_ERR1;
  49. 	}
  50. 	Delay_nms(10);
  51. 	/* 发送内存地址  并等待应答信号  */
  52. 	ack=IIC3_Send_Byte(addr);
  53. 	if(ack)
  54. 	{
  55. 		IIC3_Stop( );
  56. 		return WRITE_ERR2;
  57. 	}
  58. 	Delay_nms(10);
  59. 	/* 发送写入数据  并等待应答信号 */
  60. 	ack=IIC3_Send_Byte(data);
  61. 	if(ack)
  62. 	{
  63. 		IIC3_Stop( );
  64. 		return WRITE_ERR3;
  65. 	}
  66. 	/* 发送停止信号      */
  67. 	IIC3_Stop( );
  68. 	/* 等待eeprom的写入完成     要求5ms */
  69. 	Delay_nms(10);
  70. 	
  71. 	return 0;
  72. }
  73.  
  74. /*
  75. ****************************************************************************************
  76. * Function: At24c02readByte
  77. * Description: -----------------------------------------------------读1字节数据到At24c02
  78. * Input: addr内部地址（0~255）  
  79. * Output: None
  80. * Return: 读的数据
  81. ****************************************************************************************
  82. */
  83. uint8_t At24c02readByte(uint16_t addr)
  84. {
  85. 	uint8_t ack;
  86. 	uint8_t rec=2;
  87. 	
  88. 	/* 1,发送起始信号  */
  89. 	IIC3_Start( );        
  90. 	
  91. 	/* 2,发送写操作  并等待应答信号  */
  92. 	ack=IIC3_Send_Byte(AT24C02_ADDR_W);
  93. 	if(ack)
  94. 	{
  95. 		IIC3_Stop( );
  96. 		return WRITE_ERR1;
  97. 	}
  98. 	Delay_nms(10);
  99. 	/* 发送内存地址  并等待应答信号  */
  100. 	ack=IIC3_Send_Byte(addr);
  101. 	if(ack)
  102. 	{
  103. 		IIC3_Stop( );
  104. 		return WRITE_ERR2;
  105. 	}
  106. 	Delay_nms(10);
  107. 	/* 发送起始信号  */
  108. 	IIC3_Start( );  
  109. 	
  110. 	/*   2,发送读操作  并等待应答信号    */
  111. 	ack=IIC3_Send_Byte(AT24C02_ADDR_R);
  112. 	if(ack)
  113. 	{
  114. 		IIC3_Stop( );
  115. 		return WRITE_ERR3;
  116. 	}
  117. 	Delay_nms(10);
  118. 	rec = IIC3_Revice_Byte(0);     //  获取数据地址就行，不需要应答    0非应答   1应答  
  119. 	Delay_nms(10);
  120. 	/* 发送停止信号      */
  121. 	IIC3_Stop( );
  122. 	
  123. 	return rec;
  124. }
  125.  
  126. /*
  127. ****************************************************************************************
  128. * Function: At24c02PageWrite
  129. * Description: ---------------------------------------------------------------页写At24c02
  130. * Input: addr内部地址（0~255）  num待写入的数据个数  p指向待写入的数据
  131. * Output: None
  132. * Return: 0成功写入  其他：错误码
  133. ****************************************************************************************
  134. */
  135. uint8_t At24c02PageWrite(uint16_t addr,uint8_t num,uint8_t *p)
  136. {
  137. 	uint8_t ack=0;
  138. 	
  139. 	//起始地址---addr
  140. 	//结束地址---addr+num-1
  141. 	
  142. //	if(addr/8 != (addr+num-1)/8)
  143. //	{
  144. //		return NOT_IN_SAME_PAGE;
  145. //	}
  146. 	
  147. 	IIC3_Start( );
  148. 	
  149. 	ack=IIC3_Send_Byte(AT24C02_ADDR_W);//发送器件地址+写方向
  150. 	if(ack)
  151. 	{
  152. 		IIC3_Stop( );
  153. 		return WRITE_ERR4;
  154. 	}
  155. 	
  156. 	ack=IIC3_Send_Byte(addr);//发送内部地址
  157. 	if(ack)
  158. 	{
  159. 		IIC3_Stop( );
  160. 		return WRITE_ERR5;
  161. 	}
  162. 	
  163. 	while(num--)
  164. 	{
  165. 		ack=IIC3_Send_Byte(*p);//发送数据
  166. 		if(ack)
  167. 		{
  168. 			IIC3_Stop( );
  169. 			return WRITE_ERR3;
  170. 		}
  171. 		p++;
  172. 	}
  173. 	
  174. 	IIC3_Stop( );
  175. 	
  176. 	Delay_nms(5);//写周期！！！！！！！！！！！！！！！！
  177. 	
  178. 	return 0;
  179. }
  180.  
  181. /*
  182. ****************************************************************************************
  183. * Function: At24c02WriteBytes
  184. * Description: -------------------------------------------------------------随机写At24c02
  185. * Input: addr内部地址（0~511）  num要写入的数据个数（1~256）  p指向数据存储空间
  186. * Output: None
  187. * Return: 0成功写入  其他：错误码
  188. * Others: 起始地址跟结束地址在同一页
  189. ****************************************************************************************
  190. */
  191. uint8_t At24c02WriteBytes(uint16_t addr,uint16_t num,uint8_t *p)
  192. {
  193. 	uint8_t ret=0;
  194. 	uint8_t less_addr=0;//当前页还剩下多少个地址空间可以写
  195. 	
  196. 	while(1)
  197. 	{
  198. 		less_addr=8-addr%8;
  199. 		if(less_addr>=num)//本页可以写完
  200. 		{
  201. 			less_addr=num;
  202. 		}
  203. 			
  204. 		ret=At24c02PageWrite(addr,less_addr,p);
  205. 		if(ret)
  206. 		{
  207. 			return ret;
  208. 		}
  209. 		
  210. 		if(less_addr==num)
  211. 		{
  212. 			return 0;
  213. 		}
  214. 		
  215. 		addr=addr+less_addr;//下一页的起始地址
  216. 		num=num-less_addr;//还剩下多少个数据没写
  217. 		p=p+less_addr;//偏移到还没写的数据
  218. 	}
  219. 	
  220. }
  221.  
  222. /*
  223. ****************************************************************************************
  224. * Function: At24c02ReadBytes
  225. * Description:--------------------------------------------------------------随机读At24c02
  226. * Input: addr内部地址（0~255）  num要读取的数据个数  p指向数据存储空间
  227. * Output: None
  228. * Return: 0成功写入  其他：错误码
  229. * Others: 起始地址跟结束地址在同一页
  230. ****************************************************************************************
  231. */
  232. uint8_t At24c02ReadBytes(uint16_t addr,uint16_t num,uint8_t *p)
  233. {
  234. 	uint8_t ack=0;
  235. 	
  236. 	IIC3_Start( );
  237. 	
  238. 	ack=IIC3_Send_Byte(AT24C02_ADDR_W);//发送器件地址+写方向
  239. 	if(ack)
  240. 	{
  241. 		IIC3_Stop( );
  242. 		return READ_ERR1;
  243. 	}
  244. 	
  245. 	ack=IIC3_Send_Byte(addr);//发送内部地址
  246. 	if(ack)
  247. 	{
  248. 		IIC3_Stop( );
  249. 		return READ_ERR2;
  250. 	}
  251. 	
  252. 	IIC3_Start( );//重复起始条件
  253. 	
  254. 	ack=IIC3_Send_Byte(AT24C02_ADDR_R);//发送器件地址+读方向
  255. 	if(ack)
  256. 	{
  257. 		IIC3_Stop( );
  258. 		return READ_ERR3;
  259. 	}
  260. 	
  261. 	while(num)
  262. 	{
  263. 		num--;//还剩下多少个字节没有读
  264. 		if(num==0)
  265. 		{
  266. 			*p=IIC3_Revice_Byte(1);
  267. 			break;
  268. 		}
  269. 		*p++=IIC3_Revice_Byte(0);
  270. 		
  271. 	}
  272. 	
  273. 	IIC3_Stop( );
  274. 	
  275. 	return 0;
  276. }
  277.  
  278. /*
  279. ****************************************************************************************
  280. * Function: At24c02ChipErase
  281. * Description:--------------------------------------------------------------擦除At24c02
  282. * Input: 
  283. * Output: 
  284. * Return: 
  285. * Others: 
  286. ****************************************************************************************
  287. */
  288. void At24c02ChipErase() 
  289. {
  290.     // 将所有字节设置为 0xFF（擦除状态）
  291.     uint8_t eraseData[256];
  292.     for (int i = 0; i < sizeof(eraseData); i++) {
  293.         eraseData[i] = 0xFF;
  294.     }
  295.  
  296.     // 逐页写入擦除数据
  297.     int pageNum = 256/8;  // 每页包含 16 字节
  298.     for (int page = 0; page < pageNum; page++) {
  299.         int address = page * 8;
  300.         if (At24c02WriteBytes(address, sizeof(eraseData), eraseData) != 0) {
  301.             printf("整体擦除失败\r\n");
  302.             return;
  303.         }
  304.     }
  305.  
  306.     printf("整体擦除成功\r\n");
  307. }
  308.  
  309.  
  310. int HuiFuChuChangSheZhi() 
  311. {
  312.     uint8_t GL_MiMa[6]={'0','0','0','0','0','0'};         // 出厂——管理员密码
  313.     uint8_t KM_MiMa[6]={'1','2','3','4','5','6'};         //出厂------开门密码
  314.  // 将所有字节设置为 0x00（擦除状态）
  315.     uint8_t eraseData[256];
  316.     memset(eraseData, 0x00, sizeof(eraseData));
  317.  
  318.     // 逐页写入擦除数据
  319.     int pageNum = 256/8;  // 每页包含 16 字节
  320.  
  321.     for (int page = 0; page < pageNum; page++) 
  322. 	{
  323.         int address = page * 8;
  324.         if (At24c02WriteBytes(address, sizeof(eraseData), eraseData) != 0) 
  325. 		{
  326.             printf("整体擦除失败\r\n");
  327.             return 0;
  328. 		}
  329.     }
  330.     printf("整体擦除成功\r\n");	
  331. //将初始化开门密码与管理员密码写入指定位置		
  332. 	if (At24c02WriteBytes(240,sizeof(KM_MiMa),KM_MiMa)!=0) //在指定位置240(31页的前6字节)存开门密码
  333. 	{
  334. 		return 0;
  335. 	}
  336. 	if (At24c02WriteBytes(232,sizeof(GL_MiMa),GL_MiMa)!=0)  //在指定位置232(30页的前6字节)存管理员密码
  337. 	{
  338. 		return 0;
  339. 	}                		
  340. 		return 1;
  341. }
  342.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/205824
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号