指纹逻辑

串口.h文件

#ifndef __WIFI_UART1_H__

#define __WIFI_UART1_H__

#include "stm32f10x.h"
#include "timer3.h"
#include "stdarg.h"  
#include "stdio.h"  
#include "string.h"  

#define WIFI_USART1_MAX_RECV_LEN 600 //最大接收缓存字节数
#define WIFI_USART1_MAX_SEND_LEN 600 //最大发送缓存字节数
#define WIFI_USART1_RX_EN 1 //0,不接收;1,接收.
// 串口3-USART3
#define  Test_USART                USART3
#define  USART3_CLK                RCC_APB1Periph_USART3
#define  USART3_APBxClkCmd         RCC_APB1PeriphClockCmd
#define  USART3_BAUDRATE           115200


USART GPIO 引脚宏定义
#define  USART3_GPIO_CLK           (RCC_APB2Periph_GPIOB)
#define  USART3_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
    
#define  USART3_TX_GPIO_PORT       GPIOB   
#define  USART3_TX_GPIO_PIN        GPIO_Pin_10
#define  USART3_RX_GPIO_PORT       GPIOB
#define  USART3_RX_GPIO_PIN        GPIO_Pin_11


#define  USART3_IRQ                USART3_IRQn
#define  USART3_IRQHandler         USART3_IRQHandler






// 串口4-UART4
#define  Finger_USART              UART4
#define  USART4_CLK                RCC_APB1Periph_UART4
#define  USART4_APBxClkCmd         RCC_APB1PeriphClockCmd
#define  USART4_BAUDRATE           57600


USART GPIO 引脚宏定义
#define  USART4_GPIO_CLK           (RCC_APB2Periph_GPIOC)
#define  USART4_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
//    
#define  USART4_TX_GPIO_PORT       GPIOC   
#define  USART4_TX_GPIO_PIN        GPIO_Pin_10
#define  USART4_RX_GPIO_PORT       GPIOC
#define  USART4_RX_GPIO_PIN        GPIO_Pin_11


#define  USART4_IRQ                UART4_IRQn
#define  USART4_IRQHandler         UART4_IRQHandler


typedef struct
{


unsigned char startRcv :2;
unsigned char resetflag:1;
unsigned char stopRcv : 1;
unsigned char reverse : 4;

unsigned char usartReceiveFlag;
  unsigned char  usartLen;
unsigned char  usartLenPre;
unsigned char usartBuf[300];


} USART_INFO;




typedef  struct 
{
uint32_t  count;
uint8_t  start_C_flag;
  uint8_t  end_flag;
    uint8_t  Over_f;


}WIFI_Over;
typedef  enum
{
init=0,
register_fingerprint,
verification_fingerprint,
delete_fingerprint,
delete_ALL_fingerprint,
shake_hander_to_test_normal


}fingerprint_op;
extern fingerprint_op  fingerprint_op_Command;
typedef enum
{
Success=0,
Shake_hande_R_E,
register_Get_image_R_E,
Generating_feature_value_R_E,
Merge_template_R_E,
Storge_template_R_E,
Storge_template_V_E,
verification_Get_image_V_E,
Generating_feature_value_V_E,
Find_fingerprint_V_E,
Shake_hande_C_E,
Delete_fingerprint_C_E,
Clear_fingerprint_C_E


}Retrun_ERROR;
extern Retrun_ERROR  fingerprint_retrun;
typedef struct
{
uint16_t Open_door_person;
uint16_t Matchscore;


}find_person;
typedef struct
{
bool  only_one_R;
bool  only_one_V;
bool  only_one_C;
bool  only_one_S;

}only_T;




volatile extern WIFI_Over  WIFI_Over_Adjust;
volatile extern WIFI_Over  Door_delay;
volatile extern WIFI_Over  Door_State_send;
volatile extern WIFI_Over  WIFI_state_delay;
volatile extern WIFI_Over  only_config_delay;
volatile extern WIFI_Over  battle_delay;
volatile extern WIFI_Over  close_3s_delay;
volatile extern WIFI_Over  close_7s_delay;
volatile extern WIFI_Over  in_door_d;
volatile extern WIFI_Over  door_3s_open_f;
volatile extern WIFI_Over  config_net_time;
volatile extern WIFI_Over  In_door_t;
extern   volatile WIFI_Over  test_new_yaokongqi_1s;
extern   volatile WIFI_Over  return_3s_c_Nega;
volatile extern WIFI_Over  add_yaokongqi_delay;
extern   volatile WIFI_Over  return_3s_c_Main;
extern u8  WIFI_USART1_RX_BUF[WIFI_USART1_MAX_RECV_LEN]; //接收缓冲,最大USART3_MAX_RECV_LEN字节
extern u8  WIFI_USART1_TX_BUF[WIFI_USART1_MAX_SEND_LEN]; //发送缓冲,最大USART3_MAX_SEND_LEN字节
extern vu16 WIFI_USART1_RX_STA;    //接收数据状态


extern    USART_INFO   finger_rec_Info;
extern    USART_INFO    boards_rec_Info;


#define    beep_GPIO_CLK             RCC_APB2Periph_GPIOB
#define    beep_GPIO_PORT            GPIOB    
#define    beep_GPIO_PIN          GPIO_Pin_8


void beep_init(void);
void beep_count(void);








void Fingerprint_USART_INIT(u32 bound);
void WIFI_USART_INIT(u32 bound);//串口1初始化函数
void WIFI_u1_printf(char* fmt,...);//串口1打印函数
void WIFI_UART1_Send_Data(u8 dat);
void WIFI_UART1_Send_String(char  *s);
void Fingerprint_board_USART_INIT(u32 bound);


void Usarts_SendString(USART_TypeDef *USARTx, unsigned char *str, unsigned short len);


uint16_t find_vacany_location(void);
uint8_t  Send_command_finger(uint8_t Operation,uint16_t save_id);
void  fingerPrint_opr_function(void);
uint8_t  Send_delete_shake_hander_C(void);
uint16_t find_FingerID_location(uint16_t finger_ID);

#endif

串口.c文件

#include "wifi_uart1.h"

USART_INFO    finger_rec_Info;
USART_INFO    boards_rec_Info;
//串口接收缓存区
u8  WIFI_USART1_RX_BUF[WIFI_USART1_MAX_RECV_LEN]; //接收缓冲,最大USART1_MAX_RECV_LEN个字节.
u8  WIFI_USART1_TX_BUF[WIFI_USART1_MAX_SEND_LEN]; //发送缓冲,最大USART1_MAX_SEND_LEN字节


//通过判断接收连续2个字符之间的时间差不大于10ms来决定是不是一次连续的数据.
//如果2个字符接收间隔超过10ms,则认为不是1次连续数据.也就是超过10ms没有接收到
//任何数据,则表示此次接收完毕.
//接收到的数据状态
//[15]:0,没有接收到数据;1,接收到了一批数据.
//[14:0]:接收到的数据长度




volatile WIFI_Over  WIFI_Over_Adjust;
volatile WIFI_Over  Door_delay;
volatile WIFI_Over  close_3s_delay;
volatile WIFI_Over  close_7s_delay;
volatile WIFI_Over  door_3s_open_f;
volatile WIFI_Over  config_net_time;
///
fingerprint_op  fingerprint_op_Command;
fingerprint_op  last_fingerprint_op_Command;
Retrun_ERROR  fingerprint_retrun;


uint16_t Store_finger_id[120]={0};
uint16_t  vacany_location;
uint16_t  Numbering=0;//手机上指纹编号
uint8_t   Beep_count;
find_person find_person_C;
only_T  only_Type;
void USART3_IRQHandler(void)
{
     unsigned char data = 0;
   
     if(USART_GetITStatus(Test_USART, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)
   {
   
  data = Test_USART->DR;
    boards_rec_Info.usartBuf[boards_rec_Info.usartLen++] = data;
        USART_ClearFlag(Test_USART, USART_FLAG_RXNE);
   }
} 
void USART4_IRQHandler(void)
{
     unsigned char data = 0;
   
     if(USART_GetITStatus(Finger_USART, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)
   {
    WIFI_Over_Adjust.count=0;   
 
    WIFI_Over_Adjust.start_C_flag=1;
 
        data = Finger_USART->DR;
          
        finger_rec_Info.usartBuf[finger_rec_Info.usartLen++] = data;
 
        USART_ClearFlag(Finger_USART, USART_FLAG_RXNE);
   }  
} 
void Fingerprint_board_USART_INIT(u32 bound)
{  
NVIC_InitTypeDef NVIC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;


RCC_APB2PeriphClockCmd(USART3_GPIO_CLK, ENABLE); // GPIOA时钟
RCC_APB2PeriphClockCmd(USART3_CLK,ENABLE); //串口3时钟使能


USART_DeInit(USART3);  //复位串口3
//USART3_TX   PB10
GPIO_InitStructure.GPIO_Pin = USART3_TX_GPIO_PIN; //PB10
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
GPIO_Init(USART3_TX_GPIO_PORT, &GPIO_InitStructure); //初始化PB10
 
//USART3_RX   PB11
GPIO_InitStructure.GPIO_Pin = USART3_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
GPIO_Init(USART3_TX_GPIO_PORT, &GPIO_InitStructure);  //初始化PB11

USART_InitStructure.USART_BaudRate = bound;//波特率一般设置为9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式

USART_Init(Test_USART, &USART_InitStructure); //初始化串口 3



USART_Cmd(Test_USART, ENABLE);                    //使能串口 

//使能接收中断
USART_ITConfig(Test_USART, USART_IT_RXNE, ENABLE);//开启中断   

//设置中断优先级
#if 1
NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQ;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级3
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器
#endif
}


//初始化IO 串口4
//pclk1:PCLK1时钟频率(Mhz)
//bound:波特率   
void Fingerprint_USART_INIT(u32 bound)
{  
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
    // 第1步：打开GPIO和USART部件的时钟 
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
    
    // Configure UART4 Tx (PC.10) as alternate function push-pull 
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOC, &GPIO_InitStructure);
    
    // Configure UART4 Rx (PC.11) as input floating 
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOC, &GPIO_InitStructure);
    
    // Enable the UART4 Interrupt 
    NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    
    // 串口相关配置
    USART_StructInit(&USART_InitStructure);
    USART_InitStructure.USART_BaudRate = bound;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b; // 位宽
    USART_InitStructure.USART_StopBits = USART_StopBits_1;      //停止位
    USART_InitStructure.USART_Parity = USART_Parity_No;         //校验位
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//硬件控制流
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //串口模式
    USART_Init(UART4, &USART_InitStructure);  // Configure USART3 配置 串口发送方式寄存器
    


    USART_ITConfig(UART4, USART_IT_RXNE, ENABLE); 
    USART_Cmd(UART4, ENABLE);   


}


//串口1,printf 函数
//确保一次发送数据不超过USART1_MAX_SEND_LEN字节
void WIFI_u1_printf(char* fmt,...)  
{  
u16 i,j; 
va_list ap; 
va_start(ap,fmt);
vsprintf((char*)WIFI_USART1_TX_BUF,fmt,ap);
va_end(ap);
i=strlen((const char*)WIFI_USART1_TX_BUF); //此次发送数据的长度
for(j=0;j<i;j++) //循环发送数据
{
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET); //循环发送,直到发送完毕   
USART_SendData(USART1,WIFI_USART1_TX_BUF[j]); 
} 
}
//=======USART串口发送字符函数===========//


void Usarts_SendString(USART_TypeDef *USARTx, unsigned char *str, unsigned short len)
{
  unsigned short count = 0;
  
  for(count = 0; count < len; count++)
  {
     USART_SendData(USARTx, *str++);
     while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);
  }
}
/**查找空位**/
uint16_t find_vacany_location(void)
{
uint8_t i=0;
for(i=0;i<120;i++)
{
if(Store_finger_id[i]==0)//当前为空位
{
return  i;
}
}
if(i==120)
{
return 120;//已存满
}
}
/**查找指纹编号在数组中的位置**/
uint16_t find_FingerID_location(uint16_t finger_ID)
{
uint8_t i=0;
for(i=0;i<120;i++)
{
if(Store_finger_id[i]==finger_ID)//指纹编号在数组中的位置
{
return  i;
}
}
if(i==120)
{
return 120;//不存在
}
}


void  fingerPrint_opr_function(void)
{
  uint8_t i=0;
if(fingerprint_op_Command==register_fingerprint)//注册
{
vacany_location=find_vacany_location(); //查找空缺的位
        Send_command_finger(register_fingerprint,vacany_location);
//后面添加ID写入到内部FLASH
//.................
}
else if(fingerprint_op_Command==delete_fingerprint) //删除
{
Send_command_finger(delete_fingerprint,Store_finger_id[Numbering]);
  Store_finger_id[Numbering]=0;
//后面将ID从内部FLASH擦除
  //.................
}
else if(fingerprint_op_Command==delete_ALL_fingerprint) //清除
{
Send_command_finger(delete_ALL_fingerprint,0);

  for(i=0;i<120;i++)
{
Store_finger_id[i]=0;
}
//后面将ID从内部FLASH擦除
//............................
}
else //检测指纹
{
Send_command_finger(verification_fingerprint,0);
}
}
/**
注册指纹流程:
1.发送注册图像获取指令:EF 01 FF FF FF FF 01 00 03 29 00 2D
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 0A
2.发送生产特征值指令:EF 01 FF FF FF FF 01 00 04 02 01(默认缓存区号) 00 08
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 0A 


N++;
if(N>=2)
才往下执行.....


3.发送合并模板指令:EF 01 FF FF FF FF 01 00 03 05 00 09
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 0A 
4.发送存储模板指令:EF 01 FF FF FF FF 01 00 06 01(默认缓存区号) (00 01)(存储ID号) sum(2个字节)
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 0A 
**/
uint8_t Shake_hande_C[12]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x03,0x35,0x00,0x39};
uint8_t register_Get_image_C[12]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x03,0x29,0x00,0x2D};
uint8_t Generating_feature_value_C[13]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x04,0x02,0x01,0x00,0x08};
uint8_t Merge_template_C[12]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x03,0x05,0x00,0x09};
uint8_t Storge_template_C[15]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x06,0x06,0x01,0x00,0x01,0x00,0x00};
uint8_t Right_return[12]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0x03,0x00,0x00,0x0A};
uint8_t Send_register_fingerprint_C(uint16_t Save_ID)
{
static uint8_t step=2;
uint16_t Sum_all=0;
uint16_t  Save_ID_add_1=0;
uint8_t i=0;
static uint8_t register_success_count=1;
Save_ID_add_1=Save_ID+1;
only_Type.only_one_C=0;
only_Type.only_one_S=0;
only_Type.only_one_V=0;
   
switch(step)
{
case  1://握手指令--去掉了--只在检测故障时启用
    
break;
case  2://发送注册图像获取指令
if(only_Type.only_one_R==0)
{
if(fingerprint_T[time_3].start_f==1)//连续注册---第二次
{
  if(fingerprint_T[time_3].end_f==1)//2s到时
{
Stop_Delay(time_3);
Usarts_SendString(Finger_USART, register_Get_image_C, sizeof(register_Get_image_C)/sizeof(uint8_t));
only_Type.only_one_R=1;
Start_Delay(time_1,1000);//ms级
}
}
else
{
Usarts_SendString(Finger_USART, register_Get_image_C, sizeof(register_Get_image_C)/sizeof(uint8_t));
only_Type.only_one_R=1;
Start_Delay(time_1,1000);//ms级
}
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_R=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
step=3;
}
else//返回错误
{
step=2;
fingerprint_retrun=register_Get_image_R_E;
}
if(fingerprint_T[time_2].start_f==1)//连续注册---第二次
{
if(fingerprint_T[time_2].end_f)//10s到时--认为超时了,重新开始注册计数
{
register_success_count=1;
step=2;
fingerprint_op_Command=init;//退出注册指纹--默认查询有无指纹
Stop_Delay(time_2);
}
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
case  3://发送生产特征值指令
Stop_Delay(time_2);//没有超时
if(only_Type.only_one_R==0)
{
  if(register_success_count>=2)
{
Generating_feature_value_C[10]=0x02;//bufferID
}
else
{
Generating_feature_value_C[10]=0x01;//bufferID
}
for(i=6;i<11;i++)
{
Sum_all+=Generating_feature_value_C[i];
}
Generating_feature_value_C[11]=Sum_all>>8;
Generating_feature_value_C[12]=Sum_all&0xff;
Sum_all=0;//防止对下面影响
Usarts_SendString(Finger_USART, Generating_feature_value_C, sizeof(Generating_feature_value_C)/sizeof(uint8_t));
only_Type.only_one_R=1;
Start_Delay(time_1,1000);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_R=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
  if(register_success_count>=2)//注册了两次了
{
step=4;
}
else//再注册一次
{
step=2;
Start_Delay(time_2,10000);//ms级--10s超时标志--第二次的注册时间间隔
Start_Delay(time_3,2000);//ms级--时间间隔2s后第二次发送获取图像指令--因为间隔太短,会检测到上一次的指纹,没有按指纹而认为有手指按下
}
Beep_count=2;
  register_success_count++;
}
else//返回错误---重新注册
{
register_success_count=1;
step=3;
Beep_count=20;//提示要重新注册指纹
fingerprint_retrun=Generating_feature_value_R_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
case  4://发送合并模板指令
if(register_success_count>=2)
{
if(only_Type.only_one_R==0)
{
Usarts_SendString(Finger_USART, Merge_template_C, sizeof(Merge_template_C)/sizeof(uint8_t));
only_Type.only_one_R=1;
Start_Delay(time_1,400);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_R=0;
register_success_count=1;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
step=5;
}
else//返回错误
{
step=4;
fingerprint_retrun=Merge_template_R_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
}
break;
case  5://发送存储模板指令
if(only_Type.only_one_R==0)
{
Storge_template_C[11]=Save_ID_add_1>>8;
Storge_template_C[12]=Save_ID_add_1&0xff;
for(i=6;i<13;i++)
{
Sum_all+=Storge_template_C[i];
}
Storge_template_C[13]=Sum_all>>8;
Storge_template_C[14]=Sum_all&0xff;
Usarts_SendString(Finger_USART, Storge_template_C, sizeof(Storge_template_C)/sizeof(uint8_t));
only_Type.only_one_R=1;
Start_Delay(time_1,1000);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_R=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
step=6;
}
else//返回错误
{
step=5;
fingerprint_retrun=Storge_template_R_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
default:
break;
}
if(step==6)
{
  Store_finger_id[Save_ID]=Save_ID_add_1;//存储指纹
fingerprint_retrun=Success;
  fingerprint_op_Command=init;
step=2;
Beep_count=5;//提示注册成功
}
return fingerprint_retrun;
}
/**
验证指纹指令:


1.发送验证图像获取指令:EF 01 FF FF FF FF 01 00 03 01 00 05
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 0A
2.发送生产特征值指令:EF 01 FF FF FF FF 01 00 04 02 01(默认缓存区号) 00 08   
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 0A 
3.搜索当前指纹指令:EF 01 FF FF FF FF 01 00 07 3E (00 00)(指纹可编号起始位置) (00 77)(指纹可编号终点位置) 00 BD
搜索到了正确返回:EF 01 FF FF FF FF 07 00 07 00 PageID(2字节) Matchscore(2字节) sum(2字节)
**/
uint8_t verification_Get_image_C[12]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x03,0x01,0x00,0x05};
uint8_t Find_fingerprint_C[16]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x07,0x3E,0x00,0x00,0x00,0x77,0x00,0xBD};
uint8_t  Send_verification_fingerprint_C(uint16_t Save_ID)
{
static uint8_t step=2;
uint16_t fingerID=0,Sum_all=0;
uint8_t  i=0;
only_Type.only_one_C=0;
only_Type.only_one_R=0;
only_Type.only_one_S=0;
switch(step)
{
case  1://握手指令

case  2://发送验证图像获取指令
if(only_Type.only_one_V==0)
{
Usarts_SendString(Finger_USART, verification_Get_image_C, sizeof(verification_Get_image_C)/sizeof(uint8_t));
only_Type.only_one_V=1;
Start_Delay(time_1,500);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_V=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
step=3;
}
else//返回错误
{
  step=2;
fingerprint_retrun=verification_Get_image_V_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
case  3://发送生产特征值指令
if(only_Type.only_one_V==0)
{
Generating_feature_value_C[10]=0x01;//(默认缓存区号)
for(i=6;i<11;i++)
{
Sum_all+=Generating_feature_value_C[i];
}
Generating_feature_value_C[11]=Sum_all>>8;
Generating_feature_value_C[12]=Sum_all&0xff;
Sum_all=0;//防止对下面影响
Usarts_SendString(Finger_USART, Generating_feature_value_C, sizeof(Generating_feature_value_C)/sizeof(uint8_t));
only_Type.only_one_V=1;
Start_Delay(time_1,500);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_V=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
step=4;
}
else//返回错误
{
step=3;
fingerprint_retrun=Generating_feature_value_V_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
case  4://搜索当前指纹指令
if(only_Type.only_one_V==0)
{
Usarts_SendString(Finger_USART, Find_fingerprint_C, sizeof(Find_fingerprint_C)/sizeof(uint8_t));
only_Type.only_one_V=1;
Start_Delay(time_1,1000);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_V=0;
Stop_Delay(time_1);
/*指纹存储正确返回:EF 01 FF FF FF FF 07 00 07 00 PageID(2字节) Matchscore(2字节) sum(2字节)--所以比较前10个字节数据*/   
if(finger_rec_Info.usartBuf[9]==0)
{
step=5;
  fingerID=(finger_rec_Info.usartBuf[10]<<8)+(finger_rec_Info.usartBuf[11]);
find_person_C.Matchscore=(finger_rec_Info.usartBuf[12]<<8)+(finger_rec_Info.usartBuf[13]);
  find_person_C.Open_door_person=find_FingerID_location(fingerID);
}
else//返回错误
{
step=2;
Beep_count=2;//没有找到--响两声提示-重新按手指
fingerprint_retrun=Find_fingerprint_V_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
default:
break;
}
if(step==5)
{
fingerprint_retrun=Success;
fingerprint_op_Command=init;
Beep_count=8;
  step=2;
}
return fingerprint_retrun;
}
/**
1.握手指令:EF 01 FF FF FF FF 01 00 03 35 00 39
正常指纹模块返回:EF 01 FF FF FF FF 07 00 03 00 00 0A 
2.删除模板指令:EF 01 FF FF FF FF 01 00 07 0c (00 01)(指纹库编号) (00 01)(删除的个数) sum
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 sum
3.清空指纹库指令:EF 01 FF FF FF FF 01 00 03 0d 00 11
正确返回:EF 01 FF FF FF FF 07 00 03 00 00 sum
**/
uint8_t Delete_fingerprint_C[16]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x07,0x0c,0x00,0x01,0x00,0x01,0x00,0x16};
uint8_t Clear_fingerprint_C[12]={0xEF,0x01,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x03,0x0d,0x00,0x11};
uint8_t  Send_delete_fingerprint_C(uint8_t type,uint16_t page_ID,uint8_t dele_fingerprint_num)
{
static uint8_t step=2;
uint16_t Sum_all=0;
uint8_t i=0;
only_Type.only_one_R=0;
only_Type.only_one_S=0;
only_Type.only_one_V=0;
    if(type==delete_ALL_fingerprint)
{
step=3;
}
else
{
step=2;
}
switch(step)
{
case  1://握手指令

break;
case  2://删除模板指令
if(only_Type.only_one_C==0)
{
for(i=6;i<14;i++)
{
Sum_all+=Delete_fingerprint_C[i];
}
Delete_fingerprint_C[10]=(page_ID+1)>>8;
Delete_fingerprint_C[11]=(page_ID+1)&0xff;
Delete_fingerprint_C[12]=dele_fingerprint_num>>8;
Delete_fingerprint_C[13]=dele_fingerprint_num&0xff;
Delete_fingerprint_C[14]=Sum_all>>8;
Delete_fingerprint_C[15]=Sum_all&0xff;
Usarts_SendString(Finger_USART, Delete_fingerprint_C, sizeof(Delete_fingerprint_C)/sizeof(uint8_t));
only_Type.only_one_C=1;
Start_Delay(time_1,300);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_C=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
step=4;
}
else//返回错误
{
step=2;
fingerprint_retrun=Delete_fingerprint_C_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
case  3://清空指纹库指令
if(only_Type.only_one_C==0)
{
Usarts_SendString(Finger_USART, Clear_fingerprint_C, sizeof(Clear_fingerprint_C)/sizeof(uint8_t));
only_Type.only_one_C=1;
Start_Delay(time_1,300);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_C=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
step=4;
}
else//返回错误
{
step=3;
fingerprint_retrun=Clear_fingerprint_C_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
default:
break;
}
if(step==4)
{
Store_finger_id[page_ID]=0;//清掉删除的指纹编号
fingerprint_retrun=Success;
fingerprint_op_Command=init;
if(type==delete_ALL_fingerprint)
{
step=3;
}
else
{
step=2;
}
  Beep_count=10;
}
return fingerprint_retrun;
}


/**
测试指纹模块是否正常:
1.握手指令:EF 01 FF FF FF FF 01 00 03 35 00 39
正常指纹模块返回:EF 01 FF FF FF FF 07 00 03 00 00 0A 
**/
uint8_t  Send_delete_shake_hander_C(void)
{
static uint8_t step=1;
only_Type.only_one_C=0;
only_Type.only_one_R=0;
only_Type.only_one_V=0;
switch(step)
{
case  1://握手指令
if(only_Type.only_one_S==0)
{
Usarts_SendString(Finger_USART, Shake_hande_C, sizeof(Shake_hande_C)/sizeof(uint8_t));
only_Type.only_one_S=1;
Start_Delay(time_1,4000);//ms级
}
if(fingerprint_T[time_1].end_f==1)//到时了
{
only_Type.only_one_S=0;
Stop_Delay(time_1);
if(memcmp(Right_return,finger_rec_Info.usartBuf,sizeof(Right_return)/sizeof(uint8_t))==0)
{
fingerprint_retrun=Success;
  Beep_count=1;
}
else//返回错误
{
fingerprint_retrun=Shake_hande_C_E;
}
memset(finger_rec_Info.usartBuf,0,sizeof(finger_rec_Info.usartBuf)/sizeof(unsigned char));
finger_rec_Info.usartLen=0;
}
break;
default :
break;
}

}
/**


**/
uint8_t  Send_command_finger(uint8_t Operation,uint16_t save_id)
{ 
uint8_t error_type=Success;
    uint8_t Fingerprint_num=1;//一次只删除一枚指纹
switch(Operation)
{
case  register_fingerprint://注册指纹流程
    error_type=Send_register_fingerprint_C(save_id);
break;
case  verification_fingerprint://验证指纹指令
error_type=Send_verification_fingerprint_C(0);
break;
case  delete_fingerprint://删除模板指令
error_type=Send_delete_fingerprint_C(delete_fingerprint,save_id,Fingerprint_num);
break;
case  delete_ALL_fingerprint://清空指纹库指令
error_type=Send_delete_fingerprint_C(delete_ALL_fingerprint,0,0);
break;
case  shake_hander_to_test_normal://检测指纹是否工作正常
error_type=Send_delete_shake_hander_C();
break;
default:
break;

}
return error_type;
}






//****蜂鸣器*******//


void beep_count(void)
{
    static uint16_t  beep_c=0;
if(Beep_count>0)
{
beep_c++;
  if(beep_c<2000)//0.2s
{
GPIO_SetBits(beep_GPIO_PORT,beep_GPIO_PIN);
}
else if(beep_c<4000)
{
GPIO_ResetBits(beep_GPIO_PORT,beep_GPIO_PIN);
}
else
{
beep_c=0;
Beep_count--;
  GPIO_ResetBits(beep_GPIO_PORT,beep_GPIO_PIN);
}
}
}
void beep_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.GPIO_Pin = beep_GPIO_PIN;           电池充满检测
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;             // 推挽输出
GPIO_Init(beep_GPIO_PORT, &GPIO_InitStructure);


}

STM32定时器.C文件

#include "timer3.h"
#include "wifi_uart1.h"

Time  fingerprint_T[TIME_count];

//通用定时器3中断初始化
//这里时钟选择为APB1的2倍，而APB1为36M
//arr：自动重装值。
//psc：时钟预分频数
//这里使用的是定时器3!
void TIM3_Int_Init(u16 arr,u16 psc)
{
  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
NVIC_InitTypeDef NVIC_InitStructure;


RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //时钟使能

//定时器TIM3初始化
TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值
TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值
TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位
 
TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); //使能指定的TIM3中断,允许更新中断


//中断优先级NVIC设置
NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级0级   //0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;  //从优先级3级   0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
NVIC_Init(&NVIC_InitStructure);  //初始化NVIC寄存器


//  TIM_Cmd(TIM3, DISABLE);  //使能TIMx
TIM_Cmd(TIM3, ENABLE);  //使能TIMx  
}
//定时器3中断服务程序
void TIM3_IRQHandler(void)   //TIM3中断100us
{
  static uint8_t  count_tim3=0;
  uint8_t i=0;
if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
{
  for(i=0;i<TIME_count;i++)
{
if(fingerprint_T[i].start_f==1)
{
count_tim3++;
if(count_tim3>10)//1ms
{
count_tim3=0;
fingerprint_T[i].count++;
if(fingerprint_T[i].count>fingerprint_T[i].T)
{
fingerprint_T[i].count=0;
fingerprint_T[i].end_f=1;
}
}
}
}

beep_count();



TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIMx更新中断标志 
}
}
//Time_X:软定时器编号
//time:定时时间
void Start_Delay(uint16_t Time_X,uint16_t time)
{
fingerprint_T[Time_X].count=0;
fingerprint_T[Time_X].end_f=0;
  fingerprint_T[Time_X].start_f=1;
  fingerprint_T[Time_X].T=time;
}
void Stop_Delay(uint16_t Time_X)
{
fingerprint_T[Time_X].count=0;
fingerprint_T[Time_X].end_f=0;
  fingerprint_T[Time_X].start_f=0;
  fingerprint_T[Time_X].T=0;
}
STM32定时器.h文件

#ifndef __TIMER_H
#define __TIMER_H
#include "stm32f10x.h"
#include "stdbool.h"


#define TIME_count  3
#define time_1  0
#define time_2  1
#define time_3  2


typedef struct  T
{
bool start_f;
bool end_f;
uint16_t  count;
uint16_t  T;
}Time;
extern Time  fingerprint_T[TIME_count];


void Start_Delay(uint16_t Time_X,uint16_t time);
void Stop_Delay(uint16_t Time_X);
void TIM3_Int_Init(u16 arr,u16 psc);


 
#endif