设为首页收藏本站
开启辅助访问

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 基于stm32f4单片机的智能门锁程序设计

基于stm32f4单片机的智能门锁程序设计

查看数: 3399 | 评论数: 2 | 收藏 6
关灯 | 提示：支持键盘翻页<-左 右->
帖子模式
    组图打开中，请稍候......
51小白冬
发布时间: 2022-6-17 14:49

正文摘要:

本设备采用stm32f4  独立按键+as608指纹模块+jdy30蓝牙模块 +7针spi oled显示+24c02 具有 指纹解锁 密码解锁 app解锁 指纹解锁：可对指纹信息进行 增 删 改 查 密码解锁：输入正确密码可解锁 可更改密 ...

回复

ID:474195 发表于 2022-6-17 14:52
程序为早年所写，逻辑不是很好，勿喷
STM32单片机源程序如下:
  1. #include "sys.h"
  2. #include "delay.h"
  3. #include "usart.h"
  4. #include "oled.h"
  5. #include "usart2.h"
  6. #include "gpio.h"
  7. #include "timer.h"
  8. #include "as608.h"
  9. #include "24cxx.h"
  10. #include "myiic.h"
  11. #define moto_down 1400
  12. #define moto_up 2100                   //最大2500
  13. #define time 1000                      //ms
  14. void ifmima(void);                     //密码判断函数
  15. void recivemima(void);                 //串口接收密码函数
  16. void turncode(void);                   //串口密码更改函数
  17. void press_FR(void);                   //刷指纹
  18. void Add_FR(void);                     //验证指纹
  19. void gui(u8 i);                        //界面函数
  20. void gpioinit(void);                   //gpio初始化函数
  21. void Del_FR(void);                     //指纹删除函数
  22. void incode(void);                     //按键输入函数
  23. void tcode(void);                      //按键更改密码函数
  24. u8 key(u8 mode);                       //按键扫描函数
  25. u8 turnstr(u8 d);                      //字符转换还函数
  26. u16 ValidN;                             //模块内有效指纹个数
  27. u8 mima[6]= {'1','1','1','1','1','1'};                //默认密码
  28. u16 shurumima[6]= {'0','0','0','0','0','0'};          //输入密码
  29. u16 turnmima[7]= {'0','0','0','0','0','0','0'};       //更改密码
  30. u16 i,j;
  31. u8 len;           //接收数据的长度;
  32. u8 change=0;      //密码更改标志位 更改1，不更改为0
  33. u8 over=0;        //输入密码结束标志位 完成1
  34. u8 ture=2;        //密码判断标志位 正确1，错误0,等待2
  35. u8 t=0;
  36. u8 reok=0;        //回到主界面标志位 为一回到主界面
  37. int main(void)
  38. {
  39.     PS_StaGPIO_Init();
  40.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  //设置系统中断优先级分组2
  41.     delay_init(168);                                 //初始化延时函数
  42.     pwminit1(84-1,20000-1);
  43.     usart2_init(9600);                               //初始化串口2,用于与指纹模块通讯
  44.     uart_init(9600);                                       //初始化串口波特率为115200
  45.     OLED_Init();                                                             //初始化OLED
  46.     gpioinit();                                      //gpio初始化（按键）
  47.     AT24CXX_Init();                                               //24c02初始化
  48.     while(AT24CXX_Check())                           //等待24c02初始化完毕
  49.     OLED_Clear();
  50.     OLED_ShowCH(0,16,"准备中");
  51.     OLED_Refresh_Gram();
  52.          // AT24CXX_Write(0,(u8*)mima,6);           //       此条用于初始密码 如果密码忘记恢复此条密码初始为111111
  53.     AT24CXX_Read(0,mima,6);
  54.     delay_ms(2000);
  55.     OLED_Clear();                                    //清屏
  56.     gui(0);                                          //主界面
  57.     OLED_Refresh_Gram();                             //更新显示到OLED
  58.     TIM_SetCompare1(TIM3,moto_down);                 //舵机1500-2400  中值1850
  59.     while(1)
  60.     {
  61.         recivemima();                          //调用串口密码接收
  62.         if(reok==1) {
  63.             reok=0;    //如果标志位置一回到主屏
  64.             goto OVER;
  65.         }
  66.         switch(key(0))                           //选择哪个按键被按下
  67.         {
  68.         case 0:                                 //按键0被按下
  69.             gui(1);                               //进入界面1指纹解锁
  70.             while(1)                              //进入循环等待（等待操作结束）
  71.             {
  72.                 delay_ms(100);
  73.                 t++;                                 //延时100ms t加一（5秒无操作退出）
  74.                 switch(key(0))                        //选择次界面 指纹功能选择
  75.                 {
  76.                 case 0:  {
  77.                     Add_FR();     //指纹添加
  78.                     goto OVER;
  79.                 }
  80.                 case 10: {
  81.                     Del_FR();     //指纹删除
  82.                     goto OVER;
  83.                 }
  84.                 case 11: {
  85.                     press_FR();    //指纹验证
  86.                     goto OVER;
  87.                 }
  88.                 }
  89.                 if(t==50) {
  90.                     t=0;    //5秒无操作退出
  91.                     goto OVER;
  92.                 }
  93.             }

  95.         case 10: {
  96.             gui(2);
  97.             while(1)
  98.             {
  99.                 delay_ms(100);
  100.                 t++;
  101.                 switch (key(0))
  102.                 {
  103.                 case 0:
  104.                     while(1) {
  105.                         incode();
  106.                         goto OVER;
  107.                     }
  108.                 case 10:
  109.                     while(1) {
  110.                         tcode();
  111.                         goto OVER;
  112.                     }
  113.                 case 11:
  114.                     goto OVER;
  115.                 }
  116.                 if(t==50) {
  117.                     t=0;
  118.                     goto OVER;
  119.                 }
  120.             }
  121.             /*        case 11:
  122.                     {
  123.                     gui(4);
  124.                     while(1)
  125.                     {
  126.                     if(key(0)==11)goto OVER;

  128.                     if(reok==1)
  129.                     {goto OVER;}
  130.                     }
  131.                     }        */
  132.         }
  133. OVER: {
  134.             OLED_Clear();
  135.             gui(0);
  136.             break;
  137.         }
  138.         }
  139.     }
  140. }

  142. void recivemima(void)                                               //串口接收密码函数
  143. {
  144.     reok=0;                                                             //标志位清零
  145.     if(USART_RX_STA&0x8000)                                             //如果串口有数据发来
  146.     {
  147.         len=USART_RX_STA&0x3fff;                                           //得到此次接收到的数据长度
  148.         for(i=0; i<len; i++)                                               //数据转存
  149.         {
  150.             if(USART_RX_BUF[0]!='t') {
  151.                 shurumima[i]=USART_RX_BUF[i];    //如果没有接收到密码更改标志位数据存储在shurumima中
  152.                 change=0;
  153.             }
  154.             if(USART_RX_BUF[0]=='t') {
  155.                 turnmima[i]=USART_RX_BUF[i];           //如果接收到密码更改标志位数据存储在turnmima中 密码更改标志位置一
  156.                 change=1;
  157.             }
  158.         }
  159.         if(change==0)                                                      //密码更改
  160.         {
  161.             ifmima();                                                         //调用判断函数
  162.             if(ture==1) {
  163.                 OLED_Clear();
  164.                 OLED_ShowCH(0,16,"密码正确");
  165.                 OLED_Refresh_Gram();
  166.                 reok=1;
  167.                 TIM_SetCompare1(TIM3,moto_up);
  168.                 delay_ms(time);
  169.                 TIM_SetCompare1(TIM3,moto_down);
  170.             }
  171.             else {
  172.                 OLED_Clear();
  173.                 OLED_ShowCH(0,16,"密码错误");
  174.                 OLED_Refresh_Gram();
  175.                 reok=1;
  176.                 delay_ms(800);
  177.             }
  178.         }
  179.         if(change==1) {
  180.             turncode();
  181.         }
  182.         USART_RX_STA=0;                                                    //清除中断 标志位
  183.     }
  184. }



  188. void tcode(void)//按键更改密码函数
  189. {
  190.     u8 key1,count=0;
  191.     ture=2;
  192.     incode();                                                   //密码输入函数调用
  193.     if(ture==1)                                                   //输入原密码正确
  194.     {
  195.         OLED_Clear();
  196.         OLED_ShowCH(0,0,"请输新密码");
  197.         OLED_Refresh_Gram();
  198.         key1=key(0);                                                  //获取当前按键值（无按键按下是为15）
  199.         while(1)
  200.         {
  201.             key1=key(0);
  202.             while(key1==15)                                             //等待按键按下
  203.             {
  204.                 key1=key(0);
  205.             }
  206.             count++;                                                  //计算密码个数
  207.             OLED_ShowNum(12,23,count,2,12);
  208.             OLED_Refresh_Gram();
  209.             switch(count)                                              //密码转存
  210.             {
  211.             case 1:
  212.                 mima[0]=turnstr(key1);
  213.                 break;
  214.             case 2:
  215.                 mima[1]=turnstr(key1);
  216.                 break;
  217.             case 3:
  218.                 mima[2]=turnstr(key1);
  219.                 break;
  220.             case 4:
  221.                 mima[3]=turnstr(key1);
  222.                 break;
  223.             case 5:
  224.                 mima[4]=turnstr(key1);
  225.                 break;
  226.             case 6:
  227.                 mima[5]=turnstr(key1);
  228.                 break;
  229.             }
  230.             if(count==6)                                             //密码个数为6位
  231.             {
  232.                 count=0;
  233.                 delay_ms(100);
  234.                 break;
  235.             }
  236.             delay_ms(200);
  237.         }
  238.         AT24CXX_Write(0,(u8*)mima,6);
  239.         OLED_Clear();
  240.         OLED_ShowCH(0,16,"密码修改成功");
  241.         OLED_Refresh_Gram();
  242.         delay_ms(800);
  243.     }
  244.     else
  245.     {
  246.         OLED_Clear();
  247.         OLED_ShowCH(0,16,"密码修改错误");
  248.         OLED_Refresh_Gram();
  249.         delay_ms(800);
  250.         reok=1;
  251.     }
  252. }

  254. void incode(void)                            //按键输入函数
  255. {
  256.     u8 key1,count=0;
  257.     OLED_Clear();
  258.     OLED_ShowCH(0,0,"请输入密码");
  259.     OLED_Refresh_Gram();
  260.     key1=key(0);                               //返回15
  261.     while(1)
  262.     {
  263.         key1=key(0);
  264.         while(key1==15)
  265.         {
  266.             key1=key(0);
  267.         }
  268.         count++;
  269.         switch(count)
  270.         {
  271.         case 1:
  272.             shurumima[0]=turnstr(key1);
  273.             break;
  274.         case 2:
  275.             shurumima[1]=turnstr(key1);
  276.             break;
  277.         case 3:
  278.             shurumima[2]=turnstr(key1);
  279.             break;
  280.         case 4:
  281.             shurumima[3]=turnstr(key1);
  282.             break;
  283.         case 5:
  284.             shurumima[4]=turnstr(key1);
  285.             break;
  286.         case 6:
  287.             shurumima[5]=turnstr(key1);
  288.             break;
  289.         }
  290.         if(count==6)
  291.         {
  292.             count=0;
  293.             ifmima();
  294.             delay_ms(100);
  295.             break;
  296.         }
  297.         delay_ms(200);
  298.     }
  299.     if(ture==1) {
  300.         OLED_Clear();
  301.         OLED_ShowCH(0,16,"密码正确");
  302.         OLED_Refresh_Gram();
  303.         TIM_SetCompare1(TIM3,moto_up);
  304.         delay_ms(time);
  305.         TIM_SetCompare1(TIM3,moto_down);
  306.     }     //舵机开锁等待1秒后关闭

  308.     if(ture==0) {
  309.         OLED_Clear();
  310.         OLED_ShowCH(0,16,"密码错误");
  311.         OLED_Refresh_Gram();
  312.         delay_ms(800);
  313.     }
  314. }



  318. void turncode(void)//串口更改密码函数
  319. {
  320.     for(i=0; i<6; i++)
  321.     {
  322.         mima[i]=turnmima[i+1];              //数据转存（第一位为标志位省去）
  323.     }
  324.     AT24CXX_Write(0,(u8*)mima,6);
  325.     OLED_Clear();
  326.     OLED_ShowCH(0,16,"密码修改成功");
  327.     OLED_Refresh_Gram();
  328.     reok=1;                              //标志位置一 返回主界面
  329.     delay_ms(800);
  330. }



  334. void ifmima(void)//密码判断函数
  335. {
  336.     for(i=0; i<6; i++)
  337.     {
  338.         if(shurumima[i]==mima[i])ture=1;     //数组比较正确标志位置一
  339.         else {
  340.             ture=0;    //不正确标志位置0
  341.             break;
  342.         }
  343.     }
  344.     for(j=0; j<6; j++)
  345.     {
  346.         shurumima[j]='0';                     //清空输入密码的数组
  347.     }
  348. }




  353. //刷指纹
  354. void press_FR(void)
  355. {
  356.     SearchResult seach;
  357.     u8 ensure;
  358.     u8 t=0;
  359.     while(1)
  360.     {
  361.         t++;
  362.         ensure = PS_GetImage();
  363.         OLED_Clear();
  364.         OLED_ShowCH(0,0,"请按手指");
  365.         OLED_Refresh_Gram();
  366.         if(ensure == 0x00)    //获取图像成功
  367.         {
  368.             ensure = PS_GenChar(CharBuffer1);
  369.             if(ensure == 0x00)  //生成特征成功
  370.             {
  371.                 ensure = PS_HighSpeedSearch(CharBuffer1, 0, 99, &seach);
  372.                 if(ensure == 0x00) //搜索成功
  373.                 {
  374.                     OLED_Clear();
  375.                     OLED_ShowCH(0, 16, "指纹验证成功");
  376.                     OLED_Refresh_Gram();
  377.                     TIM_SetCompare1(TIM3,moto_up);
  378.                     delay_ms(1000);
  379.                     TIM_SetCompare1(TIM3,moto_down);
  380.                     // delay_ms(1500);
  381.                     delay_ms(1500);
  382.                     break;
  383.                 }
  384.                 else
  385.                 {   OLED_Clear();
  386.                     OLED_ShowCH(0, 16, "验证失败");
  387.                     OLED_Refresh_Gram();
  388.                     delay_ms(1500);
  389.                     break;
  390.                 }
  391.             }
  392.             else
  393.             {};
  394.         }
  395.         if(t==10)
  396.         {
  397.             t=0;
  398.             break;
  399.         }
  400.         delay_ms(500);
  401.     }
  402. }


  405. //添加指纹
  406. void Add_FR(void)
  407. {
  408.     u8 i, ensure, processnum = 0;
  409.     u8 ID_NUM = 0;
  410.     while(1)
  411.     {
  412.         switch (processnum)
  413.         {
  414.         case 0:
  415.             i++;
  416.             OLED_Clear();
  417.             OLED_ShowCH(0, 16, "请按手指");
  418.             OLED_Refresh_Gram();
  419.             ensure = PS_GetImage();
  420.             if(ensure == 0x00)
  421.             {
  422.                 ensure = PS_GenChar(CharBuffer1); //生成特征
  423.                 if(ensure == 0x00)
  424.                 {
  425.                     OLED_Clear();
  426.                     OLED_ShowCH(0, 16, "指纹正常");
  427.                     OLED_Refresh_Gram();
  428.                     i = 0;
  429.                     processnum = 1; //跳到第二步
  430.                 }
  431.             }
  432.             break;
  433.         case 1:
  434.             i++;
  435.             OLED_Clear();
  436.             ensure = PS_GetImage();
  437.             if(ensure == 0x00)
  438.             {
  439.                 ensure = PS_GenChar(CharBuffer2); //生成特征
  440.                 if(ensure == 0x00)
  441.                 {
  442.                     OLED_Clear();
  443.                     OLED_ShowCH(0, 16, "指纹正常");
  444.                     OLED_Refresh_Gram();
  445.                     i = 0;
  446.                     processnum = 2; //跳到第三步
  447.                 }
  448.                 else {
  449.                     OLED_ShowCH(0, 16,"失败");
  450.                     OLED_Refresh_Gram();
  451.                 }
  452.             }
  453.             else {
  454.                 OLED_ShowCH(0, 16, "失败");
  455.                 OLED_Refresh_Gram();
  456.             }
  457.             break;
  458.         case 2:
  459.             OLED_Clear();
  460.             OLED_ShowCH(0, 16, "对比两次指纹");
  461.             OLED_Refresh_Gram();
  462.             ensure = PS_Match();
  463.             if(ensure == 0x00)
  464.             {   OLED_Clear();
  465.                 OLED_ShowCH(0, 16, "对比成功");
  466.                 OLED_Refresh_Gram();
  467.                 processnum = 3; //跳到第四步
  468.             }
  469.             else
  470.             {
  471.                 OLED_ShowCH(0, 16, "对比失败");
  472.                 OLED_Refresh_Gram();
  473.                 i = 0;
  474.                 processnum = 0; //跳回第一步
  475.             }
  476.             delay_ms(500);
  477.             break;
  478.         case 3:
  479.             OLED_Clear();
  480.             OLED_ShowCH(0, 16, "可松开手指");
  481.             OLED_Refresh_Gram();
  482.             delay_ms(800);
  483.             OLED_Clear();
  484.             OLED_ShowCH(0, 16, "生成指纹模板");
  485.             OLED_Refresh_Gram();
  486.             delay_ms(500);
  487.             ensure = PS_RegModel();
  488.             if(ensure == 0x00)
  489.             {   OLED_Clear();
  490.                 OLED_ShowCH(0, 16, "生成指纹模板成功");
  491.                 OLED_Refresh_Gram();
  492.                 processnum = 4; //跳到第五步
  493.             }
  494.             else
  495.             {
  496.                 processnum = 0;
  497.                 OLED_ShowCH(0, 16, "失败");
  498.                 OLED_Refresh_Gram();
  499.             }
  500.             delay_ms(1000);
  501.             break;
  502.         case 4:
  503.             OLED_Clear();
  504.             OLED_ShowCH(0, 16, "输入用户编号");
  505.             OLED_Refresh_Gram();
  506.             while(ID_NUM==0|ID_NUM==15)
  507.             {
  508.                 ID_NUM=key(0);
  509.             }
  510.             OLED_Clear();
  511.             OLED_ShowCH(0, 0, "用户编号为");
  512.             OLED_ShowNum(0, 32, ID_NUM, 2, 24);
  513.             OLED_Refresh_Gram();
  514.             ensure = PS_StoreChar(CharBuffer2, ID_NUM); //储存模板
  515.             delay_ms(800);
  516.             if(ensure == 0x00)
  517.             {
  518.                 OLED_Clear();
  519.                 OLED_ShowCH(0, 16, "录入指纹成功");
  520.                 OLED_Refresh_Gram();
  521.                 delay_ms(1500);
  522.                 OLED_Clear();
  523.                 return ;
  524.             }
  525.             else
  526.             {
  527.                 OLED_Clear();
  528.                 processnum = 0;
  529.                 OLED_ShowCH(0, 16, "失败");
  530.                 OLED_Refresh_Gram();
  531.             }
  532.             break;
  533.         }
  534.         delay_ms(400);
  535.         if(i == 10) //超过5次没有按手指则退出
  536.         {
  537.             break;
  538.         }
  539.     }
  540. }


  543. //删除指纹
  544. void Del_FR(void)
  545. {
  546.     u8  ensure;
  547.     u16 ID_NUM = 0;
  548.     OLED_Clear();
  549.     OLED_ShowCH(0, 2, "输入清除用户编号");
  550.     OLED_Refresh_Gram();
  551.     while(ID_NUM==0|ID_NUM==15)
  552.     {
  553.         ID_NUM=key(0);
  554.     }
  555.     ensure = PS_DeletChar(ID_NUM, 1); //删除单个指纹
  556.     if(ensure == 0)
  557.     {
  558.         OLED_Clear();
  559.         OLED_ShowNum(0, 12, ID_NUM, 2, 12);
  560.         OLED_ShowCH(12, 12, "号删除指纹成功");
  561.         OLED_Refresh_Gram();
  562.     }
  563.     else
  564.         OLED_ShowCH(0, 16, "删除失败");
  565.     delay_ms(1500);
  566. }

  568. void gui(u8 i)
  569. {
  570.     switch(i)
  571.     {
  572.         /*******************************************/
  573.         /*
  574.         主界面
  575.         */
  576.         /*******************************************/
  577.     case 0:
  578.         OLED_Clear();
  579.         OLED_ShowCH(8,  0, "控智控能控锁控");
  580.         OLED_ShowCH(32, 16, "指纹解锁");
  581.         OLED_ShowCH(32, 32, "密码解锁");
  582. //  OLED_ShowCH(32, 48, "软件解锁");
  583.         OLED_Refresh_Gram();
  584.         break;

  586.         /*******************************************/
  587.         /*
  588.         指纹解锁界面
  589.         */
  590.         /*******************************************/
  591.     case 1:
  592.         OLED_Clear();
  593.         OLED_ShowCH(8,  0, "指控纹控解控锁");
  594.         OLED_ShowCH(32, 16, "添加指纹");
  595.         OLED_ShowCH(32, 32, "删除指纹");
  596.         OLED_ShowCH(32, 48, "验证指纹");
  597.         OLED_Refresh_Gram();
  598.         break;

  600.         /*******************************************/


  603.         /*******************************************/
  604.         /*
  605.         按键解锁主界面
  606.         */
  607.         /*******************************************/
  608.     case 2:
  609.         OLED_Clear();
  610.         OLED_ShowCH(8,  0, "密控码控解控锁");
  611.         OLED_ShowCH(32, 16,  "输入密码");
  612.         OLED_ShowCH(32, 32,  "修改密码");
  613.         OLED_ShowCH(40, 48,   "返控回");
  614.         OLED_Refresh_Gram();
  615.         break;



  619.         /*******************************************/
  620.         /*
  621.         按键解锁次界面
  622.         */
  623.         /*******************************************/
  624.     case 3:
  625.         OLED_Clear();
  626.         OLED_ShowCH(8,  0, "密控码控解控锁");
  627.         OLED_ShowCH(0, 16,  "请输入密码");
  628.         //OLED_ShowCH(32, 32,  "修改密码");
  629.         OLED_ShowCH(88, 48,   "返回");
  630.         OLED_Refresh_Gram();
  631.         break;


  634.         /*******************************************/
  635.         /*
  636.         软件解锁次界面
  637.         */
  638.         /*******************************************/
  639.     case 4:
  640.         OLED_Clear();
  641.         OLED_ShowCH(8,  0, "软控件控解控锁");
  642.         OLED_ShowCH(0, 16,  "请连接软件");
  643.         OLED_ShowCH(88, 48,   "返回");
  644.         OLED_Refresh_Gram();
  645.         break;
  646.     }
  647. }

  649. u8 turnstr(u8 d)
  650. {
  651.     switch(d)
  652.     {
  653.     case 0: {
  654.         return '0';
  655.         break;
  656.     }
  657.     case 1: {
  658.         return '1';
  659.         break;
  660.     }
  661.     case 2: {
  662.         return '2';
  663.         break;
  664.     }
  665.     case 3: {
  666.         return '3';
  667.         break;
  668.     }
  669.     case 4: {
  670.         return '4';
  671.         break;
  672.     }
  673.     case 5: {
  674.         return '5';
  675.         break;
  676.     }
  677.     case 6: {
  678.         return '6';
  679.         break;
  680.     }
  681.     case 7: {
  682.         return '7';
  683.         break;
  684.     }
  685.     case 8: {
  686.         return '8';
  687.         break;
  688.     }
  689.     case 9: {
  690.         return '9';
  691.         break;
  692.     }
  693.     }
  694. }
复制代码


ID:474195 发表于 2022-6-17 14:50
如有制作问题可联系本人

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

Powered by 单片机教程网

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