标题: STC12单片机+AS608指纹打卡系统源程序分享 [打印本页]

---

作者: 言斯    时间: 2021-5-6 02:18
标题: STC12单片机+AS608指纹打卡系统源程序分享
基于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. 
   
9. #define uchar unsigned char
   
10. #define uint unsigned int
    
11. #define ulong unsigned long
    
12. 
    
13. 
    
14. #define CharBuffer1 0x01
    
15. #define CharBuffer2 0x02
    
16. uint CuoWu,jiaoyanwei;
    
17. ulong AS608Addr = 0XFFFFFFFF; //默认模块地址
    
18. 
    
19. char str2[6]={0};
    
20. 
    
21. typedef struct  
    
22. {
    
23.         uint pageID;//指纹ID
    
24.         uint mathscore;//匹配得分
    
25. }SearchResult;
    
26. 
    
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;
    
35. 
    
36. const char *EnsureMessage(uchar ensure);
    
37. 
    
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. }
    
74. 
    
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. }
    
100. 
     
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. }
     
123. 
     
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. }
     
148. 
     
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. }
     
171. 
     
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. //}
     
209. 
     
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. }
     
312. 
     
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. //}
     
419. 
     
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. }
     
567. 
     
568. //显示确认码错误信息
     
569. void ShowErrMessage(uchar ensure)
     
570. {
     
571.         EnsureMessage(ensure);
     
572. }
     
573. 
     
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;
     
622. 
     
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;
     
643. 
     
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. }
     
706. 
     
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. }
     
749. 
     
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. }
     
809. 
     
810. #endif
     

复制代码

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

2021-5-6 02:17 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: 792544979    时间: 2021-5-14 14:40
怎么把串口2改成串口1

---

作者: kangguoqi2324    时间: 2021-6-10 15:52
有原理图可以参考吗？

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1