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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 做指纹识别系统时，指纹模块程序与其它程序不能同时运行 ...
返回列表 发新帖
查看: 3105|回复: 1
打印 上一主题 下一主题
收起左侧

做指纹识别系统时，指纹模块程序与其它程序不能同时运行是咋回事？

[复制链接]
跳转到指定楼层
楼主
ID:326898 发表于 2018-5-10 15:44 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. #include<reg52.h>
  2. #include <intrins.h>
  3. #include <string.h>
  4. //#include<SHIJIAN.H>
  5. typedef unsigned char u8;                 // 重命名类型u8简化代码编写
  6. typedef unsigned int u16;
  7. #define LCD1602_DATA_PORT P0
  8. #define KEY_PORT P1                // 矩阵按键接在P1端口
  9. //#define DDD                                P2
  10. sbit DSIO = P3^4;                 // DS1302的SPI接口IO线，输入输出都走这里
  11. sbit CE   = P3^5;                // chip enable，读写ds1302前要使能，读写完要禁止
  12. sbit SCLK = P3^6;                   // serial clock，串行时钟线
  13. sbit gLcd1602_E=P2^7;
  14. sbit gLcd1602_RS=P2^6;
  15. sbit gLcd1602_RW=P2^5;
  16. sbit buzz=P1^5;
  17. sbit KEY_DOWN=P3^2;
  18. sbit KEY_OK=P3^3;
  19. sbit KEY_CANCEL=P3^1;
  20. sbit KEY_QIE=P3^0;
  21. sbit KEY_JIA=P1^1;
  22. sbit KEY_TIAO=P1^0;
  23. char local_date=0,base_date=0;
  24. u8 hour=0,minute=0,second=0,count=0;
  25. u8 slnum=0,cishu=0;
  26. code u8 SHIJIAN[60]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
  27. 0x19,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x40,0x41,
  28. 0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59};
  29. code unsigned char FPM10A_Get_Device[10] ={0x01,0x00,0x07,0x13,0x00,0x00,0x00,0x00,0x00,0x1b};//口令验证
  30. code unsigned char FPM10A_Pack_Head[6] = {0xEF,0x01,0xFF,0xFF,0xFF,0xFF};  //协议包头
  31. code unsigned char FPM10A_Get_Img[6] = {0x01,0x00,0x03,0x01,0x00,0x05};    //获得指纹图像
  32. code unsigned char FPM10A_Get_Templete_Count[6] ={0x01,0x00,0x03,0x1D,0x00,0x21 }; //获得模版总数
  33. code unsigned char FPM10A_Search[11]={0x01,0x00,0x08,0x04,0x01,0x00,0x00,0x03,0xE7,0x00,0xF8}; //搜索指纹搜索范围0 - 999,使用BUFFER1中的特征码搜索
  34. code unsigned char FPM10A_Search_0_9[11]={0x01,0x00,0x08,0x04,0x01,0x00,0x00,0x00,0x13,0x00,0x21}; //搜索0-9号指纹
  35. code unsigned char FPM10A_Img_To_Buffer1[7]={0x01,0x00,0x04,0x02,0x01,0x00,0x08}; //将图像放入到BUFFER1
  36. code unsigned char FPM10A_Img_To_Buffer2[7]={0x01,0x00,0x04,0x02,0x02,0x00,0x09}; //将图像放入到BUFFER2
  37. code unsigned char FPM10A_Reg_Model[6]={0x01,0x00,0x03,0x05,0x00,0x09}; //将BUFFER1跟BUFFER2合成特征模版
  38. code unsigned char FPM10A_Delete_All_Model[6]={0x01,0x00,0x03,0x0d,0x00,0x11};//删除指纹模块里所有的模版
  39. volatile unsigned char  FPM10A_Save_Finger[9]={0x01,0x00,0x06,0x06,0x01,0x00,0x0B,0x00,0x19};//将BUFFER1中的特征码存放到指定的位置
  40. code u8 DS1302_READ_ADDR[7] = {0x81, 0x83, 0x85, 0x87, 0x89, 0x8b, 0x8d};
  41. code u8 DS1302_WRITE_ADDR[7] = {0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c};
  42. xdata u8 gTime[7];                                       // 用来存储DS1302中7个时间的BCD码值
  43. xdata u8 gDispBuf0[17];                                        // LCD1602上面一排的显示buf
  44. xdata u8 gDispBuf1[17];        
  45. volatile unsigned char FPM10A_RECEICE_BUFFER[32];
  46. void Buzz_Times(unsigned char times);
  47. void zhishideng(u8 val);
  48. u8 KeyScan(void);
  49. void Uart_Init(void);
  50. void Uart_Send_Byte(unsigned char c);
  51. unsigned char Uart_Receive_Byte();
  52. void FPM10A_Cmd_Send_Pack_Head(void);
  53. void FPM10A_Cmd_Check(void);
  54. void FPM10A_Receive_Data(unsigned char ucLength);
  55. void FPM10A_Cmd_Get_Img(void);
  56. void FINGERPRINT_Cmd_Img_To_Buffer1(void);
  57. void FINGERPRINT_Cmd_Img_To_Buffer2(void);
  58. void FPM10A_Cmd_Search_Finger(void);
  59. void FPM10A_Cmd_Reg_Model(void);
  60. void FINGERPRINT_Cmd_Delete_All_Model(void);
  61. void FPM10A_Cmd_Save_Finger( unsigned int storeID );
  62. void FPM10A_Add_Fingerprint();
  63. void FPM10A_Find_Fingerprint();
  64. void FPM10A_Delete_All_Fingerprint();
  65. void Device_Check(void);
  66. static void fun1();
  67. static void fun2();        

  69. void delay(u16 z)
  70. {
  71.         u16 x,y,a;
  72.         for(x=z;x>0;x--)
  73.                 for(y=142;y>0;y--);
  74.                         for(a=2;a>0;a--);

  76.                
  77. }
  78. //static void delay5ms(void);
  79. static void Lcd1602WaitNoBusy(void)  //忙检测函数，判断bit7是0，允许执行；1禁止
  80. {
  81.     u8 sta = 0;      //

  83.     LCD1602_DATA_PORT = 0xff;
  84.     gLcd1602_RS = 0;
  85.     gLcd1602_RW = 1;
  86.     do
  87.     {
  88.         gLcd1602_E = 1;
  89.         sta = LCD1602_DATA_PORT;
  90.         gLcd1602_E = 0;    //使能，用完就拉低，释放总线
  91.     }while(sta & 0x80);
  92. }
  93. static void Lcd1602WriteCmd(u8 cmd)         
  94. {
  95.         Lcd1602WaitNoBusy();                // 先等待LCD1602处于不忙状态

  97.         gLcd1602_E = 0;                     // 禁止LCD
  98.         gLcd1602_RS = 0;                           // 选择发送命令模式
  99.         gLcd1602_RW = 0;                           // 选择写入模式        
  100.         LCD1602_DATA_PORT = cmd;    // 将1字节命令字放入8位并行数据端口
  101.         gLcd1602_E = 1;                          // 使能LED
  102.         gLcd1602_E = 0;                                // 禁止LCD
  103. }
  104. static void Lcd1602WriteData(u8 dat)                        
  105. {
  106.         Lcd1602WaitNoBusy();                // 先等待LCD1602处于不忙状态

  108.         gLcd1602_E = 0;                     // 禁止LCD
  109.         gLcd1602_RS = 1;                           // 选择发送数据模式
  110.         gLcd1602_RW = 0;                           // 选择写入模式        
  111.         LCD1602_DATA_PORT = dat;    // 将1字节命令字放入8位并行数据端口
  112.         gLcd1602_E = 1;                          // 使能LED
  113.         gLcd1602_E = 0;                                // 禁止LCD
  114. }
  115. void Lcd1602Init(void)                                                
  116. {
  117.          Lcd1602WriteCmd(0x38);          // 按照数据手册的初始化时序，先发送38H
  118.         delay(5);                                        // 延时5ms
  119.         Lcd1602WriteCmd(0x38);          // 按照数据手册的初始化时序，先发送38H
  120.         delay(5);                                        // 延时5ms
  121.         Lcd1602WriteCmd(0x38);          // 按照数据手册的初始化时序，先发送38H
  122.         delay(5);                                        // 延时5ms
  123.         Lcd1602WriteCmd(0x38);                // 显示模式设置
  124.         Lcd1602WriteCmd(0x08);                // 关闭显示
  125.         Lcd1602WriteCmd(0x01);                // 清屏（同时清数据指针）
  126.         Lcd1602WriteCmd(0x06);                // 读写后指针自动加1，写1个字符后整屏显示不移动
  127.         Lcd1602WriteCmd(0x0c);                // 开显示，不显示光标
  128. }
  129. void Lcd1602SetCursor(u8 x, u8 y)          // 坐标显示
  130. {
  131.     u8 addr = 0;

  133.            switch (y)
  134.         {
  135.                 case 0:                                                 // 上面一行
  136.                         addr = 0x00 + x;                break;        
  137.                 case 1:                                                // 下面一行
  138.                         addr = 0x40 + x;                 break;
  139.                 default:
  140.                                                                         break;
  141.         }
  142.     Lcd1602WriteCmd(addr | 0x80);
  143. }
  144. void Lcd1602ShowStr(u8 x, u8 y, u8 *pStr)     //显示字符串
  145. {
  146.     Lcd1602SetCursor(x, y);      //当前字符的坐标
  147.     while (*pStr != '\0')
  148.     {
  149.         Lcd1602WriteData(*pStr++);
  150.     }
  151. }
  152. void Lcd1602DispBufInit(void)
  153. {
  154.         strcpy(gDispBuf0,"00:00:00        ");
  155.         //gDispBuf0[14] = 0xdf;                // 显示摄氏度的小圆圈
  156.         //gDispBuf0[15] = 'C';                        // 显示摄氏度的大写C
  157.         //gDispBuf0[16] = '\0';                // 字符串结尾

  159.         //strcpy(gDispBuf1, "00 00 00EEOK-00H");               
  160. }


  163. void Lcd1602UpdateDisplay(void)
  164. {
  165.         Lcd1602ShowStr(0, 0,"menjingxitong  ");        
  166.         Lcd1602ShowStr(0, 1, gDispBuf0);
  167. }
  168. /*void write_hms(u8 add,u8 dat)          //时分秒写函数，add:输入位置设置变量   dat：输入时分秒数据
  169. {
  170.         u8 sw,gw;                                         //定义十位个位变量
  171.         sw=dat/10;
  172.         gw=dat%10;
  173.         Lcd1602WriteCmd(0x80+0x40+add);//从第二行（add）位开始写数据
  174.         Lcd1602WriteData(0x30+sw);         //写入十位
  175.         Lcd1602WriteData(0x30+gw);         //写入个位
  176. }  */
  177. static void Ds1302WriteReg(u8 addr, u8 dat)
  178. {
  179.         u8 i = 0;

  181.         CE = 0;
  182.         _nop_();                                // 空指令，延时

  184.         SCLK = 0;                                // 先将SCLK置低电平
  185.         _nop_();

  187.         CE = 1;                                 // CE拉高以使能对DS1302的读写权限
  188.         _nop_();

  190.         for (i=0; i<8; i++)                // 循环逐位发送addr的8个bit，注意低位在前
  191.         {
  192.                 DSIO = addr & 0x01;        // 数据从LSB低位开始传送
  193.                 addr >>= 1;                        // 发完后addr右移一位原来的次低位变成新的低位
  194.                 SCLK = 1;                        // 拉高SCLK制造一个上升沿，通知DS1302读取数据
  195.                 _nop_();                        // 延时等待DS1302读取DSIO线上的1位数据

  197.                 SCLK = 0;                        // 读完后，拉低SCLK为下一个位的传输做准备
  198.                 _nop_();
  199.         }
  200.                                                         // 循环结束后1字节的寄存器地址传给DS1302
  201.         for (i=0; i<8; i++)                // 循环写入8位数据，注意低位在前
  202.         {
  203.                 DSIO = dat & 0x01;
  204.                 dat >>= 1;
  205.                 SCLK = 1;                        //制造上升沿通知DS1302读取数据
  206.                 _nop_();
  207.                 SCLK = 0;
  208.                 _nop_();        
  209.         }                                                   // 循环结束后1字节值成功传给DS1302
  210.                  
  211.         CE = 0;                                        // 写入完毕拉低CE以禁止对DS1302的读写，防止意外改写事故
  212.         _nop_();
  213. }


  216. /*********************************************************************
  217. * 函 数 名       : Ds1302ReadReg
  218. * 函数功能                 : 向DS1302中地址为addr的寄存器写入数值dat
  219. * 参数列表       : addr - 待读出的寄存器的地址
  220. * 函数输出             : 读出的寄存器addr的数值
  221. *********************************************************************/
  222. static u8 Ds1302ReadReg(u8 addr)
  223. {
  224.         u8 i = 0, dat = 0, dat1 = 0;

  226.         CE = 0;                                                          // CE设置为初始状态
  227.         _nop_();

  229.         SCLK = 0;                                                // SCLK设置为初始状态
  230.         _nop_();

  232.         CE = 1;                                                        // 拉高CE使能对DS1302的寄存器读写权限
  233.         _nop_();

  235.         for (i=0; i<8; i++)                                // 循环发送8bit寄存器地址值
  236.         {
  237.                 DSIO = addr & 0x01;                        // DS1302的SPI接口从LSB开始发送
  238.                 addr >>= 1;

  240.                 SCLK = 1;                                        // 制造上升沿，DS1302在上升沿完成读取动作
  241.                 _nop_();

  243.                 SCLK = 0;                                        // 拉低SCLK为下个bit发送做准备
  244.                 _nop_();
  245.         }
  246.         
  247.         for (i=0; i<8; i++)                                // 循环读取8bit寄存器值数据
  248.         {
  249.                 dat1 = DSIO;//从最低位开始接收
  250.                 dat = (dat>>1) | (dat1<<7);
  251.                 SCLK = 1;
  252.                 _nop_();
  253.                 SCLK = 0;//DS1302下降沿时，放置数据
  254.                 _nop_();
  255.         }

  257.         CE = 0;
  258.         _nop_();        //以下为DS1302复位的稳定时间,必须的。

  260.         SCLK = 1;
  261.         _nop_();

  263.         DSIO = 0;
  264.         _nop_();

  266.         DSIO = 1;
  267.         _nop_();

  269.         return dat;        
  270. }


  273. /*********************************************************************
  274. * 函 数 名       : Ds1302WriteTime
  275. * 函数功能                 : 将全局变量gTime中的时间写入DS1302中以重置DS1302时间
  276. * 参数列表       : 无
  277. * 函数输出             : 无
  278. *********************************************************************/
  279. static void Ds1302WriteTime(void)
  280. {
  281.         u8 i = 0;

  283.         Ds1302WriteReg(0x8E, 0x00);                 // 禁用WP以获取写时间寄存器的权限
  284.         for (i=0; i<7; i++)                         // 依次写入7个时间，顺序依次：秒分时日月周年
  285.         {
  286.                 Ds1302WriteReg(DS1302_WRITE_ADDR[i], gTime[i]);        
  287.         }
  288.         Ds1302WriteReg(0x8E, 0x80);                 // 使能WP以禁止对时间寄存器的读写，防止意外改写事故
  289. }


  292. /*********************************************************************
  293. * 函 数 名       : Ds1302InitTime
  294. * 函数功能                 : 以给定的初始时间来重置DS1302时间值
  295. * 参数列表       : 无
  296. * 函数输出             : 无
  297. *********************************************************************/
  298. void Ds1302InitTime(void)
  299. {
  300.         // 先给个初始化时间
  301.         gTime[0] = 0x50;        // 初始化时间，秒，注意是BCD码不是10进制也不是16进制
  302.         gTime[1] = 0x59;        // 初始化时间，分，注意是BCD码不是10进制也不是16进制
  303.         gTime[2] = 0x23;        // 初始化时间，时，注意是BCD码不是10进制也不是16进制
  304.         
  305.         
  306.         //gTime[3] = 0x23;        // 初始化时间，日，注意是BCD码不是10进制也不是16进制
  307.         //gTime[4] = 0x10;        // 初始化时间，月，注意是BCD码不是10进制也不是16进制
  308.         //gTime[5] = 0x01;        // 初始化时间，周，注意是BCD码不是10进制也不是16进制
  309.         //gTime[6] = 0x17;        // 初始化时间，年，注意是BCD码不是10进制也不是16进制，以2000为基数
  310.         // 将给定时间写入DS1302内部时间寄存器以完成初始化
  311.         Ds1302WriteTime();
  312. }


  315. /*********************************************************************
  316. * 函 数 名       : Ds1302ReadTime
  317. * 函数功能                 : 读出DS1302内部时间放入全局变量gTime中
  318. * 参数列表       : 无
  319. * 函数输出             : 无
  320. *********************************************************************/
  321. void Ds1302ReadTime(void)
  322. {
  323.         u8 i = 0;

  325.         for (i=0; i<7; i++)//读取7个字节的时钟信号：秒分时日月周年
  326.         {
  327.                 gTime[i] = Ds1302ReadReg(DS1302_READ_ADDR[i]);
  328. //                gTime[i] = 0x23;
  329.         }
  330. }


  333. /*********************************************************************
  334. * 函 数 名       : Ds1302ReadTime
  335. * 函数功能                 : 读出DS1302内部时间放入全局变量gTime中
  336. * 参数列表       : 无
  337. * 函数输出             : 无
  338. *********************************************************************/
  339. void Ds1302WorkTest(void)
  340. {
  341.         // 第1步：从DS1302读取时间存入gTime中
  342.         Ds1302ReadTime();                  

  344.         // 第2步：将gTime中的时间值格式化为字符串存入gTimeStr中
  345.         gDispBuf0[0] = ((gTime[2] >> 4) & 0x0f) + '0';                // Hour的高4位
  346.         gDispBuf0[1] = ((gTime[2] >> 0) & 0x0f) + '0';                // Hour的低4位
  347. //        gDispBuf0[2] = ':';                                                                        // 分隔符
  348.         
  349.         gDispBuf0[3] = ((gTime[1] >> 4) & 0x0f) + '0';                // Minute的高4位
  350.         gDispBuf0[4] = ((gTime[1] >> 0) & 0x0f) + '0';                // Minute的低4位
  351. //        gDispBuf0[5] = ':';                                                                        // 分隔符

  353.         gDispBuf0[6] = ((gTime[0] >> 4) & 0x0f) + '0';                // Second的高4位
  354.         gDispBuf0[7] = ((gTime[0] >> 0) & 0x0f) + '0';                // Second的低4位
  355. //        gDispBuf0[8] = '-';        
  356.         
  357. }

  359. void main(void)
  360. {        
  361.         Lcd1602Init();
  362.         // 上面1行给17个字符，超出的最后一个'g'没有被显示
  363.         Lcd1602ShowStr(0, 0, "men jin xi tong ");
  364.         // 下面1行给16个字符，刚好完美显示               
  365.         Lcd1602ShowStr(0, 1, "welcome         ");
  366.         // 最后别忘了打结，不然程序会反复执行，反复刷屏，看到的现象是
  367.         // 屏幕显示抖动。
  368.         //Lcd1602WriteCmd(0x01);
  369.         Uart_Init();
  370.         delay(200);
  371.         Ds1302InitTime();
  372.         Lcd1602DispBufInit();
  373.         gLcd1602_RW=0;
  374.         Device_Check();                           //校对指纹模块是否接入正确，液晶做出相应的提示
  375.         delay(2000);        

  377.         while(1)
  378.         {
  379.                 if(KEY_QIE==0)
  380.                           {
  381.                           while(KEY_QIE==0);
  382.                           //shijian=1;
  383.                           //cishu+=1;
  384.                           if(cishu<2)
  385.                           {
  386.                                   cishu+=1;
  387.                                   if(cishu==2)
  388.                                     cishu=0;
  389.                           }
  390.                           
  391.                          }
  392.                         switch(cishu)
  393.                         {
  394.                                 case 0:  //指纹                                                
  395.                                 fun1();                                                                                                                                                                                                
  396.                                 break;        
  397.                                                 
  398.                                 case 1:         //        时间
  399.                                 fun2();
  400.                                 break;                                         
  401.                         }
  402.    }
  403. }        
  404. static void fun1()
  405. {                    
  406.                         //FPM10A_Cmd_Send_Pack_Head();
  407.                         //FPM10A_Cmd_Check();
  408.                         //FPM10A_Receive_Data(12);
  409.                 //delay(2000);
  410.                         Device_Check();
  411.                         do
  412.                         {
  413.                         Lcd1602WriteCmd(0x01);
  414.                         Lcd1602ShowStr(0, 0, "  search finger ");
  415.                         Lcd1602ShowStr(0, 1, "  Add     delete");
  416.                         if(local_date==0)
  417.                         {
  418.                         
  419.                                 Lcd1602ShowStr(1, 0, "*");
  420.                             Lcd1602ShowStr(1, 1, " ");
  421.                                 Lcd1602ShowStr(9, 1, " ");        
  422.                         }
  423.                         else if(local_date==1)
  424.                         {
  425.                         
  426.                                 Lcd1602ShowStr(1, 0, " ");
  427.                             Lcd1602ShowStr(1, 1, "*");
  428.                                 Lcd1602ShowStr(9, 1, " ");               
  429.                         }
  430.                         else if(local_date==2)
  431.                         {
  432.                                 
  433.                                 Lcd1602ShowStr(1, 0, " ");
  434.                             Lcd1602ShowStr(1, 1, " ");
  435.                                 Lcd1602ShowStr(9, 1, "*");               
  436.                         }                        
  437.                         //确认键        
  438.                         if(KEY_OK==0)
  439.                         {         
  440.                                 while(KEY_OK==0);//等待松开按键                                                        
  441.                                 switch(local_date)
  442.                                 {
  443.                                                 case 0:                //搜索指纹                                                
  444.                                                 FPM10A_Find_Fingerprint();                                                                                                                                                                                                
  445.                                                 break;        
  446.                                                 
  447.                                                 case 1:                      //添加指纹
  448.                                                 FPM10A_Add_Fingerprint();
  449.                                                 break;                                         
  450.                                                 
  451.                                                 case 2:                      //清空指纹
  452.                                                 FPM10A_Delete_All_Fingerprint();
  453.                                                   break;
  454.                                         }
  455.                         }
  456.                             //切换键
  457.                                 if(KEY_DOWN == 0)
  458.                                 {
  459.                                         while(KEY_DOWN == 0); //等待松开按?                        
  460.                                            if(local_date<=2)
  461.                                         {
  462.                                                 local_date++;
  463.                                                 if(local_date==3)
  464.                                                         local_date=0;                                                
  465.                                         }               
  466.                                 }                                                
  467.                                 delay(100); //延时判断100MS检测一次
  468.         }while(KEY_QIE!=0);                 
  469. }                                 
  470.         

  472. static void fun2()
  473. {
  474.         u8 i = 0;
  475.         Lcd1602WriteCmd(0x01);
  476.           Ds1302WorkTest();
  477.         Lcd1602UpdateDisplay();
  478.         if(KEY_TIAO==0)
  479.         {
  480.                 while(KEY_TIAO==0);
  481.                 Ds1302WriteReg(0x8E, 0x00);                 // 禁用WP以获取写时间寄存器的权限
  482.                 slnum++;
  483.                 switch(slnum)
  484.                 {
  485.                         case 1:Lcd1602WriteCmd(0x80+0x40+7);        
  486.                                 break;
  487.                         case 2:Lcd1602WriteCmd(0x80+0x40+4);
  488.                                 break;
  489.                         case 3:Lcd1602WriteCmd(0x80+0x40+1);
  490.                                 break;
  491.                 }
  492.                 Lcd1602WriteCmd(0x0f);
  493.                 if(slnum==4)
  494.                 {
  495.                         slnum=0;
  496.                         Lcd1602WriteCmd(0x0c);
  497.                 }
  498.                 //Ds1302WriteReg(0x8E, 0x80);                 // 禁用WP以获取写时间寄存器的权限
  499.                 }
  500.     if(KEY_JIA==0)
  501.         {
  502.                 while(KEY_JIA==0);
  503.                 switch(slnum)
  504.                 {
  505.                         case 1: second++;
  506.                                         if(second==60) second=0;
  507.                                         Ds1302WriteReg(DS1302_WRITE_ADDR[0], SHIJIAN[second]);
  508.                                     break;
  509.                         case 2:        minute++;
  510.                                         if(minute==60) minute=0;
  511.                                         Ds1302WriteReg(DS1302_WRITE_ADDR[1], SHIJIAN[minute]);
  512.                                         break;
  513.                         case 3: hour++;
  514.                                            if(hour==24) hour=0;
  515.                                         Ds1302WriteReg(DS1302_WRITE_ADDR[2], SHIJIAN[hour]);        
  516.                                         break;
  517.                                        
  518.                 }
  519.         } delay(100);
  520. }


  523. void Uart_Init(void)
  524. {
  525.     SCON=0x50;   //UART方式1:8位UART;   REN=1:允许接收
  526.     PCON=0x00;   //SMOD=0:波特率不加倍
  527.     TMOD=0x20;   //T1方式2,用于UART波特率
  528.     TH1=0xFD;
  529.     TL1=0xFD;   //UART波特率设置:FDFD，9600;FFFF,57600
  530.     TR1=1;         //允许T1计数
  531.     EA=1;
  532. }


  535. void Uart_Send_Byte(unsigned char c)//UART Send a byte
  536. {
  537.         SBUF = c;
  538.         while(!TI);                //发送完为1
  539.         TI = 0;
  540. }

  542. unsigned char Uart_Receive_Byte()//UART Receive a byteg
  543. {        
  544.         unsigned char dat;
  545.         while(!RI);         //接收完为1
  546.         RI = 0;
  547.         dat = SBUF;
  548.         return (dat);
  549. }


  552. void FPM10A_Cmd_Send_Pack_Head(void)
  553. {
  554.         int i;        
  555.         for(i=0;i<6;i++) //包头
  556.    {
  557.      Uart_Send_Byte(FPM10A_Pack_Head[i]);   
  558.     }               
  559. }
  560. //发送指令
  561. void FPM10A_Cmd_Check(void)
  562. {
  563.         int i=0;
  564.         FPM10A_Cmd_Send_Pack_Head(); //发送通信协议包头
  565.         for(i=0;i<10;i++)
  566.          {               
  567.                 Uart_Send_Byte(FPM10A_Get_Device[i]);
  568.           }
  569. }
  570. //接收反馈数据缓冲
  571. void FPM10A_Receive_Data(unsigned char ucLength)
  572. {
  573.   unsigned char i;

  575.   for (i=0;i<ucLength;i++)
  576.      FPM10A_RECEICE_BUFFER[i] = Uart_Receive_Byte();

  578. }

  580. //FINGERPRINT_获得指纹图像命令
  581. void FPM10A_Cmd_Get_Img(void)
  582. {
  583.     unsigned char i;
  584.     FPM10A_Cmd_Send_Pack_Head(); //发送通信协议包头
  585.     for(i=0;i<6;i++) //发送命令 0x1d
  586.         {
  587.        Uart_Send_Byte(FPM10A_Get_Img[i]);
  588.         }
  589. }
  590. //讲图像转换成特征码存放在Buffer1中
  591. void FINGERPRINT_Cmd_Img_To_Buffer1(void)
  592. {
  593.          unsigned char i;
  594.         FPM10A_Cmd_Send_Pack_Head(); //发送通信协议包头      
  595.            for(i=0;i<7;i++)   //发送命令 将图像转换成 特征码 存放在 CHAR_buffer1
  596.      {
  597.       Uart_Send_Byte(FPM10A_Img_To_Buffer1[i]);
  598.              }
  599. }
  600. //将图像转换成特征码存放在Buffer2中
  601. void FINGERPRINT_Cmd_Img_To_Buffer2(void)
  602. {
  603.      unsigned char i;
  604.      for(i=0;i<6;i++)    //发送包头
  605.          {
  606.             Uart_Send_Byte(FPM10A_Pack_Head[i]);   
  607.             }
  608.      for(i=0;i<7;i++)   //发送命令 将图像转换成 特征码 存放在 CHAR_buffer2
  609.       {
  610.               Uart_Send_Byte(FPM10A_Img_To_Buffer2[i]);
  611.              }
  612. }
  613. //搜索全部用户999枚
  614. void FPM10A_Cmd_Search_Finger(void)
  615. {
  616.        unsigned char i;                       
  617.                          FPM10A_Cmd_Send_Pack_Head(); //发送通信协议包头
  618.        for(i=0;i<11;i++)
  619.            {
  620.                   Uart_Send_Byte(FPM10A_Search[i]);   
  621.                       }
  622. }
  623. //将BUFFER1跟BUFFER2合成特征模版
  624. void FPM10A_Cmd_Reg_Model(void)
  625. {
  626.        unsigned char i;           
  627.             
  628.                          FPM10A_Cmd_Send_Pack_Head(); //发送通信协议包头

  630.        for(i=0;i<6;i++)
  631.            {
  632.                   Uart_Send_Byte(FPM10A_Reg_Model[i]);   
  633.                       }
  634. }
  635. //删除指纹模块里的所有指纹模版
  636. void FINGERPRINT_Cmd_Delete_All_Model(void)
  637. {
  638.     unsigned char i;   
  639.     for(i=0;i<6;i++) //包头
  640.     Uart_Send_Byte(FPM10A_Pack_Head[i]);   
  641.     for(i=0;i<6;i++) //命令合并指纹模版
  642.            {
  643.       Uart_Send_Byte(FPM10A_Delete_All_Model[i]);   
  644.            }        
  645. }
  646. //保存指纹
  647. void FPM10A_Cmd_Save_Finger( unsigned int storeID )
  648. {
  649.        unsigned long temp = 0;
  650.            unsigned char i;
  651.        FPM10A_Save_Finger[5] =(storeID&0xFF00)>>8;                 //0x00,0x0B,0x00,0x19.
  652.        FPM10A_Save_Finger[6] = (storeID&0x00FF);
  653.            for(i=0;i<7;i++)   //计算校验和
  654.                    temp = temp + FPM10A_Save_Finger[i];
  655.                    FPM10A_Save_Finger[7]=(temp & 0x00FF00) >> 8; //存放校验数据
  656.                    FPM10A_Save_Finger[8]= temp & 0x0000FF;                  
  657.        FPM10A_Cmd_Send_Pack_Head(); //发送通信协议包头        
  658.        for(i=0;i<9;i++)  
  659.                       Uart_Send_Byte(FPM10A_Save_Finger[i]);      //发送命令 将图像转换成 特征码 存放在 CHAR_buffer1
  660. }

  662. //添加指纹
  663. void FPM10A_Add_Fingerprint()
  664. {
  665.         unsigned char id_show[]={0,0,0};
  666.         u16 finger_id;
  667.         Lcd1602WriteCmd(0x01); //清屏
  668.         finger_id=0;  
  669.         while(1)
  670.         {
  671.         Lcd1602ShowStr(0,0,"  Add finger    ");
  672.         Lcd1602ShowStr(0,1,"  ID:          ");
  673.         
  674.         //按返回键直接回到主菜单
  675.         if(KEY_CANCEL == 0)
  676.         {
  677.                  while(KEY_CANCEL==0);
  678.                  break;
  679.         }

  681.         //按切换键指纹iD值加1
  682.         if(KEY_DOWN == 0)
  683.         {
  684.                 while(KEY_DOWN==0);
  685.                 if(finger_id == 1000)
  686.                 {
  687.                         finger_id = 0;
  688.                 }
  689.                 else
  690.                 finger_id = finger_id + 1;
  691.         }

  693.          //指纹iD值显示处理
  694.          Lcd1602WriteCmd(0xc0+10);
  695.          Lcd1602WriteData(finger_id/100+48);
  696.          Lcd1602WriteData(finger_id%100/10+48);
  697.          Lcd1602WriteData(finger_id%100%10+48);

  699.          //按确认键开始录入指纹信息                                          
  700.          if(KEY_OK == 0)
  701.           {        
  702.                           while(KEY_OK==0);
  703.                           Lcd1602ShowStr(0,0," Please finger ");
  704.                           //LCD1602_Display(0x80," Please  finger ",0,16);
  705.                           //LCD1602_Display(0xc0,"                ",0,16);
  706.                           Lcd1602ShowStr(0,1,"                ");
  707.                         //while(KEY_CANCEL == 1)
  708.                         while(KEY_CANCEL == 1)
  709.                    {
  710.                           //按下返回键退出录入返回fingerID调整状态   
  711.                                 if(KEY_CANCEL == 0)
  712.                                  {
  713.                                   while(KEY_CANCEL==0);
  714.                                   break;
  715.                                   }
  716.                                 FPM10A_Cmd_Get_Img(); //获得指纹图像
  717.                                 FPM10A_Receive_Data(12);
  718.                                 //判断接收到的确认码,等于0指纹获取成功
  719.                                 if(FPM10A_RECEICE_BUFFER[9]==0)
  720.                                  {
  721.                                         //Delay_Ms(100);
  722.                                         delay(100);
  723.                                         FINGERPRINT_Cmd_Img_To_Buffer1();
  724.                                     FPM10A_Receive_Data(12);
  725.                                         Lcd1602ShowStr(0,0,"Successful entry");
  726.                                         //LCD1602_Display(0x80,"Successful entry",0,16);
  727.                                         Buzz_Times(1);
  728.                                         delay(1000);
  729.                                         Lcd1602ShowStr(0,0," Please  finger ");
  730.                                         Lcd1602ShowStr(0,1,"                ");
  731.                                         //LCD1602_Display(0x80," Please  finger ",0,16);
  732.                                           //LCD1602_Display(0xc0,"                ",0,16);
  733.                                         while(1)
  734.                                         {
  735.                                                 if(KEY_CANCEL == 0)
  736.                                                 {
  737.                                                         while(KEY_CANCEL==0);
  738.                                                         break;
  739.                                                 }
  740.                                          FPM10A_Cmd_Get_Img(); //获得指纹图像
  741.                                          FPM10A_Receive_Data(12);
  742.                                         //判断接收到的确认码,等于0指纹获取成功
  743.                                         if(FPM10A_RECEICE_BUFFER[9]==0)
  744.                                         {
  745.                                                 delay(200);
  746.                                                 Lcd1602ShowStr(0,0,"Successful entry");
  747.                                             Lcd1602ShowStr(0,1,"    ID is       ");
  748.                                                 //LCD1602_Display(0x80,"Successful entry",0,16);
  749.                                                 //LCD1602_Display(0xc0,"    ID is       ",0,16);
  750.                                                  //指纹iD值显示处理
  751.                                                  Lcd1602WriteCmd(0xc0+10);
  752.                                                  Lcd1602WriteData(finger_id/100+48);
  753.                                                  Lcd1602WriteData(finger_id%100/10+48);
  754.                                                  Lcd1602WriteData(finger_id%100%10+48);
  755.                                                 FINGERPRINT_Cmd_Img_To_Buffer2();
  756.                                                   FPM10A_Receive_Data(12);
  757.                                                 FPM10A_Cmd_Reg_Model();//转换成特征码
  758.                                          FPM10A_Receive_Data(12);
  759.                                                   FPM10A_Cmd_Save_Finger(finger_id);                                         
  760.                                           FPM10A_Receive_Data(12);
  761.                                                 Buzz_Times(1);
  762.                                                 delay(1000);
  763.                                                 finger_id=finger_id+1;
  764.                                             break;
  765.                                           }
  766.                                    }
  767.                                    
  768.                                 break;
  769.                                         }
  770.                                 }
  771. //                        ClrScreen(); //清空显示屏
  772.                         }  
  773.                 //        Delay_Ms(500);
  774.                 }
  775. }

  777. //搜索指纹
  778. void FPM10A_Find_Fingerprint()
  779. {
  780.         unsigned int find_fingerid = 0;
  781.         unsigned char id_show[]={0,0,0};
  782.         do
  783.         {
  784.                 Lcd1602ShowStr(0,0," Please  finger ");
  785.                 Lcd1602ShowStr(0,1,"                ");
  786.                 //LCD1602_Display(0x80," Please  finger ",0,16);
  787.                 //LCD1602_Display(0xc0,"                ",0,16);
  788.                 FPM10A_Cmd_Get_Img(); //获得指纹图像
  789.                 FPM10A_Receive_Data(12);               
  790.                 //判断接收到的确认码,等于0指纹获取成功
  791.                 if(FPM10A_RECEICE_BUFFER[9]==0)
  792.                 {                        
  793.                         delay(100);
  794.                         FINGERPRINT_Cmd_Img_To_Buffer1();
  795.                         FPM10A_Receive_Data(12);               
  796.                         FPM10A_Cmd_Search_Finger();
  797.                         FPM10A_Receive_Data(16);                        
  798.                         if(FPM10A_RECEICE_BUFFER[9] == 0) //搜索到  
  799.                         {
  800.                                 Lcd1602ShowStr(0,0," Search success ");
  801.                                 Lcd1602ShowStr(0,1,"    ID is       ");
  802.                                 //LCD1602_Display(0x80," Search success ",0,16);
  803.                                 //LCD1602_Display(0xc0,"    ID is       ",0,16);
  804.                                 Buzz_Times(1);                                       
  805.                                 //拼接指纹ID数
  806.                                 find_fingerid = FPM10A_RECEICE_BUFFER[10]*256 + FPM10A_RECEICE_BUFFER[11];                                       
  807.                                  //指纹iD值显示处理
  808.                                  Lcd1602WriteCmd(0xc0+10);
  809.                                  Lcd1602WriteData(find_fingerid/100+48);
  810.                                  Lcd1602WriteData(find_fingerid%100/10+48);
  811.                                  Lcd1602WriteData(find_fingerid%100%10+48);
  812.                                  //LCD1602_WriteCMD(0xc0+10);
  813.                                  //LCD1602_WriteDAT(find_fingerid/100+48);
  814.                                  //LCD1602_WriteDAT(find_fingerid%100/10+48);
  815.                                  //LCD1602_WriteDAT(find_fingerid%100%10+48);                                                
  816.                                 delay(2000);                                
  817.                            }
  818.                                 else //没有找到
  819.                                 {
  820.                                         //LCD1602_Display(0x80," Search  failed ",0,16);
  821.                                         //LCD1602_Display(0xc0,"                ",0,16);
  822.                                         Lcd1602ShowStr(0,0," Search  failed ");
  823.                                         Lcd1602ShowStr(0,1,"                ");
  824.                                          Buzz_Times(3);
  825.                                 }
  826.                         }               
  827.                 }while(KEY_CANCEL == 1);
  828. }
  829. //删除所有存贮的指纹库
  830. void FPM10A_Delete_All_Fingerprint()
  831. {
  832.                 unsigned char i=0;
  833.                                 //LCD1602_Display(0x80,"   empty all    ",0,16);
  834.                                 //LCD1602_Display(0xc0,"   Yes or no ?  ",0,16);
  835.                                 Lcd1602ShowStr(0,0,"   empty all    ");
  836.                                 Lcd1602ShowStr(0,1,"   Yes or no ?  ");
  837.                 do
  838.                  {if(KEY_OK==0)
  839.                         {
  840.                                 while(KEY_OK==0);
  841.                                 //LCD1602_Display(0x80,"   emptying     ",0,16);
  842.                                 //LCD1602_Display(0xc0,"                ",0,16);
  843.                                 Lcd1602ShowStr(0,0,"   emptying     ");
  844.                                 Lcd1602ShowStr(0,1,"                ");
  845.                                 delay(300);
  846.                                 Lcd1602WriteCmd(0xc0);
  847.                                 for(i=0;i<16;i++)
  848.                                  {
  849.                                         Lcd1602WriteData(42);
  850.                                         delay(100);
  851.                                  }
  852.                                 FINGERPRINT_Cmd_Delete_All_Model();
  853.                             FPM10A_Receive_Data(12);
  854.                         //        LCD1602_Display(0x80,"   All empty    ",0,16);
  855.                         //        LCD1602_Display(0xc0,"                ",0,16);
  856.                                 Lcd1602ShowStr(0,0,"   All empty    ");
  857.                                 Lcd1602ShowStr(0,1,"                ");
  858.                                 Buzz_Times(3);
  859.                                 break;
  860.                         }
  861.                  }while(KEY_CANCEL==1);
  862. }

  864. void Device_Check(void)
  865. {
  866.                 unsigned char i=0;
  867.                 FPM10A_RECEICE_BUFFER[9]=1;                                           //串口数组第九位可判断是否通信正常
  868.                 Lcd1602ShowStr(0,1,"Loading     ");              //LCD1602_Display(0xc0,"Loading",0,7);                   //设备加载中界面                                                           
  869.                 for(i=0;i<8;i++)                                                           //进度条式更新，看起来美观
  870.                 {
  871.                         Lcd1602WriteData(42);                               //42对应ASIC码的 *
  872.                         delay(200);                                                           //控制进度条速度
  873.                 }
  874.                 Lcd1602ShowStr(0,1,"failure         ");                        //LCD1602_Display(0xc0,"Docking  failure",0,16);      //液晶先显示对接失败，如果指纹模块插对的话会将其覆盖        
  875.                 FPM10A_Cmd_Check();                                                                        //单片机向指纹模块发送校对命令
  876.                 FPM10A_Receive_Data(12);                                                        //将串口接收到的数据转存
  877.                  if(FPM10A_RECEICE_BUFFER[9]==0)                                        //判断数据低第9位是否接收到0
  878.                 {
  879.                         Lcd1602ShowStr(0,1,"success         ");       //LCD1602_Display(0xc0,"Docking  success",0,16);        //符合成功条件则显示对接成功
  880.                 }
  881. }
  882. void Buzz_Times(unsigned char times)
  883. {
  884.         unsigned char i=0;
  885.         for(i=0;i<times;i++)
  886.         {
  887.                  buzz=0;
  888.                  delay(1);
  889.                  buzz=1;
  890.                  delay(1);
  891.         }
  892. }
复制代码
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:293977 发表于 2018-5-11 17:28 | 只看该作者
你这个问题问的让人难以回答，能说具体点吗？你这个模块我之前用过，我看你程序里波特率设置是9600。这个指纹模块波特率默认是57600，如果你没改过设置的话那就是你串口波特率没设置对。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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