基于STM32的指纹锁

最新推荐文章于 2025-03-06 18:39:47 发布
最新推荐文章于 2025-03-06 18:39:47 发布
阅读量6k 收藏 55
点赞数 9
分类专栏： 项目 STM32 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51963216/article/details/123797748
版权

STM32

文章目录

指纹锁

前言

封校生活无聊至极，手上还有个AS608指纹模块没玩过，闲着无聊做了个指纹锁。

一、AS608模块

ATK-AS608 指纹识别模块是 ALIENTEK 推出的一款高性能的光学指纹识别模块。
ATK-AS608 模块采用了国内著名指纹识别芯片公司杭州晟元芯片技术有限公司(Synochip)的 AS608 指纹识别芯片。芯片内置 DSP 运算单元，集成了指纹识别算法，能高效快速采集图像并识别指纹特征。模块配备了串口、USB 通讯接口，用户无需研究复杂的图像处理及指纹识别算法，只需通过简单的串口、USB 按照通讯协议便可控制模块。本模块可应用于各种考勤机、保险箱柜、指纹门禁系统、指纹锁等场合。
在这里插入图片描述
切记不可以接5v

接线说明

在这里插入图片描述
在这里插入图片描述

二、使用步骤

代码

#include <string.h>
#include <stdio.h>
#include "delay.h"
#include "usart3.h"
#include "as608.h"
#include "oled_iic.h"
#include "key.h"

u32 AS608Addr = 0XFFFFFFFF; //ĬÈÏ
char str2[6] = {0};


//´®¿Ú·¢ËÍÒ»¸ö×Ö½Ú
static void MYUSART_SendData(u8 data)
{
  while((USART3->SR & 0X40) == 0);
  USART3->DR = data;
}
//·¢ËÍ°üÍ·
static void SendHead(void)
{
  MYUSART_SendData(0xEF);
  MYUSART_SendData(0x01);
}
//·¢Ë͵ØÖ·
static void SendAddr(void)
{
  MYUSART_SendData(AS608Addr >> 24);
  MYUSART_SendData(AS608Addr >> 16);
  MYUSART_SendData(AS608Addr >> 8);
  MYUSART_SendData(AS608Addr);
}
//·¢ËÍ°ü±êʶ,
static void SendFlag(u8 flag)
{
  MYUSART_SendData(flag);
}
//·¢ËÍ°ü³¤¶È
static void SendLength(int length)
{
  MYUSART_SendData(length >> 8);
  MYUSART_SendData(length);
}
//·¢ËÍÖ¸ÁîÂë
static void Sendcmd(u8 cmd)
{
  MYUSART_SendData(cmd);
}
//·¢ËÍУÑéºÍ
static void SendCheck(u16 check)
{
  MYUSART_SendData(check >> 8);
  MYUSART_SendData(check);
}
//ÅжÏÖжϽÓÊÕµÄÊý×éÓÐûÓÐÓ¦´ð°ü
//waittimeΪµÈ´ýÖжϽÓÊÕÊý¾ÝµÄʱ¼ä£¨µ¥Î»1ms£©
//·µ»ØÖµ£ºÊý¾Ý°üÊ×µØÖ·
static u8 *JudgeStr(u16 waittime)
{
  char *data;
  u8 str[8];
  str[0] = 0xef;
  str[1] = 0x01;
  str[2] = AS608Addr >> 24;
  str[3] = AS608Addr >> 16;
  str[4] = AS608Addr >> 8;
  str[5] = AS608Addr;
  str[6] = 0x07;
  str[7] = '\0';
  USART3_RX_STA = 0;
  while(--waittime)
  {
    delay_ms(1);
    if(USART3_RX_STA & 0X8000) //½ÓÊÕµ½Ò»´ÎÊý¾Ý
    {
      USART3_RX_STA = 0;
      data = strstr((const char*)USART3_RX_BUF, (const char*)str);
      if(data)
        return (u8*)data;
    }
  }
  return 0;
}
//¼ÈëͼÏñ PS_GetImage
//¹¦ÄÜ:̽²âÊÖÖ¸£¬Ì½²âµ½ºó¼ÈëÖ¸ÎÆͼÏñ´æÓÚImageBuffer¡£
//Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_GetImage(void)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x03);
  Sendcmd(0x01);
  temp =  0x01 + 0x03 + 0x01;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//Éú³ÉÌØÕ÷ PS_GenChar
//¹¦ÄÜ:½«ImageBufferÖеÄԭʼͼÏñÉú³ÉÖ¸ÎÆÌØÕ÷Îļþ´æÓÚCharBuffer1»òCharBuffer2
//²ÎÊý:BufferID --> charBuffer1:0x01	charBuffer1:0x02
//Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_GenChar(u8 BufferID)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x04);
  Sendcmd(0x02);
  MYUSART_SendData(BufferID);
  temp = 0x01 + 0x04 + 0x02 + BufferID;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//¾«È·±È¶ÔÁ½Ã¶Ö¸ÎÆÌØÕ÷ PS_Match
//¹¦ÄÜ:¾«È·±È¶ÔCharBuffer1 ÓëCharBuffer2 ÖеÄÌØÕ÷Îļþ
//Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_Match(void)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x03);
  Sendcmd(0x03);
  temp = 0x01 + 0x03 + 0x03;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//ËÑË÷Ö¸ÎÆ PS_Search
//¹¦ÄÜ:ÒÔCharBuffer1»òCharBuffer2ÖеÄÌØÕ÷ÎļþËÑË÷Õû¸ö»ò²¿·ÖÖ¸ÎÆ¿â.ÈôËÑË÷µ½£¬Ôò·µ»ØÒ³Âë¡£
//²ÎÊý:  BufferID @ref CharBuffer1	CharBuffer2
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö£¬Ò³Â루ÏàÅäÖ¸ÎÆÄ£°å£©
u8 PS_Search(u8 BufferID, u16 StartPage, u16 PageNum, SearchResult *p)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x08);
  Sendcmd(0x04);
  MYUSART_SendData(BufferID);
  MYUSART_SendData(StartPage >> 8);
  MYUSART_SendData(StartPage);
  MYUSART_SendData(PageNum >> 8);
  MYUSART_SendData(PageNum);
  temp = 0x01 + 0x08 + 0x04 + BufferID
         + (StartPage >> 8) + (u8)StartPage
         + (PageNum >> 8) + (u8)PageNum;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
  {
    ensure = data[9];
    p->pageID   = (data[10] << 8) + data[11];
    p->mathscore = (data[12] << 8) + data[13];
  }
  else
    ensure = 0xff;
  return ensure;
}
//ºÏ²¢ÌØÕ÷£¨Éú³ÉÄ£°å£©PS_RegModel
//¹¦ÄÜ:½«CharBuffer1ÓëCharBuffer2ÖеÄÌØÕ÷ÎļþºÏ²¢Éú³É Ä£°å,½á¹û´æÓÚCharBuffer1ÓëCharBuffer2
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_RegModel(void)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x03);
  Sendcmd(0x05);
  temp = 0x01 + 0x03 + 0x05;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//´¢´æÄ£°å PS_StoreChar
//¹¦ÄÜ:½« CharBuffer1 »ò CharBuffer2 ÖеÄÄ£°åÎļþ´æµ½ PageID ºÅflashÊý¾Ý¿âλÖá£
//²ÎÊý:  BufferID @ref charBuffer1:0x01	charBuffer1:0x02
//       PageID£¨Ö¸ÎÆ¿âλÖúţ©
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_StoreChar(u8 BufferID, u16 PageID)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x06);
  Sendcmd(0x06);
  MYUSART_SendData(BufferID);
  MYUSART_SendData(PageID >> 8);
  MYUSART_SendData(PageID);
  temp = 0x01 + 0x06 + 0x06 + BufferID
         + (PageID >> 8) + (u8)PageID;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//ɾ³ýÄ£°å PS_DeletChar
//¹¦ÄÜ:  ɾ³ýflashÊý¾Ý¿âÖÐÖ¸¶¨IDºÅ¿ªÊ¼µÄN¸öÖ¸ÎÆÄ£°å
//²ÎÊý:  PageID(Ö¸ÎÆ¿âÄ£°åºÅ)£¬Nɾ³ýµÄÄ£°å¸öÊý¡£
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_DeletChar(u16 PageID, u16 N)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x07);
  Sendcmd(0x0C);
  MYUSART_SendData(PageID >> 8);
  MYUSART_SendData(PageID);
  MYUSART_SendData(N >> 8);
  MYUSART_SendData(N);
  temp = 0x01 + 0x07 + 0x0C
         + (PageID >> 8) + (u8)PageID
         + (N >> 8) + (u8)N;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//Çå¿ÕÖ¸ÎÆ¿â PS_Empty
//¹¦ÄÜ:  ɾ³ýflashÊý¾Ý¿âÖÐËùÓÐÖ¸ÎÆÄ£°å
//²ÎÊý:  ÎÞ
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_Empty(void)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x03);
  Sendcmd(0x0D);
  temp = 0x01 + 0x03 + 0x0D;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//дϵͳ¼Ä´æÆ÷ PS_WriteReg
//¹¦ÄÜ:  дģ¿é¼Ä´æÆ÷
//²ÎÊý:  ¼Ä´æÆ÷ÐòºÅRegNum:4\5\6
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_WriteReg(u8 RegNum, u8 DATA)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x05);
  Sendcmd(0x0E);
  MYUSART_SendData(RegNum);
  MYUSART_SendData(DATA);
  temp = RegNum + DATA + 0x01 + 0x05 + 0x0E;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  if(ensure == 0)
    printf("\r\nÉèÖòÎÊý³É¹¦£¡");
  else
    printf("\r\n%s", EnsureMessage(ensure));
  return ensure;
}
//¶Áϵͳ»ù±¾²ÎÊý PS_ReadSysPara
//¹¦ÄÜ:  ¶ÁÈ¡Ä£¿éµÄ»ù±¾²ÎÊý£¨²¨ÌØÂÊ£¬°ü´óСµÈ)
//²ÎÊý:  ÎÞ
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö + »ù±¾²ÎÊý£¨16bytes£©
u8 PS_ReadSysPara(SysPara *p)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x03);
  Sendcmd(0x0F);
  temp = 0x01 + 0x03 + 0x0F;
  SendCheck(temp);
  data = JudgeStr(1000);
  if(data)
  {
    ensure = data[9];
    p->PS_max = (data[14] << 8) + data[15];
    p->PS_level = data[17];
    p->PS_addr = (data[18] << 24) + (data[19] << 16) + (data[20] << 8) + data[21];
    p->PS_size = data[23];
    p->PS_N = data[25];
  }
  else
    ensure = 0xff;
  if(ensure == 0x00)
  {
    printf("\r\nÄ£¿é×î´óÖ¸ÎÆÈÝÁ¿=%d", p->PS_max);
    printf("\r\n¶Ô±ÈµÈ¼¶=%d", p->PS_level);
    printf("\r\nµØÖ·=%x", p->PS_addr);
    printf("\r\n²¨ÌØÂÊ=%d", p->PS_N * 9600);
  }
  else
    printf("\r\n%s", EnsureMessage(ensure));
  return ensure;
}
//ÉèÖÃÄ£¿éµØÖ· PS_SetAddr
//¹¦ÄÜ:  ÉèÖÃÄ£¿éµØÖ·
//²ÎÊý:  PS_addr
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_SetAddr(u32 PS_addr)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x07);
  Sendcmd(0x15);
  MYUSART_SendData(PS_addr >> 24);
  MYUSART_SendData(PS_addr >> 16);
  MYUSART_SendData(PS_addr >> 8);
  MYUSART_SendData(PS_addr);
  temp = 0x01 + 0x07 + 0x15
         + (u8)(PS_addr >> 24) + (u8)(PS_addr >> 16)
         + (u8)(PS_addr >> 8) + (u8)PS_addr;
  SendCheck(temp);
  AS608Addr = PS_addr; //·¢ËÍÍêÖ¸Á¸ü»»µØÖ·
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  AS608Addr = PS_addr;
  if(ensure == 0x00)
    printf("\r\nÉèÖõØÖ·³É¹¦£¡");
  else
    printf("\r\n%s", EnsureMessage(ensure));
  return ensure;
}
//¹¦ÄÜ£º Ä£¿éÄÚ²¿ÎªÓû§¿ª±ÙÁË256bytesµÄFLASH¿Õ¼äÓÃÓÚ´æÓû§¼Çʱ¾,
//	¸Ã¼Çʱ¾Âß¼­Éϱ»·Ö³É 16 ¸öÒ³¡£
//²ÎÊý:  NotePageNum(0~15),Byte32(ҪдÈëÄÚÈÝ£¬32¸ö×Ö½Ú)
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö
u8 PS_WriteNotepad(u8 NotePageNum, u8 *Byte32)
{
  u16 temp;
  u8  ensure, i;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(36);
  Sendcmd(0x18);
  MYUSART_SendData(NotePageNum);
  for(i = 0; i < 32; i++)
  {
    MYUSART_SendData(Byte32[i]);
    temp += Byte32[i];
  }
  temp = 0x01 + 36 + 0x18 + NotePageNum + temp;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
    ensure = data[9];
  else
    ensure = 0xff;
  return ensure;
}
//¶Á¼ÇÊÂPS_ReadNotepad
//¹¦ÄÜ£º  ¶ÁÈ¡FLASHÓû§ÇøµÄ128bytesÊý¾Ý
//²ÎÊý:  NotePageNum(0~15)
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö+Óû§ÐÅÏ¢
u8 PS_ReadNotepad(u8 NotePageNum, u8 *Byte32)
{
  u16 temp;
  u8  ensure, i;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x04);
  Sendcmd(0x19);
  MYUSART_SendData(NotePageNum);
  temp = 0x01 + 0x04 + 0x19 + NotePageNum;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
  {
    ensure = data[9];
    for(i = 0; i < 32; i++)
    {
      Byte32[i] = data[10 + i];
    }
  }
  else
    ensure = 0xff;
  return ensure;
}
//¸ßËÙËÑË÷PS_HighSpeedSearch
//¹¦ÄÜ£ºÒÔ CharBuffer1»òCharBuffer2ÖеÄÌØÕ÷Îļþ¸ßËÙËÑË÷Õû¸ö»ò²¿·ÖÖ¸ÎÆ¿â¡£
//		  ÈôËÑË÷µ½£¬Ôò·µ»ØÒ³Âë,¸ÃÖ¸Áî¶ÔÓÚµÄÈ·´æÔÚÓÚÖ¸ÎÆ¿âÖÐ £¬ÇҵǼʱÖÊÁ¿
//		  ºÜºÃµÄÖ¸ÎÆ£¬»áºÜ¿ì¸ø³öËÑË÷½á¹û¡£
//²ÎÊý:  BufferID£¬ StartPage(Æðʼҳ)£¬PageNum£¨Ò³Êý£©
//˵Ã÷:  Ä£¿é·µ»ØÈ·ÈÏ×Ö+Ò³Â루ÏàÅäÖ¸ÎÆÄ£°å£©
u8 PS_HighSpeedSearch(u8 BufferID, u16 StartPage, u16 PageNum, SearchResult *p)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x08);
  Sendcmd(0x1b);
  MYUSART_SendData(BufferID);
  MYUSART_SendData(StartPage >> 8);
  MYUSART_SendData(StartPage);
  MYUSART_SendData(PageNum >> 8);
  MYUSART_SendData(PageNum);
  temp = 0x01 + 0x08 + 0x1b + BufferID
         + (StartPage >> 8) + (u8)StartPage
         + (PageNum >> 8) + (u8)PageNum;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
  {
    ensure = data[9];
    p->pageID 	= (data[10] << 8) + data[11];
    p->mathscore = (data[12] << 8) + data[13];
  }
  else
    ensure = 0xff;
  return ensure;
}
//¶ÁÓÐЧģ°å¸öÊý PS_ValidTempleteNum
//¹¦ÄÜ£º¶ÁÓÐЧģ°å¸öÊý
//²ÎÊý: ÎÞ
//˵Ã÷: Ä£¿é·µ»ØÈ·ÈÏ×Ö+ÓÐЧģ°å¸öÊýValidN
u8 PS_ValidTempleteNum(u16 *ValidN)
{
  u16 temp;
  u8  ensure;
  u8  *data;
  SendHead();
  SendAddr();
  SendFlag(0x01);//ÃüÁî°ü±êʶ
  SendLength(0x03);
  Sendcmd(0x1d);
  temp = 0x01 + 0x03 + 0x1d;
  SendCheck(temp);
  data = JudgeStr(2000);
  if(data)
  {
    ensure = data[9];
    *ValidN = (data[10] << 8) + data[11];
  }
  else
    ensure = 0xff;

  if(ensure == 0x00)
  {
    printf("\r\nÓÐЧָÎƸöÊý=%d", (data[10] << 8) + data[11]);
  }
  else
    printf("\r\n%s", EnsureMessage(ensure));
  return ensure;
}
//ÓëAS608ÎÕÊÖ PS_HandShake
//²ÎÊý: PS_AddrµØÖ·Ö¸Õë
//˵Ã÷: Ä£¿é·µÐµØÖ·£¨ÕýÈ·µØÖ·£©
u8 PS_HandShake(u32 *PS_Addr)
{
  SendHead();
  SendAddr();
  MYUSART_SendData(0X01);
  MYUSART_SendData(0X00);
  MYUSART_SendData(0X00);
  delay_ms(200);
  if(USART3_RX_STA & 0X8000) //½ÓÊÕµ½Êý¾Ý
  {
    if(//ÅжÏÊDz»ÊÇÄ£¿é·µ»ØµÄÓ¦´ð°ü
      USART3_RX_BUF[0] == 0XEF
      && USART3_RX_BUF[1] == 0X01
      && USART3_RX_BUF[6] == 0X07
    )
    {
      *PS_Addr = (USART3_RX_BUF[2] << 24) + (USART3_RX_BUF[3] << 16)
                 + (USART3_RX_BUF[4] << 8) + (USART3_RX_BUF[5]);
      USART3_RX_STA = 0;
      return 0;
    }
    USART3_RX_STA = 0;
  }
  return 1;
}
//Ä£¿éÓ¦´ð°üÈ·ÈÏÂëÐÅÏ¢½âÎö
//¹¦ÄÜ£º½âÎöÈ·ÈÏÂë´íÎóÐÅÏ¢·µ»ØÐÅÏ¢
//²ÎÊý: ensure
const char *EnsureMessage(u8 ensure)
{
  const char *p;
  switch(ensure)
  {
  case  0x00:   
    p = "       OK       ";
    break;
  case  0x01:
    p = " Êý¾Ý°ü½ÓÊÕ´íÎó ";
    break;
  case  0x02:
    p = "´«¸ÐÆ÷ÉÏûÓÐÊÖÖ¸";
    break;
  case  0x03:
    p = "¼ÈëÖ¸ÎÆͼÏñʧ°Ü";
    break;
  case  0x04:
    p = " Ö¸ÎÆÌ«¸É»òÌ«µ­ ";
    break;
  case  0x05:
    p = " Ö¸ÎÆ̫ʪ»òÌ«ºý ";
    break;
  case  0x06:
    p = "  Ö¸ÎÆͼÏñÌ«ÂÒ  ";
    break;
  case  0x07:
    p = " Ö¸ÎÆÌØÕ÷µãÌ«ÉÙ ";
    break;
  case  0x08:
    p = "  Ö¸ÎƲ»Æ¥Åä    ";
    break;
  case  0x09:
    p = " ûÓÐËÑË÷µ½Ö¸ÎÆ ";
    break;
  case  0x0a:
    p = "   ÌØÕ÷ºÏ²¢Ê§°Ü ";
    break;
  case  0x0b:
    p = "µØÖ·ÐòºÅ³¬³ö·¶Î§";
  case  0x10:
    p = "  ɾ³ýÄ£°åʧ°Ü  ";
    break;
  case  0x11:
    p = " Çå¿ÕÖ¸ÎÆ¿âʧ°Ü ";
    break;
  case  0x15:
    p = "»º³åÇøÄÚÎÞÓÐЧͼ";
    break;
  case  0x18:
    p = " ¶ÁдFLASH³ö´í  ";
    break;
  case  0x19:
    p = "   䶨Òå´íÎó   ";
    break;
  case  0x1a:
    p = "  ÎÞЧ¼Ä´æÆ÷ºÅ  ";
    break;
  case  0x1b:
    p = " ¼Ä´æÆ÷ÄÚÈÝ´íÎó ";
    break;
  case  0x1c:
    p = " ¼Çʱ¾Ò³Âë´íÎó ";
    break;
  case  0x1f:
    p = "    Ö¸ÎÆ¿âÂú    ";
    break;
  case  0x20:
    p = "    µØÖ·´íÎó    ";
    break;
  default :
    p = " ·µ»ØÈ·ÈÏÂëÓÐÎó ";
    break;
  }
  return p;
}

//ÏÔʾȷÈÏÂë´íÎóÐÅÏ¢
void ShowErrMessage(u8 ensure)
{
  //OLED_ShowCH(5,0,(u8*)EnsureMessage(ensure));
}


//¼ָÎÆ
void Add_FR(void)
{
  u8 i, ensure, processnum = 0;
  u8 ID_NUM = 0;
  while(1)
  {
    switch (processnum)
    {
    case 0:
      i++;
      OLED_ShowCH(0, 2, "    Çë°´ÊÖÖ¸    ");
      ensure = PS_GetImage();
      if(ensure == 0x00)
      {
        ensure = PS_GenChar(CharBuffer1); //Éú³ÉÌØÕ÷
        if(ensure == 0x00)
        {
          OLED_ShowCH(0, 2, "    Ö¸ÎÆÕý³£    ");
          OLED_ShowCH(0, 4, "                ");
          i = 0;
          processnum = 1; //Ìøµ½µÚ¶þ²½
        }
        else ShowErrMessage(ensure);
      }
      else ShowErrMessage(ensure);
      break;

    case 1:
      i++;
      OLED_ShowCH(0, 2, "   ÇëÔÙ°´Ò»´Î   ");
      OLED_ShowCH(0, 4, "                ");
      ensure = PS_GetImage();
      if(ensure == 0x00)
      {
        ensure = PS_GenChar(CharBuffer2); //Éú³ÉÌØÕ÷
        if(ensure == 0x00)
        {
          OLED_ShowCH(0, 2, "    Ö¸ÎÆÕý³£    ");
          OLED_ShowCH(0, 4, "                ");
          i = 0;
          processnum = 2; //Ìøµ½µÚÈý²½
        }
        else ShowErrMessage(ensure);
      }
      else ShowErrMessage(ensure);
      break;

    case 2:
      OLED_ShowCH(0, 2, "  ¶Ô±ÈÁ½´ÎÖ¸ÎÆ  ");
      OLED_ShowCH(0, 4, "                ");
      ensure = PS_Match();
      if(ensure == 0x00)
      {
        OLED_ShowCH(0, 2, "    ¶Ô±È³É¹¦    ");
        OLED_ShowCH(0, 4, "                ");
        processnum = 3; //Ìøµ½µÚËIJ½
      }
      else
      {
        OLED_ShowCH(0, 2, "    ¶Ô±Èʧ°Ü    ");
        OLED_ShowCH(0, 4, "                ");
        ShowErrMessage(ensure);
        i = 0;
        processnum = 0; //Ìø»ØµÚÒ»²½
      }
      delay_ms(500);
      break;

    case 3:
      OLED_ShowCH(0, 2, "  Éú³ÉÖ¸ÎÆÄ£°å  ");
      OLED_ShowCH(0, 4, "                ");
      delay_ms(500);
      ensure = PS_RegModel();
      if(ensure == 0x00)
      {
        OLED_ShowCH(0, 2, "Éú³ÉÖ¸ÎÆÄ£°å³É¹¦");
        OLED_ShowCH(0, 4, "                ");
        processnum = 4; //Ìøµ½µÚÎå²½
      }
      else
      {
        processnum = 0;
        ShowErrMessage(ensure);
      }
      delay_ms(1000);
      break;

    case 4:
      OLED_ShowCH(0, 0, " °´K4¼Ó,°´K2¼õ ");
      OLED_ShowCH(0, 2, "    °´K3±£´æ    ");
      OLED_ShowCH(0, 4, "  0=< ID <=99   ");
      while(key_num != 3)
      {
        key_num = KEY_Scan(0);
        if(key_num == 2)
        {
          key_num = 0;
          if(ID_NUM > 0)
            ID_NUM--;
        }
        if(key_num == 4)
        {
          key_num = 0;
          if(ID_NUM < 99)
            ID_NUM++;
        }
        OLED_ShowCH(40, 6, "ID=");
        OLED_ShowNum(65, 6, ID_NUM, 2, 1);
      }
      key_num = 0;
      ensure = PS_StoreChar(CharBuffer2, ID_NUM); //´¢´æÄ£°å
      if(ensure == 0x00)
      {
        OLED_Clear();
        OLED_ShowCH(0, 2, "  ¼ÈëÖ¸ÎƳɹ¦  ");
        OLED_ShowCH(0, 4, "                ");
        delay_ms(1500);
        OLED_Clear();
        OLED_ShowCH(0, 0, "Ö¸ÎÆÄ£¿é²âÊÔ³ÌÐò");
        OLED_ShowCH(16, 2, "K1¼üÌí¼ÓÖ¸ÎÆ");
        OLED_ShowCH(16, 4, "K3¼üɾ³ýÖ¸ÎÆ");
        OLED_ShowCH(16, 6, "K5¼üÑéÖ¤Ö¸ÎÆ");
        return ;
      }
      else
      {
        OLED_Clear();
        processnum = 0;
        ShowErrMessage(ensure);
      }
      break;
    }
    delay_ms(400);
    if(i == 10) //³¬¹ý5´ÎûÓа´ÊÖÖ¸ÔòÍ˳ö
    {
      break;
    }
  }
}

SysPara AS608Para;//Ö¸ÎÆÄ£¿éAS608²ÎÊý
//Ë¢Ö¸ÎÆ
void press_FR(void)
{
  SearchResult seach;
  u8 ensure;
  char str[20];
  while(key_num != 1)
  {
    key_num = KEY_Scan(0);
    ensure = PS_GetImage();
    if(ensure == 0x00) //»ñȡͼÏñ³É¹¦
    {
      ensure = PS_GenChar(CharBuffer1);
      if(ensure == 0x00) //Éú³ÉÌØÕ÷³É¹¦
      {
        ensure = PS_HighSpeedSearch(CharBuffer1, 0, 99, &seach);
        if(ensure == 0x00) //ËÑË÷³É¹¦
        {
          OLED_ShowCH(0, 2, "  Ö¸ÎÆÑéÖ¤³É¹¦  ");
          sprintf(str, " ID:%d µÃ·Ö:%d ", seach.pageID, seach.mathscore);
          OLED_ShowCH(0, 4, (u8*)str);
          delay_ms(1500);
          delay_ms(1500);
        }
        else
        {
          OLED_ShowCH(32, 2, "Ñé֤ʧ°Ü");
          delay_ms(1500);
        }
      }
      else
			{};
      OLED_Clear();
      OLED_ShowCH(32, 2, "Çë°´ÊÖÖ¸");
    }
  }
  OLED_Clear();
  OLED_ShowCH(0, 0, "Ö¸ÎÆÄ£¿é²âÊÔ³ÌÐò");
  OLED_ShowCH(16, 2, "K1¼üÌí¼ÓÖ¸ÎÆ");
  OLED_ShowCH(16, 4, "K3¼üɾ³ýÖ¸ÎÆ");
  OLED_ShowCH(16, 6, "K5¼üÑéÖ¤Ö¸ÎÆ");
}

//ɾ³ýÖ¸ÎÆ
void Del_FR(void)
{
  u8  ensure;
  u16 ID_NUM = 0;
  OLED_ShowCH(0, 0, "K4¼Ó K2¼õ K3È·ÈÏ");
  OLED_ShowCH(0, 2, "  K5Çå¿ÕÖ¸ÎÆ¿â  ");
  OLED_ShowCH(0, 4, "K1·µ»Ø 0=<ID<=99");
  while(key_num != 3)
  {
    key_num = KEY_Scan(0);
    if(key_num == 2)
    {
      key_num = 0;
      if(ID_NUM > 0)
        ID_NUM--;
    }
    if(key_num == 4)
    {
      key_num = 0;
      if(ID_NUM < 99)
        ID_NUM++;
    }
    if(key_num == 1)
      goto MENU ; //·µ»ØÖ÷Ò³Ãæ
    if(key_num == 5)
    {
      key_num = 0;
      ensure = PS_Empty(); //Çå¿ÕÖ¸ÎÆ¿â
      if(ensure == 0)
      {
        OLED_Clear();
        OLED_ShowCH(0, 2, " Çå¿ÕÖ¸ÎÆ¿â³É¹¦ ");
      }
      else
        ShowErrMessage(ensure);
      delay_ms(1500);
      goto MENU ; //·µ»ØÖ÷Ò³Ãæ
    }
    OLED_ShowCH(40, 6, "ID=");
    OLED_ShowNum(65, 6, ID_NUM, 2, 1);
  }
  ensure = PS_DeletChar(ID_NUM, 1); //ɾ³ýµ¥¸öÖ¸ÎÆ
  if(ensure == 0)
  {
    OLED_Clear();
    OLED_ShowCH(0, 2, "  ɾ³ýÖ¸ÎƳɹ¦  ");
  }
  else
    ShowErrMessage(ensure);
  delay_ms(1500);
MENU:
  OLED_Clear();
  OLED_ShowCH(0, 0, "Ö¸ÎÆÄ£¿é²âÊÔ³ÌÐò");
  OLED_ShowCH(16, 2, "K1¼üÌí¼ÓÖ¸ÎÆ");
  OLED_ShowCH(16, 4, "K3¼üɾ³ýÖ¸ÎÆ");
  OLED_ShowCH(16, 6, "K5¼üÑéÖ¤Ö¸ÎÆ");
  key_num = 0;
}

在这里插入图片描述
识别成功case选择的是0x00可以看到当ensure等于0x00时执行识别成功对应的功能。
在这里插入图片描述

总结

一般来说只要是模块类的东西就不难，下一步用人脸识别和指纹一起做一个解锁的。

基于STM32智能门锁指纹锁电路系统设计
2301_79745346的博客
05-13 1747
*单片机设计介绍，基于STM32智能门锁指纹锁电路系统设计。
基于STM32的智能指纹锁
01-06
目录功能介绍模块介绍STM32最小系统AS608光学指纹识别模块触摸键盘ESP8266 模块其他模块硬件设计电源电路STM32模块电路指纹模块电路蜂鸣器驱动电路继电器驱动电路其他模块PCB效果图软件设计程序流程图贴代码 一直想做个指纹锁玩玩，这几天有空刚好搞一下！ 先上成品图 功能介绍 这个作品主要需要完成以下几个功能 识别指纹并驱动继电器吸合使电磁锁动作 一键开锁 录指纹和删除指纹 输入密码，正确时开锁 修改密码 扩展功能：用手机小程序控制锁的开合 模块介绍 STM32最小系统 本设计选用的STM32芯片型号为STM32F103C8T6 AS608光学指纹识别模块 ATK-AS608
基于STM32的密码指纹锁
02-28
利用STM32F1 + 矩阵键盘 + 指纹模块 + OLED模块 + 继电器使用UCOS-III实现密码指纹锁，功能包括指纹录入删除、管理员身份验证、密码开锁、密码修改等等。
基于STM32的指纹密码锁
weixin_50874851的博客
06-16 4475
本项目为学习STM32单片机编程的阶段性总结；对通信协议以及单片机编程的一个阶段性练习，结合多个功能模块，实现一个可通过指纹或者密码解锁的门锁系统。1.基于OLED屏(IIC协议)显示，设计简单友好的操作界面，矩阵键扫描实现密码解锁；2.指纹模块与语音模块(异步串口)可对指纹进行录入、删除与匹配操作并语言反馈对应操作结果；3.采用外部FLash储存密码(SPI协议w25q128)。。。。。。......
智能门禁系统：基于STM32单片机的门禁指纹密码锁设计
最新发布
2302_76924123的博客
03-06 1438
智能门禁系统是一种基于现代信息技术、电子技术与网络技术深度融合的出入口控制系统。它通过识别人员的身份信息，如 IC 卡、指纹、人脸识别、密码等，来判断是否允许其进入特定区域，从而实现对出入口的有效管控，取代了传统的钥匙开锁方式，大大提升了安全性和管理效率。
STM32指纹密码锁电路图及PCB
01-13
STM32指纹密码锁电路图及PCB，整个项目已经完全调试通了，到手可以直接用的，原理图也是可以直接用的。
STM32项目设计：基于STM32指纹密码锁
热门推荐
qq_35654286的博客
03-29 1万+
一、项目功能概述 1、可通过指纹模块增删查改家庭成员的指纹信息，增删查改是否成功的相关信息显示在TFTLCD屏幕，可存储500个指纹信息。 2、在指纹匹配过程中，如果采集的指纹与指纹模块库相匹配，TFTLCD显示“刷指纹成功，确有此人ID”，此时指示灯亮。 3、可以密码解锁（密码6位），如果匹配成功，即可开锁，显示“密码正确”，指示灯亮。 4、如果密码错误或者没有识别到指纹，指示灯灭，蜂鸣器报警。 5、支持TFTLCD触摸屏校准。 6、显示温湿度。
STM32指纹锁 代码与pcb原理图.rar
12-19
在"STM32指纹锁 代码与pcb原理图.rar"这个压缩包中，包含的是一个使用STM32芯片实现的指纹锁项目的完整资源，包括源代码和PCB设计文件。 一、STM32基础知识 STM32家族的特点在于其高性能、低功耗、丰富的外设集和...
基于STM32智能指纹锁控制系统设计与实现.pdf
06-27
基于STM32智能指纹锁控制系统设计与实现 一、引言 本文旨在设计一款基于STM32微控制器的智能指纹锁控制系统，该系统着重于解决传统门禁系统存在的安全性问题。传统门禁系统主要依赖钥匙或简单密码，既容易丢失钥匙...
基于stm32的指纹识别
12-22
基于stm32的指纹识别 指纹打卡 系统 附带源程序 资料
基于STM32的指纹识别程序
09-13
利用STM32驱动指纹模块 ，可录入指纹并对比
基于STM32的寝室指纹门锁设计
09-01
FPc1020指纹模块作为指纹识别，HC-05蓝牙模块无线控制，STM32F103C8T6作为主控制芯片，0.96寸OLED显示开锁信息和实时时间
基于STM32的密码锁设计
05-06
基于stm32的电子密码锁设计，显示屏用的OLED，SPI通信方式，按键用的是矩阵键盘
STM32开发实例_基于STM32单片机的指纹密码锁（电路图+程序+流程图）24-32-51
XCHardware的博客
07-10 2239
1. 指纹识别开锁：- 支持指纹识别技术，确保安全快捷的门锁解锁体验。2. 射频刷卡开锁：- 提供射频刷卡功能，用户可以使用预设的RFID卡片进行开锁操作。3. 密码开锁：- 支持设定密码开锁，用户通过输入预设的数字密码进行门锁解锁。4. 无线远程开锁：- 提供无线远程开锁功能，允许授权用户通过远程控制设备（如手机或电脑）进行开锁操作。5. 显示屏状态显示：- 配备显示屏，实时显示当前的密码状态和门锁状态，提供用户友好的操作界面。
STM32智能锁指纹锁密码锁WIFI远程开锁微信小程序临时密码源码PCBA方案
weixin_43618242的博客
12-17 4373
这是一套已经批量生产了的智能锁PCBA方案。我们专注智能锁电控板开发，可以根据客户要求定制开发，可提供PCBA。也可以提供整套技术资料，包括程序源码，原理图PCB图，BOM清单等。 该指纹密码锁具有如下功能： 一、指纹开门 二、触摸密码开门 三、IC卡开门 四、OLED液晶界面显示 五、兼容半导体和光学指纹 六、霍尔感应唤醒（适合滑盖锁用） 七、防撬报警 八、触摸门铃功能 九、语音提示功能 十、中英文显示功能 十一、开门记录查询 十二、低成本方案 十三、防窥视密码功能（正确密码前后输入干扰码也能开门） 十四
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我与nano

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值