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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › STC12单片机+AS608指纹打卡系统源程序分享
返回列表 发新帖
查看: 2825|回复: 2
收起左侧

STC12单片机+AS608指纹打卡系统源程序分享

[复制链接]
ID:906199 发表于 2021-5-6 02:18 | 显示全部楼层 |阅读模式
基于51单片机的指纹打卡系统，
有增加，修改，删除的功能。
可以用于STC12C5A60S2的增强型芯片。
附加oled显示，oled使用IIC通信方式。
可以在oled上直接观察指纹用户的相关信息。
指纹模块采用AS608，如果有大佬有更好的方案，也可以一起交流。
当然如果有FPM10A模块的，也可以一起交流学习。

单片机源程序如下:
  1. #ifndef __AS608_H
  2. #define __AS608_H
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include "UART2.h"
  6. //#include "oled.h"
  7. #include "KEY.h"

  9. #define uchar unsigned char
  10. #define uint unsigned int
  11. #define ulong unsigned long


  14. #define CharBuffer1 0x01
  15. #define CharBuffer2 0x02
  16. uint CuoWu,jiaoyanwei;
  17. ulong AS608Addr = 0XFFFFFFFF; //默认模块地址

  19. char str2[6]={0};

  21. typedef struct  
  22. {
  23.         uint pageID;//指纹ID
  24.         uint mathscore;//匹配得分
  25. }SearchResult;

  27. typedef struct
  28. {
  29.         uint PS_max;//指纹最大容量
  30.         uchar  PS_level;//安全等级
  31.         ulong PS_addr;
  32.         uchar  PS_size;//通讯数据包大小
  33.         uchar  PS_N;//波特率基数N
  34. }SysPara;

  36. const char *EnsureMessage(uchar ensure);

  38. //发送包头
  39. static void SendHead(void)
  40. {
  41.         UART2_SendData(0xEF);
  42.         UART2_SendData(0x01);
  43. }
  44. //发送地址
  45. static void SendAddr(void)
  46. {
  47.         UART2_SendData(AS608Addr>>24);
  48.         UART2_SendData(AS608Addr>>16);
  49.         UART2_SendData(AS608Addr>>8);
  50.         UART2_SendData(AS608Addr);
  51. }
  52. //发送包标识,
  53. static void SendFlag(uchar flag)
  54. {
  55.         UART2_SendData(flag);
  56. }
  57. //发送包长度
  58. static void SendLength(int length)
  59. {
  60.         UART2_SendData(length>>8);
  61.         UART2_SendData(length);
  62. }
  63. //发送指令码
  64. static void Sendcmd(uchar cmd)
  65. {
  66.         UART2_SendData(cmd);
  67. }
  68. //发送校验和
  69. static void SendCheck(uint check)
  70. {
  71.         UART2_SendData(check>>8);
  72.         UART2_SendData(check);
  73. }

  75. //判断中断接收的数组有没有应答包
  76. //waittime为等待中断接收数据的时间（单位1ms）
  77. //返回值：数据包首地址
  78. static uchar *JudgeStr(uint waittime)
  79. {
  80. //        uint temp;
  81.         char *rdata;
  82.         uchar str[8];
  83.         str[0]=0xef;str[1]=0x01;str[2]=AS608Addr>>24;
  84.         str[3]=AS608Addr>>16;str[4]=AS608Addr>>8;
  85.         str[5]=AS608Addr;str[6]=0x07;str[7]='\0';   
  86.         UART2_RX_STA=0;
  87.         while(--waittime)
  88.         {
  89.                 Delay_Ms(1);
  90.                 if(UART2_RX_STA&0X8000)//接收到一次数据
  91.                 {
  92.                         UART2_RX_STA=0;
  93.                         rdata=strstr((const char*)UART2_RX_BUF,(const char*)str);
  94.                         if(rdata)
  95.                                 return (uchar*)rdata;        
  96.                 }               
  97.         }
  98.         return 0;
  99. }

  101. //录入图像 PS_GetImage
  102. //功能:探测手指，探测到后录入指纹图像存于ImageBuffer。
  103. //模块返回确认字
  104. uchar PS_GetImage(void)
  105. {
  106.   uint temp;
  107.   uchar  ensure;
  108.         uchar  *rdata;
  109.         SendHead();
  110.         SendAddr();
  111.         SendFlag(0x01);//命令包标识
  112.         SendLength(0x03);
  113.         Sendcmd(0x01);
  114.   temp =  0x01+0x03+0x01;
  115.         SendCheck(temp);
  116.         rdata=JudgeStr(2000);
  117.         if(rdata)
  118.                 ensure=rdata[9];
  119.         else
  120.                 ensure=0xff;
  121.         return ensure;
  122. }

  124. //生成特征 PS_GenChar
  125. //功能:将ImageBuffer中的原始图像生成指纹特征文件存于CharBuffer1或CharBuffer2                        
  126. //参数:BufferID --> charBuffer1:0x01        charBuffer1:0x02                                                                                                
  127. //模块返回确认字
  128. uchar PS_GenChar(uchar BufferID)
  129. {
  130.         uint temp;
  131.   uchar  ensure;
  132.         uchar  *rdata;
  133.         SendHead();
  134.         SendAddr();
  135.         SendFlag(0x01);//命令包标识
  136.         SendLength(0x04);
  137.         Sendcmd(0x02);
  138.         UART2_SendData(BufferID);
  139.         temp = 0x01+0x04+0x02+BufferID;
  140.         SendCheck(temp);
  141.         rdata=JudgeStr(2000);
  142.         if(rdata)
  143.                 ensure=rdata[9];
  144.         else
  145.                 ensure=0xff;
  146.         return ensure;
  147. }

  149. //精确比对两枚指纹特征 PS_Match
  150. //功能:精确比对CharBuffer1 与CharBuffer2 中的特征文件
  151. //模块返回确认字
  152. uchar PS_Match(void)
  153. {
  154.         uint temp;
  155.   uchar  ensure;
  156.         uchar  *rdata;
  157.         SendHead();
  158.         SendAddr();
  159.         SendFlag(0x01);//命令包标识
  160.         SendLength(0x03);
  161.         Sendcmd(0x03);
  162.         temp = 0x01+0x03+0x03;
  163.         SendCheck(temp);
  164.         rdata=JudgeStr(2000);
  165.         if(rdata)
  166.                 ensure=rdata[9];
  167.         else
  168.                 ensure=0xff;
  169.         return ensure;
  170. }

  172. //搜索指纹 PS_Search
  173. //功能:以CharBuffer1或CharBuffer2中的特征文件搜索整个或部分指纹库.若搜索到，则返回页码。                        
  174. //参数:  BufferID @ref CharBuffer1        CharBuffer2
  175. //说明:  模块返回确认字，页码（相配指纹模板）
  176. //uchar PS_Search(uchar BufferID,uint StartPage,uint PageNum,SearchResult *p)
  177. //{
  178. //        uint temp;
  179. //  uchar  ensure;
  180. //        uchar  *rdata;
  181. //        memset(UART2_RX_BUF,'\0',sizeof(UART2_RX_BUF));
  182. //        UART2_RX_STA=0;
  183. //        SendHead();
  184. //        SendAddr();
  185. //        SendFlag(0x01);//命令包标识
  186. //        SendLength(0x08);
  187. //        Sendcmd(0x04);
  188. //        UART2_SendData(BufferID);
  189. //        UART2_SendData(StartPage>>8);
  190. //        UART2_SendData(StartPage);
  191. //        UART2_SendData(PageNum>>8);
  192. //        UART2_SendData(PageNum);
  193. //        temp = 0x01+0x08+0x04+BufferID
  194. //        +(StartPage>>8)+(uchar)StartPage
  195. //        +(PageNum>>8)+(uchar)PageNum;
  196. //        SendCheck(temp);
  197. //        Delay_Ms(100);
  198. //        rdata=JudgeStr(2000);
  199. //        if(rdata)
  200. //        {
  201. //                ensure = rdata[9];
  202. //                p->pageID   =(rdata[10]<<8)+rdata[11];
  203. //                p->mathscore=(rdata[12]<<8)+rdata[13];        
  204. //        }
  205. //        else
  206. //                ensure = 0xff;
  207. //        return ensure;        
  208. //}

  210. //合并特征（生成模板）PS_RegModel
  211. //功能:将CharBuffer1与CharBuffer2中的特征文件合并生成 模板,结果存于CharBuffer1与CharBuffer2        
  212. //说明:  模块返回确认字
  213. uchar PS_RegModel(void)
  214. {
  215.         uint temp;
  216.   uchar  ensure;
  217.         uchar  *rdata;
  218.         SendHead();
  219.         SendAddr();
  220.         SendFlag(0x01);//命令包标识
  221.         SendLength(0x03);
  222.         Sendcmd(0x05);
  223.         temp = 0x01+0x03+0x05;
  224.         SendCheck(temp);
  225.         rdata=JudgeStr(2000);
  226.         if(rdata)
  227.                 ensure=rdata[9];
  228.         else
  229.                 ensure=0xff;
  230.         return ensure;               
  231. }
  232. //储存模板 PS_StoreChar
  233. //功能:将 CharBuffer1 或 CharBuffer2 中的模板文件存到 PageID 号flash数据库位置。                        
  234. //参数:  BufferID @ref charBuffer1:0x01        charBuffer1:0x02
  235. //       PageID（指纹库位置号）
  236. //说明:  模块返回确认字
  237. uchar PS_StoreChar(uchar BufferID,uint PageID)
  238. {
  239.         uint temp;
  240.   uchar  ensure;
  241.         uchar  *rdata;
  242.         SendHead();
  243.         SendAddr();
  244.         SendFlag(0x01);//命令包标识
  245.         SendLength(0x06);
  246.         Sendcmd(0x06);
  247.         UART2_SendData(BufferID);
  248.         UART2_SendData(PageID>>8);
  249.         UART2_SendData(PageID);
  250.         temp = 0x01+0x06+0x06+BufferID
  251.         +(PageID>>8)+(uchar)PageID;
  252.         SendCheck(temp);
  253.         rdata=JudgeStr(2000);
  254.         if(rdata)
  255.                 ensure=rdata[9];
  256.         else
  257.                 ensure=0xff;
  258.         return ensure;        
  259. }
  260. //删除模板 PS_DeletChar
  261. //功能:  删除flash数据库中指定ID号开始的N个指纹模板
  262. //参数:  PageID(指纹库模板号)，N删除的模板个数。
  263. //说明:  模块返回确认字
  264. uchar PS_DeletChar(uint PageID,uint N)
  265. {
  266.         uint temp;
  267.   uchar  ensure;
  268.         uchar  *rdata;
  269.         SendHead();
  270.         SendAddr();
  271.         SendFlag(0x01);//命令包标识
  272.         SendLength(0x07);
  273.         Sendcmd(0x0C);
  274.         UART2_SendData(PageID>>8);
  275.         UART2_SendData(PageID);
  276.         UART2_SendData(N>>8);
  277.         UART2_SendData(N);
  278.         temp = 0x01+0x07+0x0C
  279.         +(PageID>>8)+(uchar)PageID
  280.         +(N>>8)+(uchar)N;
  281.         SendCheck(temp);
  282.         rdata=JudgeStr(2000);
  283.         if(rdata)
  284.                 ensure=rdata[9];
  285.         else
  286.                 ensure=0xff;
  287.         return ensure;
  288. }
  289. //清空指纹库 PS_Empty
  290. //功能:  删除flash数据库中所有指纹模板
  291. //参数:  无
  292. //说明:  模块返回确认字
  293. uchar PS_Empty(void)
  294. {
  295.         uint temp;
  296.   uchar  ensure;
  297.         uchar  *rdata;
  298.         SendHead();
  299.         SendAddr();
  300.         SendFlag(0x01);//命令包标识
  301.         SendLength(0x03);
  302.         Sendcmd(0x0D);
  303.         temp = 0x01+0x03+0x0D;
  304.         SendCheck(temp);
  305.         rdata=JudgeStr(2000);
  306.         if(rdata)
  307.                 ensure=rdata[9];
  308.         else
  309.                 ensure=0xff;
  310.         return ensure;
  311. }

  313. //写系统寄存器 PS_WriteReg
  314. //功能:  写模块寄存器
  315. //参数:  寄存器序号RegNum:4\5\6
  316. //说明:  模块返回确认字
  317. //uchar PS_WriteReg(uchar RegNum,uchar DATA)
  318. //{
  319. //        uint temp;
  320. //  uchar  ensure;
  321. //        uchar  *rdata;
  322. //        SendHead();
  323. //        SendAddr();
  324. //        SendFlag(0x01);//命令包标识
  325. //        SendLength(0x05);
  326. //        Sendcmd(0x0E);
  327. //        UART2_SendData(RegNum);
  328. //        UART2_SendData(DATA);
  329. //        temp = RegNum+DATA+0x01+0x05+0x0E;
  330. //        SendCheck(temp);
  331. //        Delay_Ms(100);
  332. //        rdata=JudgeStr(2000);
  333. //        if(rdata)
  334. //                ensure=rdata[9];
  335. //        else
  336. //                ensure=0xff;
  337. //        if(ensure==0)
  338. //                printf("\r\n设置参数成功！");
  339. //        else
  340. //                printf("\r\n%s",EnsureMessage(ensure));
  341. //        return ensure;
  342. //}
  343. //读系统基本参数 PS_ReadSysPara
  344. //功能:  读取模块的基本参数（波特率，包大小等)
  345. //参数:  无
  346. //说明:  模块返回确认字 + 基本参数（16bytes）
  347. //uchar PS_ReadSysPara(SysPara *p)
  348. //{
  349. //        uint temp;
  350. //  uchar  ensure;
  351. //        uchar  *rdata;
  352. //        SendHead();
  353. //        SendAddr();
  354. //        SendFlag(0x01);//命令包标识
  355. //        SendLength(0x03);
  356. //        Sendcmd(0x0F);
  357. //        temp = 0x01+0x03+0x0F;
  358. //        SendCheck(temp);
  359. //        Delay_Ms(100);
  360. //        rdata=JudgeStr(1000);
  361. //        if(rdata)
  362. //        {
  363. //                ensure = rdata[9];
  364. //                p->PS_max = (rdata[14]<<8)+rdata[15];
  365. //                p->PS_level = rdata[17];
  366. //                p->PS_addr=(rdata[18]<<24)+(rdata[19]<<16)+(rdata[20]<<8)+rdata[21];
  367. //                p->PS_size = rdata[23];
  368. //                p->PS_N = rdata[25];
  369. //        }               
  370. //        else
  371. //                ensure=0xff;
  372. //        if(ensure==0x00)
  373. //        {
  374. //                printf("\r\n模块最大指纹容量=%d",p->PS_max);
  375. //                printf("\r\n对比等级=%d",p->PS_level);
  376. //                printf("\r\n地址=%x",p->PS_addr);
  377. //                printf("\r\n波特率=%d",p->PS_N*9600);
  378. //        }
  379. //        else
  380. //                        printf("\r\n%s",EnsureMessage(ensure));
  381. //        return ensure;
  382. //}
  383. //设置模块地址 PS_SetAddr
  384. //功能:  设置模块地址
  385. //参数:  PS_addr
  386. //说明:  模块返回确认字
  387. //uchar PS_SetAddr(ulong PS_addr)
  388. //{
  389. //        uint temp;
  390. //  uchar  ensure;
  391. //        uchar  *rdata;
  392. //        SendHead();
  393. //        SendAddr();
  394. //        SendFlag(0x01);//命令包标识
  395. //        SendLength(0x07);
  396. //        Sendcmd(0x15);
  397. //        UART2_SendData(PS_addr>>24);
  398. //        UART2_SendData(PS_addr>>16);
  399. //        UART2_SendData(PS_addr>>8);
  400. //        UART2_SendData(PS_addr);
  401. //        temp = 0x01+0x07+0x15
  402. //        +(uchar)(PS_addr>>24)+(uchar)(PS_addr>>16)
  403. //        +(uchar)(PS_addr>>8) +(uchar)PS_addr;                                
  404. //        SendCheck(temp);
  405. //        AS608Addr=PS_addr;//发送完指令，更换地址
  406. //        Delay_Ms(100);
  407. //  rdata=JudgeStr(2000);
  408. //        if(rdata)
  409. //                ensure=rdata[9];
  410. //        else
  411. //                ensure=0xff;        
  412. //                AS608Addr = PS_addr;
  413. //        if(ensure==0x00)
  414. //                printf("\r\n设置地址成功！");
  415. //        else
  416. //                printf("\r\n%s",EnsureMessage(ensure));
  417. //        return ensure;
  418. //}

  420. //高速搜索PS_HighSpeedSearch
  421. //功能：以 CharBuffer1或CharBuffer2中的特征文件高速搜索整个或部分指纹库。
  422. //                  若搜索到，则返回页码,该指令对于的确存在于指纹库中 ，且登录时质量
  423. //                  很好的指纹，会很快给出搜索结果。
  424. //参数:  BufferID， StartPage(起始页)，PageNum（页数）
  425. //说明:  模块返回确认字+页码（相配指纹模板）
  426. uchar PS_HighSpeedSearch(uchar BufferID,uint StartPage,uint PageNum,SearchResult *p)
  427. {
  428.         uint temp;
  429.   uint  ensure;
  430.         uchar  *rdata;
  431.         SendHead();
  432.         SendAddr();
  433.         SendFlag(0x01);//命令包标识
  434.         SendLength(0x08);
  435.         Sendcmd(0x1b);
  436.         UART2_SendData(BufferID);
  437.         UART2_SendData(StartPage>>8);
  438.         UART2_SendData(StartPage);
  439.         UART2_SendData(PageNum>>8);
  440.         UART2_SendData(PageNum);
  441.         temp = 0x01+0x08+0x1b+BufferID
  442.         +(StartPage>>8)+(uchar)StartPage
  443.         +(PageNum>>8)+(uchar)PageNum;
  444.         SendCheck(temp);
  445.         rdata=JudgeStr(2000);
  446.          if(rdata)
  447.         {
  448.                 ensure=rdata[9];
  449.                 p->pageID         =   (uint)(rdata[10]<<8) +rdata[11];
  450.                 p->mathscore=                (uint)(rdata[12]<<8) +rdata[13];
  451.         }
  452.         else
  453.                 ensure=0xff;
  454.         return ensure;
  455. }
  456. //读有效模板个数 PS_ValidTempleteNum
  457. //功能：读有效模板个数
  458. //参数: 无
  459. //说明: 模块返回确认字+有效模板个数ValidN
  460. //uchar PS_ValidTempleteNum(uint *ValidN)
  461. //{
  462. //        uint temp;
  463. //  uchar  ensure;
  464. //        uchar  *rdata;
  465. //        SendHead();
  466. //        SendAddr();
  467. //        SendFlag(0x01);//命令包标识
  468. //        SendLength(0x03);
  469. //        Sendcmd(0x1d);
  470. //        temp = 0x01+0x03+0x1d;
  471. //        SendCheck(temp);
  472. //  rdata=JudgeStr(2000);
  473. //        if(rdata)
  474. //        {
  475. //                ensure=rdata[9];
  476. //                *ValidN = (rdata[10]<<8) +rdata[11];
  477. //        }               
  478. //        else
  479. //                ensure=0xff;
  480. //        
  481. //        if(ensure==0x00)
  482. //        {
  483. //                printf("\r\n有效指纹个数=%d",(rdata[10]<<8)+rdata[11]);
  484. //        }
  485. //        else
  486. //                printf("\r\n%s",EnsureMessage(ensure));
  487. //        return ensure;
  488. //}
  489. //与AS608握手 PS_HandShake
  490. //参数: PS_Addr地址指针
  491. //说明: 模块返新地址（正确地址）        
  492. //uchar PS_HandShake(ulong *PS_Addr)
  493. //{
  494. //        SendHead();
  495. //        SendAddr();
  496. //        UART2_SendData(0X01);
  497. //        UART2_SendData(0X00);
  498. //        UART2_SendData(0X00);        
  499. //        Delay_Ms(200);        
  500. //        if(        UART2_RX_BUF[0]==0XEF && UART2_RX_BUF[1]==0X01 && UART2_RX_BUF[6]==0X07)//判断是不是模块返回的应答包        
  501. //                {
  502. //                        *PS_Addr=(UART2_RX_BUF[2]<<24) + (UART2_RX_BUF[3]<<16)
  503. //                                                        +(UART2_RX_BUF[4]<<8) + (UART2_RX_BUF[5]);
  504. //                        UART2_RX_STA=0;
  505. //                        return 0;
  506. //                }
  507. //        UART2_RX_STA=0;                                       
  508. //        return 1;               
  509. //}
  510. //模块应答包确认码信息解析
  511. //功能：解析确认码错误信息返回信息
  512. //参数: ensure
  513. const char *EnsureMessage(uchar ensure)
  514. {
  515.         const char *p;
  516.         switch(ensure)
  517.         {
  518.                 case  0x00:
  519.                         p="       OK       ";break;               
  520.                 case  0x01:
  521.                         p=" 数据包接收错误 ";break;
  522.                 case  0x02:
  523.                         p="传感器上没有手指";break;
  524.                 case  0x03:
  525.                         p="录入指纹图像失败";break;
  526.                 case  0x04:
  527.                         p=" 指纹太干或太淡 ";break;
  528.                 case  0x05:
  529.                         p=" 指纹太湿或太糊 ";break;
  530.                 case  0x06:
  531.                         p="  指纹图像太乱  ";break;
  532.                 case  0x07:
  533.                         p=" 指纹特征点太少 ";break;
  534.                 case  0x08:
  535.                         p="   指纹不匹配   ";break;
  536.                 case  0x09:
  537.                         p=" 没有搜索到指纹 ";break;
  538.                 case  0x0a:
  539.                         p="   特征合并失败 ";break;
  540.                 case  0x0b:
  541.                         p="地址序号超出范围";
  542.                 case  0x10:
  543.                         p="  删除模板失败  ";break;
  544.                 case  0x11:
  545.                         p=" 清空指纹库失败 ";break;        
  546.                 case  0x15:
  547.                         p="缓冲区内无有效图";break;
  548.                 case  0x18:
  549.                         p=" 读写FLASH出错  ";break;
  550.                 case  0x19:
  551.                         p="   未定义错误   ";break;
  552.                 case  0x1a:
  553.                         p="  无效寄存器号  ";break;
  554.                 case  0x1b:
  555.                         p=" 寄存器内容错误 ";break;
  556.                 case  0x1c:
  557.                         p=" 记事本页码错误 ";break;
  558.                 case  0x1f:
  559.                         p="    指纹库满    ";break;
  560.                 case  0x20:
  561.                         p="    地址错误    ";break;
  562.                 default :
  563.                         p=" 返回确认码有误 ";break;
  564.         }
  565. return p;        
  566. }

  568. //显示确认码错误信息
  569. void ShowErrMessage(uchar ensure)
  570. {
  571.         EnsureMessage(ensure);
  572. }

  574. //录指纹
  575. void Add_FR(void)
  576. {
  577.         uchar i,ensure ,processnum=0;
  578.         uint ID_NUM=0;
  579.         while(1)
  580.         {
  581.                 switch (processnum)
  582.                 {
  583.                         case 0:
  584.                                 i++;
  585.                                 OLED_ShowCH(0,2,"    请按手指    ");
  586.                                 ensure=PS_GetImage();
  587.                                 if(ensure==0x00)
  588.                                 {
  589.                                         ensure=PS_GenChar(CharBuffer1);//生成特征
  590.                                         if(ensure==0x00)
  591.                                         {
  592.                                                 Delay_Ms(1);
  593.                                                 OLED_ShowCH(0,2,"    指纹正常    ");
  594.                                                 OLED_ShowCH(0,4,"                ");
  595.                                                 Delay_Ms(100);
  596.                                                 i=0;
  597.                                                 processnum=1;//跳到第二步                                                
  598.                                         }else {};                                
  599.                                 }else {};                                                
  600.                                 break;
  601.                         
  602.                         case 1:
  603.                                 i++;
  604.                                 OLED_ShowCH(0,2,"   请再按一次   ");
  605.                                 OLED_ShowCH(0,4,"                ");
  606.                                 Delay_Ms(100);
  607.                                 ensure=PS_GetImage();
  608.                                 if(ensure==0x00)
  609.                                 {
  610.                                         ensure=PS_GenChar(CharBuffer2);//生成特征
  611.                                         if(ensure==0x00)
  612.                                         {
  613.                                                 Delay_Ms(1);
  614.                                                 OLED_ShowCH(0,2,"    指纹正常    ");
  615.                                                 OLED_ShowCH(0,4,"                ");
  616.                                                 Delay_Ms(100);
  617.                                                 i=0;
  618.                                                 processnum=2;//跳到第三步
  619.                                         }else {};        
  620.                                 }else {};               
  621.                                 break;

  623.                         case 2:
  624.                                 OLED_ShowCH(0,2,"  对比两次指纹  ");
  625.                                 OLED_ShowCH(0,4,"                ");
  626.                                 ensure=PS_Match();
  627.                                 if(ensure==0x00)
  628.                                 {
  629.                                         OLED_ShowCH(0,2,"    对比成功    ");
  630.                                         OLED_ShowCH(0,4,"                ");
  631.                                         processnum=3;//跳到第四步
  632.                                 }
  633.                                 else
  634.                                 {                                       
  635.                                         OLED_ShowCH(0,2,"    对比失败    ");
  636.                                         OLED_ShowCH(0,4,"                ");
  637.                                         ShowErrMessage(ensure);
  638.                                         i=0;
  639.                                         processnum=0;//跳回第一步               
  640.                                 }
  641.                                 Delay_Ms(500);
  642.                                 break;

  644.                         case 3:
  645.                                 OLED_ShowCH(0,2,"  生成指纹模板  ");
  646.                                 OLED_ShowCH(0,4,"                ");
  647.                                 Delay_Ms(500);
  648.                                 ensure=PS_RegModel();
  649.                                 if(ensure==0x00)
  650.                                 {
  651.                                         OLED_ShowCH(0,2,"生成指纹模板成功");
  652.                                         OLED_ShowCH(0,4,"                ");
  653.                                         processnum=4;//跳到第五步
  654.                                 }else {processnum=0;}
  655.                                 Delay_Ms(1000);
  656.                                 break;
  657.                                 
  658.                         case 4:        
  659.                                 OLED_ShowCH(0,0," 按K4加,按K2减 ");
  660.                                 OLED_ShowCH(0,2,"    按K3保存    ");
  661.                                 OLED_ShowCH(0,4,"  0=< ID <=99   ");
  662.                           ID_NUM=0;
  663.                                 while(key_num!=3)
  664.                                 {
  665.                                         key_num=KEY_Scan(0);
  666.                                         if(key_num==2)
  667.                                         {
  668.                                                 key_num=0;
  669.                                                 if(ID_NUM>0)
  670.                                                         ID_NUM--;
  671.                                         }
  672.                                         if(key_num==4)
  673.                                         {
  674.                                                 key_num=0;
  675.                                                 if(ID_NUM<99)
  676.                                                         ID_NUM++;
  677.                                         }
  678.                                         OLED_ShowCH(40,6,"ID=");
  679.                                         OLED_ShowNum(65,6,ID_NUM,2,1);
  680.                                 }
  681.                                 key_num=0;
  682.                                 ensure=PS_StoreChar(CharBuffer2,ID_NUM);//储存模板
  683.                                 if(ensure==0x00)
  684.                                 {               
  685.                                         OLED_Clear();
  686.                                         OLED_ShowCH(0,2,"  录入指纹成功  ");
  687.                                         OLED_ShowCH(0,4,"                ");
  688.                                         Delay_Ms(1500);
  689.                                         OLED_Clear();
  690.                                         OLED_ShowCH(0,0,"指纹模块测试程序");
  691.                                         OLED_ShowCH(16,2,"K1键添加指纹");
  692.                                         OLED_ShowCH(16,4,"K3键删除指纹");
  693.                                         OLED_ShowCH(16,6,"K5键验证指纹");
  694.                                         return ;
  695.                                 }else {OLED_Clear();processnum=0;}                                       
  696.                                 break;                                
  697.                 }
  698.                 Delay_Ms(400);
  699.                 if(i==10)//超过5次没有按手指则退出
  700.                 {
  701.                         OLED_Clear();
  702.                         break;        
  703.                 }
  704.         }               
  705. }

  707. SysPara AS608Para;//指纹模块AS608参数
  708. //刷指纹
  709. void press_FR(void)
  710. {
  711.         SearchResult seach;
  712.         uchar ensure;
  713.         char str[20];
  714.         while(key_num!=1)
  715.         {
  716.                 key_num=KEY_Scan(0);
  717.                 ensure=PS_GetImage();
  718.                 if(ensure==0x00)//获取图像成功
  719.                 {        
  720.                         ensure=PS_GenChar(CharBuffer1);
  721.                         if(ensure==0x00) //生成特征成功
  722.                         {                        
  723.                                 ensure=PS_HighSpeedSearch(CharBuffer1,0,99,&seach);
  724.                                 if(ensure==0x00)//搜索成功
  725.                                 {                                
  726.                                         OLED_ShowCH(0,2,"  指纹验证成功  ");                                
  727.                                         sprintf(str," ID:%d 得分:%d ",seach.pageID,seach.mathscore);
  728.                                         OLED_ShowCH(0,4,(u8*)str);
  729.                                         Delay_Ms(3000);
  730.                                 }
  731.                                 if(ensure==0x09)
  732.                                 {
  733.                                         OLED_ShowCH(32,2,"验证失败");
  734.                                         Delay_Ms(1500);
  735.                                 }               
  736.                         }
  737.                         else
  738.                                 {};
  739.                         OLED_Clear();
  740.                         OLED_ShowCH(32,2,"请按手指");
  741.                 }
  742.         }        
  743.         OLED_Clear();
  744.         OLED_ShowCH(0,0,"指纹模块测试程序");
  745.         OLED_ShowCH(16,2,"K1键添加指纹");
  746.         OLED_ShowCH(16,4,"K3键删除指纹");
  747.         OLED_ShowCH(16,6,"K5键验证指纹");
  748. }

  750. //删除指纹
  751. void Del_FR(void)
  752. {
  753.         uchar  ensure;
  754.         uint ID_NUM=0;
  755.         OLED_ShowCH(0,0,"K4加 K2减 K3确认");
  756.         OLED_ShowCH(0,2,"  K5清空指纹库  ");
  757.         OLED_ShowCH(0,4,"K1返回 0=<ID<=99");
  758.         while(key_num!=3)
  759.         {
  760.                 key_num=KEY_Scan(0);
  761.                 if(key_num==2)
  762.                 {
  763.                         key_num=0;
  764.                         if(ID_NUM>0)
  765.                                 ID_NUM--;
  766.                 }
  767.                 if(key_num==4)
  768.                 {
  769.                         key_num=0;
  770.                         if(ID_NUM<99)
  771.                                 ID_NUM++;
  772.                 }
  773.                 if(key_num==1)
  774.                         goto MENU ; //返回主页面
  775.                 if(key_num==5)
  776.                 {
  777.                         key_num=0;
  778.                         ensure=PS_Empty();//清空指纹库
  779.                         if(ensure==0)
  780.                         {
  781.                                 OLED_Clear();
  782.                                 OLED_ShowCH(0,2," 清空指纹库成功 ");               
  783.                         }
  784.                         else
  785.                                 {};
  786.                         Delay_Ms(1500);
  787.                         goto MENU ; //返回主页面
  788.                 }               
  789.                 OLED_ShowCH(40,6,"ID=");
  790.                 OLED_ShowNum(65,6,ID_NUM,2,1);
  791.         }
  792.         ensure=PS_DeletChar(ID_NUM,1);//删除单个指纹
  793.         if(ensure==0)
  794.         {
  795.                 OLED_Clear();
  796.                 OLED_ShowCH(0,2,"  删除指纹成功  ");               
  797.         }
  798.   else
  799.                 {};        
  800.         Delay_Ms(1500);
  801. MENU:        
  802.         OLED_Clear();
  803.         OLED_ShowCH(0,0,"指纹模块测试程序");
  804.         OLED_ShowCH(16,2,"K1键添加指纹");
  805.         OLED_ShowCH(16,4,"K3键删除指纹");
  806.         OLED_ShowCH(16,6,"K5键验证指纹");
  807.         key_num=0;
  808. }

  810. #endif
复制代码
51hei.png

全部资料51hei下载地址：
STC12C5A60S2指纹模块程序.rar (114.97 KB, 下载次数: 53)

评分

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

查看全部评分

回复

使用道具 举报

ID:245302 发表于 2021-5-14 14:40 | 显示全部楼层
怎么把串口2改成串口1
回复

使用道具 举报

ID:99490 发表于 2021-6-10 15:52 | 显示全部楼层
有原理图可以参考吗？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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