STC12C5A60S2 51单片机+AS608指纹打卡系统源程序

[复制链接]
查看0 | 回复0 | 2021-5-6 13:04:54 | 显示全部楼层 |阅读模式
基于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"

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


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

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

  16. typedef struct  
  17. {
  18.         uint pageID;//指纹ID
  19.         uint mathscore;//匹配得分
  20. }SearchResult;

  21. typedef struct
  22. {
  23.         uint PS_max;//指纹最大容量
  24.         uchar  PS_level;//安全等级
  25.         ulong PS_addr;
  26.         uchar  PS_size;//通讯数据包大小
  27.         uchar  PS_N;//波特率基数N
  28. }SysPara;

  29. const char *EnsureMessage(uchar ensure);

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

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

  91. //录入图像 PS_GetImage
  92. //功能:探测手指,探测到后录入指纹图像存于ImageBuffer。
  93. //模块返回确认字
  94. uchar PS_GetImage(void)
  95. {
  96.   uint temp;
  97.   uchar  ensure;
  98.         uchar  *rdata;
  99.         SendHead();
  100.         SendAddr();
  101.         SendFlag(0x01);//命令包标识
  102.         SendLength(0x03);
  103.         Sendcmd(0x01);
  104.   temp =  0x01+0x03+0x01;
  105.         SendCheck(temp);
  106.         rdata=JudgeStr(2000);
  107.         if(rdata)
  108.                 ensure=rdata[9];
  109.         else
  110.                 ensure=0xff;
  111.         return ensure;
  112. }

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

  137. //精确比对两枚指纹特征 PS_Match
  138. //功能:精确比对CharBuffer1 与CharBuffer2 中的特征文件
  139. //模块返回确认字
  140. uchar PS_Match(void)
  141. {
  142.         uint temp;
  143.   uchar  ensure;
  144.         uchar  *rdata;
  145.         SendHead();
  146.         SendAddr();
  147.         SendFlag(0x01);//命令包标识
  148.         SendLength(0x03);
  149.         Sendcmd(0x03);
  150.         temp = 0x01+0x03+0x03;
  151.         SendCheck(temp);
  152.         rdata=JudgeStr(2000);
  153.         if(rdata)
  154.                 ensure=rdata[9];
  155.         else
  156.                 ensure=0xff;
  157.         return ensure;
  158. }

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

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

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

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

  551. //显示确认码错误信息
  552. void ShowErrMessage(uchar ensure)
  553. {
  554.         EnsureMessage(ensure);
  555. }

  556. //录指纹
  557. void Add_FR(void)
  558. {
  559.         uchar i,ensure ,processnum=0;
  560.         uint ID_NUM=0;
  561.         while(1)
  562.         {
  563.                 switch (processnum)
  564.                 {
  565.                         case 0:
  566.                                 i++;
  567.                                 OLED_ShowCH(0,2,"    请按手指    ");
  568.                                 ensure=PS_GetImage();
  569.                                 if(ensure==0x00)
  570.                                 {
  571.                                         ensure=PS_GenChar(CharBuffer1);//生成特征
  572.                                         if(ensure==0x00)
  573.                                         {
  574.                                                 Delay_Ms(1);
  575.                                                 OLED_ShowCH(0,2,"    指纹正常    ");
  576.                                                 OLED_ShowCH(0,4,"                ");
  577.                                                 Delay_Ms(100);
  578.                                                 i=0;
  579.                                                 processnum=1;//跳到第二步                                                
  580.                                         }else {};                                
  581.                                 }else {};                                                
  582.                                 break;
  583.                         
  584.                         case 1:
  585.                                 i++;
  586.                                 OLED_ShowCH(0,2,"   请再按一次   ");
  587.                                 OLED_ShowCH(0,4,"                ");
  588.                                 Delay_Ms(100);
  589.                                 ensure=PS_GetImage();
  590.                                 if(ensure==0x00)
  591.                                 {
  592.                                         ensure=PS_GenChar(CharBuffer2);//生成特征
  593.                                         if(ensure==0x00)
  594.                                         {
  595.                                                 Delay_Ms(1);
  596.                                                 OLED_ShowCH(0,2,"    指纹正常    ");
  597.                                                 OLED_ShowCH(0,4,"                ");
  598.                                                 Delay_Ms(100);
  599.                                                 i=0;
  600.                                                 processnum=2;//跳到第三步
  601.                                         }else {};        
  602.                                 }else {};               
  603.                                 break;

  604.                         case 2:
  605.                                 OLED_ShowCH(0,2,"  对比两次指纹  ");
  606.                                 OLED_ShowCH(0,4,"                ");
  607.                                 ensure=PS_Match();
  608.                                 if(ensure==0x00)
  609.                                 {
  610.                                         OLED_ShowCH(0,2,"    对比成功    ");
  611.                                         OLED_ShowCH(0,4,"                ");
  612.                                         processnum=3;//跳到第四步
  613.                                 }
  614.                                 else
  615.                                 {                                       
  616.                                         OLED_ShowCH(0,2,"    对比失败    ");
  617.                                         OLED_ShowCH(0,4,"                ");
  618.                                         ShowErrMessage(ensure);
  619.                                         i=0;
  620.                                         processnum=0;//跳回第一步               
  621.                                 }
  622.                                 Delay_Ms(500);
  623.                                 break;

  624.                         case 3:
  625.                                 OLED_ShowCH(0,2,"  生成指纹模板  ");
  626.                                 OLED_ShowCH(0,4,"                ");
  627.                                 Delay_Ms(500);
  628.                                 ensure=PS_RegModel();
  629.                                 if(ensure==0x00)
  630.                                 {
  631.                                         OLED_ShowCH(0,2,"生成指纹模板成功");
  632.                                         OLED_ShowCH(0,4,"                ");
  633.                                         processnum=4;//跳到第五步
  634.                                 }else {processnum=0;}
  635.                                 Delay_Ms(1000);
  636.                                 break;
  637.                                 
  638.                         case 4:        
  639.                                 OLED_ShowCH(0,0," 按K4加,按K2减 ");
  640.                                 OLED_ShowCH(0,2,"    按K3保存    ");
  641.                                 OLED_ShowCH(0,4,"  0=< ID <=99   ");
  642.                           ID_NUM=0;
  643.                                 while(key_num!=3)
  644.                                 {
  645.                                         key_num=KEY_Scan(0);
  646.                                         if(key_num==2)
  647.                                         {
  648.                                                 key_num=0;
  649.                                                 if(ID_NUM>0)
  650.                                                         ID_NUM--;
  651.                                         }
  652.                                         if(key_num==4)
  653.                                         {
  654.                                                 key_num=0;
  655.                                                 if(ID_NUM<99)
  656.                                                         ID_NUM++;
  657.                                         }
  658.                                         OLED_ShowCH(40,6,"ID=");
  659.                                         OLED_ShowNum(65,6,ID_NUM,2,1);
  660.                                 }
  661.                                 key_num=0;
  662.                                 ensure=PS_StoreChar(CharBuffer2,ID_NUM);//储存模板
  663.                                 if(ensure==0x00)
  664.                                 {               
  665.                                         OLED_Clear();
  666.                                         OLED_ShowCH(0,2,"  录入指纹成功  ");
  667.                                         OLED_ShowCH(0,4,"                ");
  668.                                         Delay_Ms(1500);
  669.                                         OLED_Clear();
  670.                                         OLED_ShowCH(0,0,"指纹模块测试程序");
  671.                                         OLED_ShowCH(16,2,"K1键添加指纹");
  672.                                         OLED_ShowCH(16,4,"K3键删除指纹");
  673.                                         OLED_ShowCH(16,6,"K5键验证指纹");
  674.                                         return ;
  675.                                 }else {OLED_Clear();processnum=0;}                                       
  676.                                 break;                                
  677.                 }
  678.                 Delay_Ms(400);
  679.                 if(i==10)//超过5次没有按手指则退出
  680.                 {
  681.                         OLED_Clear();
  682.                         break;        
  683.                 }
  684.         }               
  685. }

  686. SysPara AS608Para;//指纹模块AS608参数
  687. //刷指纹
  688. void press_FR(void)
  689. {
  690.         SearchResult seach;
  691.         uchar ensure;
  692.         char str[20];
  693.         while(key_num!=1)
  694.         {
  695.                 key_num=KEY_Scan(0);
  696.                 ensure=PS_GetImage();
  697.                 if(ensure==0x00)//获取图像成功
  698.                 {        
  699.                         ensure=PS_GenChar(CharBuffer1);
  700.                         if(ensure==0x00) //生成特征成功
  701.                         {                        
  702.                                 ensure=PS_HighSpeedSearch(CharBuffer1,0,99,&seach);
  703.                                 if(ensure==0x00)//搜索成功
  704.                                 {                                
  705.                                         OLED_ShowCH(0,2,"  指纹验证成功  ");                                
  706.                                         sprintf(str," ID:%d 得分:%d ",seach.pageID,seach.mathscore);
  707.                                         OLED_ShowCH(0,4,(u8*)str);
  708.                                         Delay_Ms(3000);
  709.                                 }
  710.                                 if(ensure==0x09)
  711.                                 {
  712.                                         OLED_ShowCH(32,2,"验证失败");
  713.                                         Delay_Ms(1500);
  714.                                 }               
  715.                         }
  716.                         else
  717.                                 {};
  718.                         OLED_Clear();
  719.                         OLED_ShowCH(32,2,"请按手指");
  720.                 }
  721.         }        
  722.         OLED_Clear();
  723.         OLED_ShowCH(0,0,"指纹模块测试程序");
  724.         OLED_ShowCH(16,2,"K1键添加指纹");
  725.         OLED_ShowCH(16,4,"K3键删除指纹");
  726.         OLED_ShowCH(16,6,"K5键验证指纹");
  727. }

  728. //删除指纹
  729. void Del_FR(void)
  730. {
  731.         uchar  ensure;
  732.         uint ID_NUM=0;
  733.         OLED_ShowCH(0,0,"K4加 K2减 K3确认");
  734.         OLED_ShowCH(0,2,"  K5清空指纹库  ");
  735.         OLED_ShowCH(0,4,"K1返回 0=<ID<=99");
  736.         while(key_num!=3)
  737.         {
  738.                 key_num=KEY_Scan(0);
  739.                 if(key_num==2)
  740.                 {
  741.                         key_num=0;
  742.                         if(ID_NUM>0)
  743.                                 ID_NUM--;
  744.                 }
  745.                 if(key_num==4)
  746.                 {
  747.                         key_num=0;
  748.                         if(ID_NUM<99)
  749.                                 ID_NUM++;
  750.                 }
  751.                 if(key_num==1)
  752.                         goto MENU ; //返回主页面
  753.                 if(key_num==5)
  754.                 {
  755.                         key_num=0;
  756.                         ensure=PS_Empty();//清空指纹库
  757.                         if(ensure==0)
  758.                         {
  759.                                 OLED_Clear();
  760.                                 OLED_ShowCH(0,2," 清空指纹库成功 ");               
  761.                         }
  762.                         else
  763.                                 {};
  764.                         Delay_Ms(1500);
  765.                         goto MENU ; //返回主页面
  766.                 }               
  767.                 OLED_ShowCH(40,6,"ID=");
  768.                 OLED_ShowNum(65,6,ID_NUM,2,1);
  769.         }
  770.         ensure=PS_DeletChar(ID_NUM,1);//删除单个指纹
  771.         if(ensure==0)
  772.         {
  773.                 OLED_Clear();
  774.                 OLED_ShowCH(0,2,"  删除指纹成功  ");               
  775.         }
  776.   else
  777.                 {};        
  778.         Delay_Ms(1500);
  779. MENU:        
  780.         OLED_Clear();
  781.         OLED_ShowCH(0,0,"指纹模块测试程序");
  782.         OLED_ShowCH(16,2,"K1键添加指纹");
  783.         OLED_ShowCH(16,4,"K3键删除指纹");
  784.         OLED_ShowCH(16,6,"K5键验证指纹");
  785.         key_num=0;
  786. }

  787. #endif
复制代码
STC12C5A60S2指纹模块程序.rar (114.97 KB, 售价: 2 工控币)

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则