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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机的AS608指纹锁源程序
返回列表 发新帖
查看: 5061|回复: 2
打印 上一主题 下一主题
收起左侧

51单片机的AS608指纹锁源程序

  [复制链接]
跳转到指定楼层
楼主
ID:782179 发表于 2020-6-17 16:01 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
AS608 指纹识别模块主要是指采用了杭州晟元芯片技术有限公司(Synochip)的 AS608 指纹识别芯片 而做成的指纹模块，模块厂商只是基于该芯片设计外围电路，集成一个可供2次开发的指纹模块；所以，只要是基于AS608芯片的指纹模块，其控制电路及控制协议几乎是一样的，只是厂家和性能不同而已。      

制作出来的实物图如下：


单片机源程序如下:
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #define MAIN_Fosc 11059200//宏定义主时钟频率
  4. #define LINE1         0x80                        //1602屏地址定义 第一行地址
  5. #define LINE2         0xc0                        //1602屏地址定义 第二行地址
  6. #define DataPort P0          //LCD1602操作位定义

  8. typedef unsigned char INT8U;
  9. typedef unsigned char uchar;
  10. typedef unsigned int INT16U;
  11. typedef unsigned int uint;

  13. sbit EN = P3^4;     //读写数据使能   0：停止 1：启动
  14. sbit RS = P3^5;     //寄存器选择 0:指令寄存器 1:数据寄存器
  15. sbit RW = P3^6;     //读写控制 0：写  1：读
  16. sbit KEY_DOWN=P2^4;
  17. sbit KEY_OK=P2^2;
  18. sbit KEY_CANCEL=P2^0;
  19. sbit beep=P2^6;

  21. uchar flag=0;
  22. extern char local_date=0;  //全局变量，当前箭头位置
  23. extern unsigned int finger_id = 0;

  25. //uart 函数
  26. void Uart_Init(void)
  27. {
  28.     SCON=0x50;   //UART方式1:8位UART;   REN=1:允许接收
  29.     PCON=0x00;   //SMOD=0:波特率不加倍
  30.     TMOD=0x20;   //T1方式2,用于UART波特率
  31.     TH1=0xFD;
  32.     TL1=0xFD;   //UART波特率设置:FDFD，9600;FFFF,57600
  33.     TR1=1;         //允许T1计数
  34.     EA=1;         //开总中断
  35. }

  37. void Uart_Send_Byte(unsigned char c)//UART Send a byte
  38. {
  39.         SBUF = c;
  40.         while(!TI);                //发送完为1
  41.         TI = 0;
  42. }

  44. unsigned char Uart_Receive_Byte()//UART Receive a byteg
  45. {        
  46.         unsigned char dat;
  47.         while(!RI);         //接收完为1
  48.         RI = 0;
  49.         dat = SBUF;
  50.         return (dat);
  51. }
  52. //延时函数
  53. void Delay_us(int i)
  54. {
  55.         while(--i);
  56. }

  58. void Delay_ms(INT16U ms)
  59. {
  60.      INT16U i;
  61.          do{
  62.               i = MAIN_Fosc / 96000;
  63.                   while(--i);   //96T per loop
  64.      }while(--ms);
  65. }

  67. //蜂鸣器函数
  68. void Beep_Times(unsigned char times)
  69. {
  70.         unsigned char i=0;
  71.         for(i=0;i<times;i++)
  72.         {
  73.                  beep=0;
  74.                  Delay_ms(200);
  75.                  beep=1;
  76.                  Delay_ms(200);
  77.         }
  78. }

  80. //按键操作函数
  81. void Key_Init(void)
  82. {
  83.     //定义按键输入端口
  84.         KEY_DOWN=1;                // 下一项
  85.         KEY_OK=1;                // 确认
  86.         KEY_CANCEL=1;        // 取消
  87. }

  89. // 1602液晶函数
  90. //写指令
  91. void LCD1602_WriteCMD(unsigned char cmd)  
  92. {
  93.           EN=0;
  94.           RS=0;
  95.           RW=0;
  96.           Delay_us(10);
  97.           EN=1;
  98.           Delay_us(10);
  99.           DataPort=cmd;
  100.           Delay_us(10);
  101.           EN=0;
  102. }
  103. //写数据
  104. void LCD1602_WriteDAT(unsigned char dat)
  105. {
  106.           EN=0;
  107.           RS=1;
  108.           RW=0;
  109.           Delay_us(10);
  110.           EN=1;
  111.           Delay_us(10);
  112.           DataPort=dat;
  113.           Delay_us(10);
  114.           EN=0;
  115. }
  116. //液晶繁忙检测
  117. void LCD1602_CheckBusy(void)
  118. {
  119.         
  120.         uchar busy;
  121.         DataPort=0xff;
  122.         RS=0;
  123.         RW=1;
  124.         do
  125.         {
  126.                 EN=1;
  127.                 busy=DataPort;
  128.                 EN=0;
  129.         }while(busy&0x80);
  130.         
  131. }
  132. //液晶初始化函数
  133. void LCD1602_Init(void)  
  134. {
  135.         Delay_ms(15);                      //上电延时15ms
  136.           LCD1602_WriteCMD(0x38); //写显示指令(不检测忙信号)
  137.           Delay_ms(5);
  138.           LCD1602_CheckBusy();
  139.           LCD1602_WriteCMD(0x38); //写显示指令
  140.           LCD1602_CheckBusy();
  141.           LCD1602_WriteCMD(0x01); //清屏
  142.           LCD1602_CheckBusy();
  143.           LCD1602_WriteCMD(0x06); //显示光标移动设置
  144.           LCD1602_CheckBusy();
  145.           LCD1602_WriteCMD(0x0c); //显示开及光标设置  
  146. }

  148. //液晶显示函数                入口参数：addr起始地址，pointer指针地址，index下标，num个数
  149. void LCD1602_Display(unsigned char addr,unsigned char* pointer,unsigned char index,unsigned char num)
  150. {
  151.           unsigned char i;
  152.           LCD1602_CheckBusy();        //判断忙信号
  153.           LCD1602_WriteCMD(addr);        //写入地址
  154.           for(i=0;i<num;i++)                //写入数据
  155.           {
  156.              LCD1602_CheckBusy();                           //判断忙信号
  157.              LCD1602_WriteDAT(pointer[index+i]);//写入数据     
  158.           }
  159. }

  161. //AS608指纹模块
  162. volatile unsigned char AS608_RECEICE_BUFFER[32]; //volatile:系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据

  164. //FINGERPRINT通信协议定义
  165. code unsigned char AS608_Get_Device[10] ={0x01,0x00,0x07,0x13,0x00,0x00,0x00,0x00,0x00,0x1b};//口令验证
  166. code unsigned char AS608_Pack_Head[6] = {0xEF,0x01,0xFF,0xFF,0xFF,0xFF};  //协议包头
  167. code unsigned char AS608_Get_Img[6] = {0x01,0x00,0x03,0x01,0x00,0x05};    //获得指纹图像
  168. code unsigned char AS608_Get_Templete_Count[6] ={0x01,0x00,0x03,0x1D,0x00,0x21 }; //获得模版总数
  169. code unsigned char AS608_Search[11]={0x01,0x00,0x08,0x04,0x01,0x00,0x00,0x03,0xE7,0x00,0xF8}; //搜索指纹搜索范围0 - 999,使用BUFFER1中的特征码搜索
  170. code unsigned char AS608_Search_0_9[11]={0x01,0x00,0x08,0x04,0x01,0x00,0x00,0x00,0x13,0x00,0x21}; //搜索0-9号指纹
  171. code unsigned char AS608_Img_To_Buffer1[7]={0x01,0x00,0x04,0x02,0x01,0x00,0x08}; //将图像放入到BUFFER1
  172. code unsigned char AS608_Img_To_Buffer2[7]={0x01,0x00,0x04,0x02,0x02,0x00,0x09}; //将图像放入到BUFFER2
  173. code unsigned char AS608_Reg_Model[6]={0x01,0x00,0x03,0x05,0x00,0x09}; //将BUFFER1跟BUFFER2合成特征模版
  174. code unsigned char AS608_Delete_All_Model[6]={0x01,0x00,0x03,0x0d,0x00,0x11};//删除指纹模块里所有的模版
  175. volatile unsigned char  AS608_Save_Finger[9]={0x01,0x00,0x06,0x06,0x01,0x00,0x0B,0x00,0x19};//将BUFFER1中的特征码存放到指定的位置
  176. //code unsigned char AS608_num_of_finger_in_lib1[7]={0x01,0x00,0x04,0x1F,0x00,0x00,0x24};//查看指纹库的命令
  177. //code unsigned char AS608_num_of_finger_in_lib2[7]={0x01,0x00,0x04,0x1F,0x01,0x00,0x25};
  178. //code unsigned char AS608_num_of_finger_in_lib3[7]={0x01,0x00,0x04,0x1F,0x02,0x00,0x26};
  179. //code unsigned char AS608_num_of_finger_in_lib4[7]={0x01,0x00,0x04,0x1F,0x03,0x00,0x27};

  181. //发送包头
  182. void AS608_Cmd_Send_Pack_Head(void)
  183. {
  184.         int i;        
  185.         for(i=0;i<6;i++) //包头
  186.         {
  187.                 Uart_Send_Byte(AS608_Pack_Head[i]);   
  188.         }               
  189. }

  191. //发送指令
  192. void AS608_Cmd_Check(void)
  193. {
  194.         int i=0;
  195.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头
  196.         for(i=0;i<10;i++)
  197.         {               
  198.                 Uart_Send_Byte(AS608_Get_Device[i]);
  199.         }
  200. }

  202. //接收反馈数据缓冲
  203. void AS608_Receive_Data(unsigned char ucLength)
  204. {
  205.         unsigned char i;                                 
  206.         for (i=0;i<ucLength;i++)
  207.                 AS608_RECEICE_BUFFER[i] = Uart_Receive_Byte();
  208. }

  210. //FINGERPRINT_获得指纹图像命令
  211. void AS608_Cmd_Get_Img(void)
  212. {
  213.     unsigned char i;
  214.     AS608_Cmd_Send_Pack_Head(); //发送通信协议包头
  215.     for(i=0;i<6;i++) //发送命令 0x1d
  216.         {
  217.        Uart_Send_Byte(AS608_Get_Img[i]);
  218.         }
  219. }

  221. //将图像转换成特征码存放在Buffer1中
  222. void FINGERPRINT_Cmd_Img_To_Buffer1(void)
  223. {
  224.          unsigned char i;
  225.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头      
  226.            for(i=0;i<7;i++)   //发送命令 将图像转换成 特征码 存放在 CHAR_buffer1
  227.         {
  228.                 Uart_Send_Byte(AS608_Img_To_Buffer1[i]);
  229.         }
  230. }
  231. //将图像转换成特征码存放在Buffer2中
  232. void FINGERPRINT_Cmd_Img_To_Buffer2(void)
  233. {
  234.         unsigned char i;
  235.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头
  236.         for(i=0;i<7;i++)   //发送命令 将图像转换成 特征码 存放在 CHAR_buffer1
  237.         {
  238.                 Uart_Send_Byte(AS608_Img_To_Buffer2[i]);
  239.         }
  240. }

  242. //搜索全部用户999枚
  243. void AS608_Cmd_Search_Finger(void)
  244. {
  245.         unsigned char i;                       
  246.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头
  247.         for(i=0;i<11;i++)
  248.         {
  249.                 Uart_Send_Byte(AS608_Search[i]);   
  250.         }
  251. }

  253. //转换成特征码
  254. void AS608_Cmd_Reg_Model(void)
  255. {
  256.         unsigned char i;                              
  257.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头
  258.         for(i=0;i<6;i++)
  259.         {
  260.                 Uart_Send_Byte(AS608_Reg_Model[i]);   
  261.         }
  262. }

  264. //删除指纹模块里的所有指纹模版
  265. void FINGERPRINT_Cmd_Delete_All_Model(void)
  266. {
  267.         unsigned char i;   
  268.     AS608_Cmd_Send_Pack_Head(); //发送通信协议包头   
  269.     for(i=0;i<6;i++) //命令删除指纹模版
  270.         {
  271.               Uart_Send_Byte(AS608_Delete_All_Model[i]);   
  272.         }        
  273. }

  275. //保存指纹
  276. void AS608_Cmd_Save_Finger( unsigned int storeID )
  277. {
  278.         unsigned long temp = 0;
  279.         unsigned char i;
  280.         AS608_Save_Finger[5] =(storeID&0xFF00)>>8;
  281.         AS608_Save_Finger[6] = (storeID&0x00FF);
  282.         for(i=0;i<7;i++)   //计算校验和
  283.                 temp = temp + AS608_Save_Finger[i];
  284.         AS608_Save_Finger[7]=(temp & 0x00FF00) >> 8; //存放校验数据
  285.         AS608_Save_Finger[8]= temp & 0x0000FF;                  
  286.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头        
  287.         for(i=0;i<9;i++)  
  288.                 Uart_Send_Byte(AS608_Save_Finger[i]);      //发送命令 将图像转换成 特征码 存放在 CHAR_buffer1
  289. }

  291. //查看当前指纹库中指纹模板数
  292. int AS608_number_of_fingers()
  293. {
  294.          int num=1;//默认模板库中有一个模板
  295.         uchar i=0;
  296.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头
  297.         for(i=0;i<6;i++)
  298.         {
  299.                   Uart_Send_Byte(AS608_Get_Templete_Count[i]);
  300.         }
  301.         AS608_RECEICE_BUFFER[9]=1;//方便后续判断是否接收成功
  302.         AS608_Receive_Data(14);//接收数据
  303.         if(AS608_RECEICE_BUFFER[9]==0) //接收成功
  304.         {
  305.                  num=AS608_RECEICE_BUFFER[10]*256+AS608_RECEICE_BUFFER[11];//拼接模板总个数                        
  306.         }
  307.         return num;
  308. }
  309. //另一种方法查看指纹库中是否有模板 //本来应该查看所有1000个模板位置是否存在模板，但一般只用得到前256个，故从简
  310. /*
  311. uchar AS608_notEmpty()
  312. {
  313.          uchar exist=0;
  314.         char i=0;
  315.         AS608_Cmd_Send_Pack_Head(); //发送通信协议包头
  316.         for(i=0;i<7;i++)
  317.         {
  318.                   Uart_Send_Byte(AS608_num_of_finger_in_lib1[i]);
  319.         }
  320.         AS608_Receive_Data(10);//接收前10byte数据,除第10字节的确认码外，其余全部丢弃
  321.         if(AS608_RECEICE_BUFFER[9]==0) //接收成功
  322.         {
  323.         AS608_Receive_Data(32);//接收后续32byte数据，此即0~255个模板为是否存在指纹模板的数据
  324.         for(i=0;i<32;i++)//查看这32byte数据，任何一个位置存在模板则返回值为真，否则为假
  325.         {
  326.                  if(AS608_RECEICE_BUFFER[i])
  327.                         exist=1;
  328.         }
  329.         return exist;
  330.         }
  331. }
  332. */
  333. //添加指纹
  334. void AS608_Add_Fingerprint()
  335. {
  336.         unsigned char id_show[]={0,0,0};
  337.         LCD1602_WriteCMD(0x01); //清屏  
  338.         while(1)
  339.         {
  340.                 LCD1602_Display(0x80,"   Add  finger  ",0,16);
  341.                 LCD1602_Display(0xc0,"    ID is       ",0,16);
  342.                 //按返回键直接回到主菜单
  343.                 if(KEY_CANCEL == 0)
  344.                 {
  345.                          Delay_ms(5);
  346.                          if(KEY_CANCEL == 0)
  347.                          {
  348.                                  while(KEY_CANCEL==0);
  349.                                  break;
  350.                          }         
  351.                 }

  353.                 //按切换键指纹iD值加1
  354.                 if(KEY_DOWN == 0)
  355.                 {
  356.                         Delay_ms(5);
  357.                         if(KEY_DOWN == 0)
  358.                         {
  359.                                 while(KEY_DOWN==0);
  360.                                 if(finger_id == 1000)
  361.                                 {
  362.                                         finger_id = 1;
  363.                                 }
  364.                                 else
  365.                                         finger_id = finger_id + 1;
  366.                         }               
  367.                 }

  369.                  //指纹iD值显示处理
  370.                  LCD1602_WriteCMD(0xc0+10);
  371.                  LCD1602_WriteDAT(finger_id/100+48);
  372.                 LCD1602_WriteDAT(finger_id%100/10+48);
  373.                  LCD1602_WriteDAT(finger_id%100%10+48);

  375.                  //按确认键开始录入指纹信息                                          
  376.                  if(KEY_OK == 0)
  377.                  {
  378.                  Delay_ms(5);
  379.                  if(KEY_OK == 0)
  380.                   {        
  381.                                 while(KEY_OK==0);
  382.                                   LCD1602_Display(0x80," Please  finger ",0,16);
  383.                                   LCD1602_Display(0xc0,"                ",0,16);
  384.                                 while(KEY_CANCEL == 1)
  385.                                   {
  386.                                           //按下返回键退出录入返回fingerID调整状态   
  387.                                         if(KEY_CANCEL == 0)
  388.                                          {
  389.                                                   Delay_ms(5);
  390.                                                 if(KEY_CANCEL == 0)
  391.                                                 {
  392.                                                         while(KEY_CANCEL==0);
  393.                                                           break;
  394.                                                 }
  395.                                                 
  396.                                           }
  397.                                         AS608_Cmd_Get_Img(); //获得指纹图像
  398.                                         AS608_Receive_Data(12);
  399.                                         //判断接收到的确认码,等于0指纹获取成功
  400.                                         if(AS608_RECEICE_BUFFER[9]==0)
  401.                                          {
  402.                                                 Delay_ms(100);
  403.                                                 FINGERPRINT_Cmd_Img_To_Buffer1();
  404.                                             AS608_Receive_Data(12);
  405.                                                 LCD1602_Display(0x80,"Successful entry",0,16);
  406.                                                 Beep_Times(1);
  407.                                                 Delay_ms(1000);
  408.                                                 LCD1602_Display(0x80," Please  finger ",0,16);
  409.                                                   LCD1602_Display(0xc0,"                ",0,16);
  410.                                                 while(1)
  411.                                                 {
  412.                                                         if(KEY_CANCEL == 0)
  413.                                                          {
  414.                                                                   Delay_ms(5);
  415.                                                                 if(KEY_CANCEL == 0)
  416.                                                                 {
  417.                                                                         while(KEY_CANCEL==0);
  418.                                                                           break;
  419.                                                                 }
  420.                                                           }
  421.                                                          AS608_Cmd_Get_Img(); //获得指纹图像
  422.                                                          AS608_Receive_Data(12);
  423.                                                         //判断接收到的确认码,等于0指纹获取成功
  424.                                                         if(AS608_RECEICE_BUFFER[9]==0)
  425.                                                         {
  426.                                                         Delay_ms(200);
  427.                                                         LCD1602_Display(0x80,"Successful entry",0,16);
  428.                                                         LCD1602_Display(0xc0,"    ID is       ",0,16);
  429.                                                          //指纹iD值显示处理
  430.                                                          LCD1602_WriteCMD(0xc0+10);
  431.                                                          LCD1602_WriteDAT(finger_id/100+48);
  432.                                                          LCD1602_WriteDAT(finger_id%100/10+48);
  433.                                                          LCD1602_WriteDAT(finger_id%100%10+48);
  434.                                                         FINGERPRINT_Cmd_Img_To_Buffer2();
  435.                                                           AS608_Receive_Data(12);
  436.                                                         AS608_Cmd_Reg_Model();//转换成特征码
  437.                                                  AS608_Receive_Data(12);
  438.                                                           AS608_Cmd_Save_Finger(finger_id);                                         
  439.                                                   AS608_Receive_Data(12);
  440.                                                         Beep_Times(1);
  441.                                                         Delay_ms(1000);
  442.                                                         finger_id=finger_id+1;
  443.                                                     break;
  444.                                                           }
  445.                                                    }
  446.                                                    break;
  447.                                         }
  448.                                 }
  449.                 }
  450.                 }
  451.         }
  452. }

  454. //搜索指纹
  455. void AS608_Find_Fingerprint()
  456. {
  457.         unsigned int find_fingerid = 0;
  458.         unsigned char id_show[]={0,0,0};
  459.         do
  460.         {
  461.                 LCD1602_Display(0x80," Please  finger ",0,16);
  462.                 LCD1602_Display(0xc0,"                ",0,16);
  463.                 AS608_Cmd_Get_Img(); //获得指纹图像
  464.                 AS608_Receive_Data(12);               
  465.                 //判断接收到的确认码,等于0指纹获取成功
  466.                 if(AS608_RECEICE_BUFFER[9]==0)
  467.                 {                        
  468.                         Delay_ms(100);
  469.                         FINGERPRINT_Cmd_Img_To_Buffer1();
  470.                         AS608_Receive_Data(12);               
  471.                         AS608_Cmd_Search_Finger();
  472.                         AS608_Receive_Data(16);                        
  473.                         if(AS608_RECEICE_BUFFER[9] == 0) //搜索到  
  474.                         {
  475.                                 //解锁成功//
  476.                                 
  477.                                 LCD1602_Display(0x80," Search success ",0,16);
  478.                                 LCD1602_Display(0xc0,"    ID is       ",0,16);
  479.                                 Beep_Times(1);                                       
  480.                                 //拼接指纹ID数
  481.                                 find_fingerid = AS608_RECEICE_BUFFER[10]*256 + AS608_RECEICE_BUFFER[11];                                       
  482.                                  //指纹iD值显示处理
  483.                                  LCD1602_WriteCMD(0xc0+10);
  484.                                  LCD1602_WriteDAT(find_fingerid/100+48);
  485.                                  LCD1602_WriteDAT(find_fingerid%100/10+48);
  486.                                  LCD1602_WriteDAT(find_fingerid%100%10+48);
  487.                                 //配置IO口，执行开锁操作
  488.                                 if(flag)
  489.                                 {
  490.                                 P1=0xfe;                                                
  491.                                 Delay_ms(3800);
  492.                                 P1=0xff;        //电动机停止转动
  493.                                 Delay_ms(1000);
  494.                                 P1=0xfd;        //电动机反转复位
  495.                                 Delay_ms(3600);//电机正转阻力远大于反转，旋转相同角度时，正转需要更多时间        
  496.                                 P1=0xff;        //电动机停止转动
  497.                                 }
  498.                                 flag=1;        //允许后续相关操作：添加或删除指纹模板
  499.                                 break;                                                        
  500.                         }
  501.                         else //没有找到
  502.                         {
  503.                                         LCD1602_Display(0x80," Search  failed ",0,16);
  504.                                         LCD1602_Display(0xc0,"                ",0,16);
  505.                                          Beep_Times(3);
  506.                         }
  507.                         }               
  508.                 }while(KEY_CANCEL == 1);
  509. }
  510. //删除所有存贮的指纹库
  511. void AS608_Delete_All_Fingerprint()
  512. {
  513.                 unsigned char i=0;
  514.                                 LCD1602_Display(0x80,"   empty all    ",0,16);
  515.                                 LCD1602_Display(0xc0,"   Yes or no ?  ",0,16);
  516.                 do
  517.                  {
  518.                         if(KEY_OK==0)
  519.                         {
  520.                         Delay_ms(5);
  521.                         if(KEY_OK==0)
  522.                         {
  523.                                 while(KEY_OK==0);
  524.                                 LCD1602_Display(0x80,"   emptying     ",0,16);
  525.                                 LCD1602_Display(0xc0,"                ",0,16);
  526.                                 Delay_ms(300);
  527.                                 LCD1602_WriteCMD(0xc0);
  528.                                 for(i=0;i<16;i++)
  529.                                  {
  530.                                         LCD1602_WriteDAT(42);// 即'*'
  531.                                         Delay_ms(100);
  532.                                  }
  533.                                 FINGERPRINT_Cmd_Delete_All_Model();
  534.                                   AS608_Receive_Data(12);
  535.                                 LCD1602_Display(0x80,"   All empty    ",0,16);
  536.                                 LCD1602_Display(0xc0,"                ",0,16);
  537.                                 Beep_Times(3);
  538.                                 break;
  539.                         }
  540.                         }
  541.                  }while(KEY_CANCEL==1);
  542. }

  544. void Device_Check(void)
  545. {
  546.                 unsigned char i=0;
  547.                 AS608_RECEICE_BUFFER[9]=1;                                           //串口数组第九位可判断是否通信正常
  548.                 LCD1602_Display(0xc0,"Loading",0,7);                   //设备加载中界面                                                           
  549.                 for(i=0;i<8;i++)                                                           //进度条式更新，看起来美观
  550.                 {
  551.                         LCD1602_WriteDAT(42);                               //42对应ASIC码的 *
  552.                         Delay_ms(20);                                                           //控制进度条速度
  553.                 }                                                                        
  554.                 LCD1602_Display(0xc0,"Docking  failure",0,16);      //液晶先显示对接失败，如果指纹模块插对的话会将其覆盖        
  555.                 AS608_Cmd_Check();                                                                //单片机向指纹模块发送校对命令
  556.                 AS608_Receive_Data(12);                                                        //将串口接收到的数据转存
  557.                  if(AS608_RECEICE_BUFFER[9] == 0)                                        //判断数据低第9位是否接收到0
  558.                 {
  559.                         LCD1602_Display(0xc0,"Docking  success",0,16);        //符合成功条件则显示对接成功
  560.                 }
  561. }

  563. //主函数
  564. void main()
  565. {                                                        
  566.         finger_id=0;
  567.         LCD1602_Init();                        //初始化液晶
  568.         LCD1602_Display(0x80,"Fingerprint Test",0,16);         //液晶开机显示界面
  569.           Uart_Init();                        //初始化串口
  570.         Key_Init();                                //初始化按键
  571.          Delay_ms(200);          //延时500MS，等待指纹模块复位
  572.         Device_Check();                           //校对指纹模块是否接入正确，液晶做出相应的提示
  573.         Delay_ms(1000);                        //对接成功界面停留一定时间
  574.         while(1)
  575.         {
  576.             
  577.                 /**************进入主功能界面****************/
  578.                 LCD1602_Display(0x80,"  search finger ",0,16);         //第一排显示搜索指纹
  579.                 LCD1602_Display(0xc0,"  Add     delete",0,16);         //添加和删除指纹
  580.                 if(local_date==0)
  581.                 {
  582.                         LCD1602_Display(0x80,  " *",0,2);
  583.                         LCD1602_Display(0xc0,  "  ",0,2);
  584.                         LCD1602_Display(0xc0+8,"  ",0,2);        
  585.                 }
  586.                 else if(local_date==1)
  587.                 {
  588.                         LCD1602_Display(0x80,  "  ",0,2);
  589.                         LCD1602_Display(0xc0,  " *",0,2);
  590.                         LCD1602_Display(0xc0+8,"  ",0,2);        
  591.                 }
  592.                 else if(local_date==2)
  593.                 {
  594.                         LCD1602_Display(0x80,  "  ",0,2);
  595.                         LCD1602_Display(0xc0,  "  ",0,2);
  596.                         LCD1602_Display(0xc0+8," *",0,2);        
  597.                 }                        
  598.                 //确认键
  599.                 if(KEY_OK == 0)
  600.                 {
  601.                 Delay_ms(5);
  602.                 if(KEY_OK == 0)
  603.                 {         
  604.                          while(KEY_OK == 0);//等待松开按键                                                               
  605.                         switch(local_date)
  606.                         {
  607.                                         case 0:  //搜索指纹        
  608.                                         flag=1;                                       
  609.                                         AS608_Find_Fingerprint();                                                                                                                                                                                                
  610.                                         break;        
  611.                                        
  612.                                         case 1:         //添加指纹
  613.                                         flag=1;        //flag=1，若指纹库为空，则可以直接添加指纹                                
  614.                                         if(AS608_number_of_fingers())
  615.                                         {
  616.                                                 flag=0;//flag置0由两重作用：
  617.                                                 //1、指纹库中已有指纹，则需要搜索匹配成功，由AS608_Find_Fingerprint()将flag置1，才能添加指纹
  618.                                                 //2、flag=0，则在搜索指纹成功后不执行开锁操作
  619.                                                 AS608_Find_Fingerprint();
  620.                                         }
  621.                                         if(flag)
  622.                                         {
  623.                                                 AS608_Add_Fingerprint();
  624.                                         }
  625.                                         break;                                         
  626.                                        
  627.                                         case 2:        //清空指纹
  628.                                         flag=0;        //1、在搜索指纹成功后不执行开锁操作；2、若搜索不成功，不执行清空操作
  629.                                         AS608_Find_Fingerprint();//搜索匹配成功后，函数内部将flag置1，才能清空指纹库
  630.                                         if(flag)
  631.                                         {
  632.                                                 AS608_Delete_All_Fingerprint();
  633.                                           }
  634.                                         break;
  635.                         }
  636.                 }
  637.                 }
  638.                     //切换键
  639.                         if(KEY_DOWN == 0)
  640.                         {
  641.                         Delay_ms(5);
  642.                         if(KEY_DOWN == 0)
  643.                         {
  644.                                  while(KEY_DOWN == 0); //等待松开按键                                
  645.                                    if(local_date<=2)
  646.                                 {
  647.                                         local_date++;
  648.                                         if(local_date==3) local_date=0;                                                
  649.                                 }               
  650.                         }
  651.                         }                                                
  652.                         Delay_ms(100); //延时判断100MS检测一次               
  653.         }
  654. }
复制代码


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:968021 发表于 2023-2-20 23:36 | 只看该作者
实测有用
回复

使用道具 举报

板凳
ID:433219 发表于 2023-12-6 15:06 | 只看该作者
指纹打卡，，，
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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