21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 基于STM32的RFID-RC522门禁系统
返回列表 发新帖我要提问

[其他ST产品] 基于STM32的RFID-RC522门禁系统

[复制链接]
 楼主| 而服务器人 发表于 2022-12-27 16:34 | 显示全部楼层 |阅读模式
RC522, RF, RFID, ST, STM
设计介绍

这是一个基于STM32的RFID-RC522门禁系统，LCD1602显示当前状态，当检测到IC卡时，如果这个IC卡已经登记过，LCD1602上会显示IC卡的卡号，继电器打开，如果没有登记则报警。部分代码如下。

复制
  1. #include "sys.h"
    

  2. #include "delay.h"
    

  3. #include "lcd.h"
    

  4. #include "led.h"
    

  5. #include "usart.h"
    

  6. #include "dht11.h"
    

  7. #include "key.h"
    

  8. #include "beep.h"
    

  9. #include <stdio.h>
    

  10. #include "stmflash.h"
    

  11. #include "timer.h"
    

  12. #include "exit.h"
    

  13. #include "rc522.h"
    


  14. 

  15. void show1(void);
    

  16. void show2(void);
    

  17. void show3(void);
    

  18. void show4(void);
    

  19. void show5(void);
    

  20. void show21(void);
    

  21. void show31(void);
    

  22. void show8(void);
    

  23. u8 read_up=1;
    

  24. u8 set1=1;
    


  25. 

  26. /*这三个标志位是用于按键的扫描程序*/
    

  27. u8 key0_flag=0;
    

  28. u8 key1_flag=0;
    

  29. u8 key2_flag=0;
    

  30. u8 beep_switch=0;
    

  31. u8 beep_num=0;
    

  32. u8 beepup_num=0;
    

  33. u8 open_flag=0;
    

  34. u8 down_flag=0;
    

  35. u8 err_beepnum=0;
    

  36. u8 table1[]="Please Bash Card";
    

  37. u8 table11[]="      (())      ";
    

  38. u8 table2[]="  Register Mode ";
    

  39. u8 table22[]="      (())      ";
    

  40. u8 table222[]="Register Success";
    

  41. u8 table3[]="   Clear Mode   ";
    

  42. u8 table33[]=" **ut Success ";
    

  43. u8 table5[]="    Door open   ";
    

  44. u8 table6[]="   Door close   ";
    

  45. u8 table8[]=" Dead Lock    s ";
    

  46. u8 err_num=0;
    

  47. u8 eee_flag=0;
    

  48. int kg_flag=0;//定时器4累加标志位，用于当RFID扫描到了并对门做出了相应的动作后，返回到扫描ID卡的计时标志位
    

  49. u8 tim2_flag=0;//定时器2累加标志位，用于当按键按下之后，并完成了注册或注销卡之后，返回到扫描ID卡的计时标志位
    

  50. u8 show_flag=0;//记录显示那个界面的标志位
    

  51. unsigned char num;
    

  52. unsigned char key_flag;//用于标识当前系统处于，扫描ID卡状态还是注册ID卡状态还是注销ID卡状态
    

  53. unsigned char i;
    

  54. unsigned int temp;
    

  55. unsigned char status;
    

  56. unsigned char g_ucTempbuf[20];
    

  57. unsigned char g_ucTempbufid[20];//用于记录下来当前扫描到的ID
    

  58. unsigned char lcd[]="0123456789ABCDEF";//用于显示ID时的16进制
    

  59. unsigned char dataerr[16] = {0x11,0x11,0x11,0x78,0xED,0xCB,0xA9,0x87,0x12,0x34,0x56,0x78,0x01,0xFE,0x01,0xFE};//ID卡中错误的密码数据
    

  60. unsigned char data1[16] = {0x12,0x34,0x56,0x78,0xED,0xCB,0xA9,0x87,0x12,0x34,0x56,0x78,0x01,0xFE,0x01,0xFE};//ID卡中正确的密码数据
    


  61. 

  62. unsigned char data2[4]  = {0,0,0,0x01};
    

  63. unsigned char DefaultKey[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; 
    


  64. 


  65. 

  66. u8 RC522_flag=1;
    

  67. u8 RC522_flag1=1;
    

  68. u8 RC522_flag2=1;
    

  69. u8 RC522_flag3=0;
    

  70. /*按键的扫描函数*/
    


  71. 

  72. /*用于判断系统应该显示哪一个界面*/
    


  73. 

  74.         
    


  75. 

  76. int main(void)
    

  77. {
    

  78.         unsigned char status,i;
    

  79.         unsigned int temp;
    

  80.         delay_init();
    

  81.   LCD1602_Init();
    

  82.         KEY_Init();
    

  83.         
    

  84.         BEEP_Init();
    

  85.         LED_Init();
    

  86.         
    

  87.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    

  88.          uart_init(115200);
    


  89. 


  90. 

  91.         RC522_Init();
    

  92.         PcdReset();
    

  93.         PcdAntennaOff(); 
    

  94.         delay_ms(10);
    

  95.          PcdAntennaOn();
    

  96.         delay_ms(10);
    

  97.         TIM2_Int_Init(4999,7199);//10Khz的计数频率，计数到5000为500ms 
    

  98.         TIM3_Int_Init(499,7199);//10Khz的计数频率，计数到5000为500ms  
    

  99.         TIM4_Int_Init(4999,7199);//10Khz的计数频率，计数到5000为500ms  
    

  100.         printf("Start \r\n");
    

  101.         key_flag=0;
    

  102.         show_flag=1;
    

  103.         beep_switch=0;
    

  104.         GPIO_ResetBits(GPIOB,GPIO_Pin_0);
    

  105.         while(1)
    

  106.         {
    

  107. //                printf("%d",RC522_flag1);
    

  108.                 
    

  109.                 
    

  110.                 show_num();
    


  111. 


  112. 

  113.                         down_flag=0;
    

  114.                         if(kg_flag==6 && err_num<3)
    

  115.                         {
    

  116.                                 GPIO_ResetBits(GPIOB,GPIO_Pin_0);
    

  117.                                 kg_flag=0;
    

  118.                                 TIM_Cmd(TIM4, DISABLE);  //使能TIMx        
    

  119.                                 GPIO_ResetBits(GPIOB,GPIO_Pin_11);
    

  120.                                 key_flag=0;
    

  121.                                 show_flag=1;
    

  122.                                 open_flag=0;
    

  123.                                 down_flag=0;
    


  124. 

  125.                         }
    

  126.                         else if(kg_flag==360 && err_num==3)
    

  127.                         {
    

  128.                                 kg_flag=0;
    

  129.                                 err_beepnum=0;
    

  130.                                 GPIO_ResetBits(GPIOB,GPIO_Pin_0);
    

  131.                                 TIM_Cmd(TIM4, DISABLE);  //使能TIMx        
    

  132.                                 key_flag=0;
    

  133.                                 show_flag=1;
    

  134.                                 err_num=0;
    

  135.                         }
    


  136. 

  137.                 if(tim2_flag==4)
    

  138.                 {                
    

  139.                                 GPIO_ResetBits(GPIOB,GPIO_Pin_0);
    

  140.                                 tim2_flag=0;
    

  141.                                 TIM_Cmd(TIM2, DISABLE);  //使能TIMx        
    

  142.                                 key_flag=0;
    

  143.                           show_flag=1;
    


  144. 

  145.                 }
    

  146.                 if(key_flag==0)
    

  147.                 {
    


  148. 

  149.                         status = PcdRequest(PICC_REQALL, g_ucTempbuf);//寻卡                         
    

  150.                         if (status != MI_OK)                 
    

  151.                         {    
    

  152.                                 PcdReset();
    

  153.                                 PcdAntennaOff(); 
    

  154.                                 PcdAntennaOn();
    

  155.                                         printf("寻卡失败\r\n");
    

  156.                                 
    

  157.                                 if(RC522_flag3<3) RC522_flag3++;
    

  158.                           if(RC522_flag3==4)RC522_flag3=3;
    

  159.                                 
    


  160. 

  161.                         
    

  162.                                 continue;
    

  163.                         }
    

  164.                         else 
    

  165.                         {
    

  166.                                         if(RC522_flag3==3) 
    

  167.                                         {
    

  168.                                                   RC522_flag3=4;
    

  169.                                                         RC522_flag=1;
    

  170.                                         }
    

  171.                         }
    

  172.                         
    

  173.                         
    

  174.                         if(RC522_flag==1) 
    

  175.                         {  
    

  176.                                 RC522_flag=0;                
    

  177.                                 printf("1231231231312312312312312312\r\n");
    

  178.                                 status = PcdAnticoll(g_ucTempbuf);//防冲撞                
    

  179.                                 if(status != MI_OK)
    

  180.                                 {   printf("寻卡失败1");  continue;           }
    


  181. 


  182. 

  183.                                 printf("卡序列号：");        //超级终端显示,
    

  184.                                 for(i=0;i<4;i++)
    

  185.                                 {
    

  186.                                 temp=g_ucTempbuf[i];
    

  187.                                 g_ucTempbufid[i]=temp;
    

  188.                                 printf("%X",temp);
    

  189.                                 }
    

  190.                                                         status = PcdSelect(g_ucTempbuf);//选定卡片
    

  191.                                 if (status != MI_OK)
    

  192.                                 {   printf("寻卡失败2");  continue;           }
    

  193.                                          
    

  194.                                 
    

  195.                                 status = PcdAuthState(PICC_AUTHENT1A, 1, DefaultKey, g_ucTempbuf);//验证卡片密码
    

  196.                                 if (status != MI_OK)
    

  197.                                 {           printf("寻卡失败3");   continue;  }
    


  198. 

  199.                                                 
    


  200. 

  201.                                 status = PcdRead(1, g_ucTempbuf);//读块
    

  202.                                 if (status != MI_OK)
    

  203.                                 {          printf("寻卡失败4");    continue;  }
    

  204.                                                                         
    

  205.                                 printf("卡读块：");        //超级终端显示,
    

  206.                                 for(i=0;i<16;i++)
    

  207.                                 {
    

  208.                                         temp=g_ucTempbuf[i];
    

  209.                                         printf("%X",temp);
    

  210.                                 }
    

  211.                                 num=0;
    

  212.                                 for(i=0;i<16;i++)
    

  213.                                 {
    

  214.                                         if(data1[i]==g_ucTempbuf[i])
    

  215.                                         {num++;}
    

  216.                                         
    

  217.                                         printf("\nnum %d\n",num);
    

  218.                                 }
    

  219.                                                 
    

  220.                                 if(num!=16)
    

  221.                                 {
    

  222.                                         err_num++;
    

  223.                                         if(err_num<3)
    

  224.                                         {                                        
    

  225.                                                 //不开门
    

  226.                                                 show_flag=4;
    

  227.                                                 kg_flag=0;
    

  228.                                                 open_flag=2;
    

  229.                                                 printf("downflag%d\n",down_flag);
    

  230.                                                 TIM_Cmd(TIM4, ENABLE);  //使能TIMx        
    

  231.                                         }
    

  232.                                 }
    

  233.                                 else
    

  234.                                 {
    

  235.                                 //开门
    

  236.                                         err_num=0;
    

  237.                                         show_flag=5;
    

  238.                                         kg_flag=0;
    

  239.                                         open_flag=1;
    

  240.                                         TIM_Cmd(TIM4, ENABLE);  //使能TIMx        
    

  241.                                         GPIO_SetBits(GPIOB,GPIO_Pin_11);
    


  242. 

  243.                                 }
    

  244.                         }
    

  245.                         
    

  246.                                 //printf("\n");                                          
    

  247.                         
    

  248.                         PcdHalt();
    

  249.                 }
    

  250.                 
    

  251.                 else if(key_flag==1)
    

  252.                 {
    

  253.         
    

  254.                         TIM_Cmd(TIM2, DISABLE);  //使能TIMx        
    

  255.       TIM_Cmd(TIM4, DISABLE);  //使能TIMx        
    

  256.                         GPIO_ResetBits(GPIOB,GPIO_Pin_11);
    

  257.       GPIO_ResetBits(GPIOB,GPIO_Pin_0);
    

  258.                         show_flag=2;
    

  259.                         status = PcdRequest(PICC_REQALL, g_ucTempbuf);//寻卡
    

  260.                         if (status != MI_OK)
    

  261.                         {    
    

  262.                                 PcdReset();
    

  263.                                 PcdAntennaOff(); 
    

  264.                                 PcdAntennaOn(); 
    

  265.                                 key_flag=1;                printf("寻卡失败111\r\n");RC522_flag1=1;
    


  266. 

  267.                                 continue;
    

  268.                                 
    


  269. 

  270.                         }
    

  271.                         if(RC522_flag1==1)
    

  272.                         {
    

  273.                                 RC522_flag3=0;
    

  274.                                 RC522_flag1=0;
    

  275.                                 printf("1231231231312312312312312312\r\n");
    


  276. 

  277.                                 printf("卡的类型:");
    

  278.                                 for(i=0;i<2;i++)
    

  279.                                 {
    

  280.                                 temp=g_ucTempbuf[i];
    

  281.                                 printf("%X",temp);
    

  282.                                 }
    

  283.                                 
    

  284.                                 status = PcdAnticoll(g_ucTempbuf);//防冲撞                
    

  285.                                 if(status != MI_OK)
    

  286.                                 {  
    

  287.                                         printf("防冲撞失败");
    

  288.                                  
    

  289.                                 }
    

  290.                                 else
    

  291.                                 {
    

  292.                                                                                                                 
    

  293.                                         printf("卡序列号：");        //超级终端显示,
    

  294.                                         for(i=0;i<4;i++)
    

  295.                                         {
    

  296.                                                 temp=g_ucTempbuf[i];
    

  297.                                                 printf("%X",temp);
    


  298. 

  299.                                         }
    


  300. 

  301.                                         status = PcdSelect(g_ucTempbuf);//选定卡片
    

  302.                                         if (status != MI_OK)
    

  303.                                         {    
    

  304.                                                 printf("选定卡失败");   
    


  305. 

  306.                                         }
    

  307.                                         else
    

  308.                                         {        
    

  309.                                                 status = PcdAuthState(PICC_AUTHENT1A, 1, DefaultKey, g_ucTempbuf);//验证卡片密码
    

  310.                                                 if (status != MI_OK)
    

  311.                                                 {    
    

  312.                                                         printf("密码错误");
    


  313. 

  314.                                                 }
    

  315.                                                 else
    

  316.                                                 {
    

  317.                                                         status = PcdWrite(1, data1);//写块
    

  318.                                                         if (status != MI_OK)
    

  319.                                                         {    
    

  320.                                                                 printf("写错");
    

  321.                                                                          
    

  322.                                                         }
    

  323.                                                         else
    

  324.                                                         {                
    


  325. 

  326.                                                                 
    

  327.                                                                         key_flag=3;
    

  328.                                                                         show_flag=6;                                                
    

  329.                   tim2_flag=0;
    

  330.                                                                         TIM_Cmd(TIM2, ENABLE);  //使能TIMx                                                                                                                                         
    

  331.                                                         }                                                        
    

  332.                                                 }                                                        
    

  333.                                         }                                                
    

  334.                                 }                
    

  335.                  
    

  336.                         
    

  337.                         }
    


  338. 

  339.             PcdHalt();
    

  340. //                        
    

  341. //RC522_flag1=1;
    

  342.         
    

  343.                         
    

  344.                         
    

  345.                 }
    

  346.                 else if(key_flag==2)
    

  347.                 {
    

  348.                                          TIM_Cmd(TIM2, DISABLE);  //使能TIMx        
    

  349.      TIM_Cmd(TIM4, DISABLE);  //使能TIMx        
    

  350.                                                 GPIO_ResetBits(GPIOB,GPIO_Pin_11);
    

  351.       GPIO_ResetBits(GPIOB,GPIO_Pin_0);
    

  352.                         show_flag=3;
    

  353.                         status = PcdRequest(PICC_REQALL, g_ucTempbuf);//寻卡
    

  354.                         if (status != MI_OK)
    

  355.                         {    
    

  356.                                 PcdReset();
    

  357.                                 PcdAntennaOff(); 
    

  358.                                 PcdAntennaOn(); 
    

  359.                                 printf("寻卡失败\r\n");
    

  360.                                 key_flag=2;
    

  361.                                 RC522_flag2=1;
    

  362.                                 continue;
    

  363.                         }
    

  364.                         if(RC522_flag2==1)
    

  365.                         {
    

  366.                                 RC522_flag3=0;
    

  367.                                 RC522_flag2=0;printf("1231231231312312312312312312\r\n");
    


  368. 

  369.                                 printf("卡的类型:");
    

  370.                                 for(i=0;i<2;i++)
    

  371.                                 {
    

  372.                                         temp=g_ucTempbuf[i];
    

  373.                                         printf("%X",temp);
    

  374.                                 }                                
    

  375.                                 status = PcdAnticoll(g_ucTempbuf);//防冲撞                
    

  376.                                 if(status != MI_OK)
    

  377.                                 {  
    

  378.                                         printf("防冲撞失败");
    


  379. 

  380.                                 }
    

  381.                                 else
    

  382.                                 {                                                        
    

  383.                                         printf("卡序列号：");        //超级终端显示,
    

  384.                                         for(i=0;i<4;i++)
    

  385.                                         {
    

  386.                                                 temp=g_ucTempbuf[i];
    

  387.                                                 printf("%X",temp);
    


  388. 

  389.                                         }                                                
    

  390.                                         status = PcdSelect(g_ucTempbuf);//选定卡片
    

  391.                                         if (status != MI_OK)
    

  392.                                         {    
    

  393.                                                 printf("选定卡失败");   
    


  394. 

  395.                                         }
    

  396.                                         else
    

  397.                                         {        
    

  398.                                                 status = PcdAuthState(PICC_AUTHENT1A, 1, DefaultKey, g_ucTempbuf);//验证卡片密码
    

  399.                                                 if (status != MI_OK)
    

  400.                                                 {    
    

  401.                                                         printf("密码错误");
    

  402.                                                          
    

  403.                                                 }
    

  404.                                                 else
    

  405.                                                 {
    

  406.                                                         status = PcdWrite(1, dataerr);//写块
    

  407.                                                         if (status != MI_OK)
    

  408.                                                         {    
    

  409.                                                                 printf("写错");
    

  410.                                                                 
    

  411.                                                         }
    

  412.                                                         else
    

  413.                                                         {                                
    

  414.                 
    

  415.                                                                 key_flag=3; 
    

  416.                                                                 show_flag=7;        
    

  417.                                                                 tim2_flag=0;
    

  418.                                                                 TIM_Cmd(TIM2, ENABLE);  //使能TIMx        
    

  419.                                                      
    

  420.                                                         }                                                
    

  421.                                                 }                                        
    

  422.                                         }                        
    

  423.                                 }                                 
    

  424.                         }
    

  425.                         PcdHalt();
    

  426.                 
    

  427.                 }
    

  428.                 else if(key_flag==3)
    

  429.                 {
    

  430.                         
    

  431.                 }
    

  432.         }
    


  433. 

  434. }
    


  435.


回复 赏

举报

相关帖子
pmp 发表于 2023-1-5 11:26 | 显示全部楼层
这个工程文件有了吗？              
回复 赏

举报

OKAKAKO 发表于 2023-1-5 11:35 | 显示全部楼层
原理简单，代码编写很有用
回复 赏

举报

maudlu 发表于 2023-1-5 11:36 | 显示全部楼层
射频卡是否支持加密呢？              
回复 赏

举报

hudi008 发表于 2023-1-5 16:20 | 显示全部楼层
这个最大的读取速度是多少？              
回复 赏

举报

Jacquetry 发表于 2023-1-5 16:49 | 显示全部楼层
最大的读取速度是多少？   
回复 赏

举报

adolphcocker 发表于 2023-1-5 17:00 | 显示全部楼层
射频卡的功能非常强大。              
回复 赏

举报

LOVEEVER 发表于 2023-1-6 09:30 | 显示全部楼层
固定频率的电磁波，非接触的功能很好
回复 赏

举报

louliana 发表于 2023-1-6 17:34 | 显示全部楼层
这个如何写入数据？              
回复 赏

举报

mikewalpole 发表于 2023-1-7 16:30 | 显示全部楼层
怎么写入数据到RC522系统呢？
回复 赏

举报

bestwell 发表于 2023-1-9 15:33 | 显示全部楼层
循环扫描的话，会不会连续读写卡片？
回复 赏

举报

星辰大海不退缩 发表于 2023-1-9 16:10 来自手机 | 显示全部楼层
射频卡应用还是很多的，不过这种应该加密吧
回复 赏

举报

sheflynn 发表于 2023-1-12 14:51 | 显示全部楼层
检测IC卡的时候，会报错，但是读取不到数据。
回复 赏

举报

zerorobert 发表于 2023-1-13 22:26 | 显示全部楼层
RC522可以被哪个模块替代呢？
回复 赏

举报

updownq 发表于 2023-1-14 14:39 | 显示全部楼层
这个有时候会接触不良怎么回事？              
回复 赏

举报

uiint 发表于 2023-1-14 15:58 | 显示全部楼层
怎么判断ic卡已经读取到了？              
回复 赏

举报

everyrobin 发表于 2023-1-16 19:00 | 显示全部楼层
STM32的性能还是不错的。              
回复 赏

举报

abotomson 发表于 2023-1-19 13:23 | 显示全部楼层
怎么判断数据是否读取成功？              
回复 赏

举报

earlmax 发表于 2023-1-19 18:28 | 显示全部楼层
怎么使用这个中断？              
回复 赏

举报

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

本版积分规则

而服务器人

41

主题

467

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部