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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机的智能楼宇门禁系统源程序+视频资料
返回列表 发新帖
查看: 6510|回复: 7
打印 上一主题 下一主题
收起左侧

51单片机的智能楼宇门禁系统源程序+视频资料

  [复制链接]
跳转到指定楼层
楼主
ID:506908 发表于 2019-4-8 13:23 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
   基于单片机的门禁系统，大家分享。

功能
(60%)    可输入密码进行解锁。        
    可以对IC卡进行注册或注销。         
    可用已注册的IC卡解锁。         
    可实现液晶显示当前时间。      
    密码连续输错三次时能强制退出并报警。         
    具有指示灯温和蜂鸣器提示功能，开锁时亮绿灯。         
参数(20%)    开锁后自动恢复闭锁时间≤15s         
    实现开锁的反应时间≤2s   

视频演示:

  

单片机源程序如下:
  1. //包含头文件
  2. #include <REG52.h>
  3. #include<intrins.h>
  4. #include "main.h"
  5. #include<rc522.c>
  6. #include<eeprom52.h>
  7. //宏定义
  8. #define LCM_Data  P0                  //将P0口定义为LCM_Data
  9. #define uchar unsigned char
  10. #define uint  unsigned int

  12. #define WRITE_SECOND    0x80    //DS1302内部的相关地址
  13. #define WRITE_MINUTE    0x82
  14. #define WRITE_HOUR      0x84
  15. #define WRITE_DATE      0x86
  16. #define WRITE_MONTH     0x88
  17. #define WRITE_WEEK                0x8a
  18. #define WRITE_YEAR      0x8c

  20. #define READ_SECOND     0x81
  21. #define READ_MINUTE     0x83
  22. #define READ_HOUR       0x85
  23. #define READ_DATE       0x87
  24. #define READ_MONTH      0x89
  25. #define READ_WEEK                0x8b
  26. #define READ_YEAR       0x8d
  27. uchar second1;
  28. uchar minute1;
  29. uchar hour1;
  30. uchar week1;
  31. uchar day1;
  32. uchar month1;
  33. uchar year1;

  35. struct time
  36. {
  37.    uchar second;
  38.    uchar minute;
  39.    uchar hour;
  40.    uchar week;
  41.    uchar day;
  42.    uchar month;
  43.    uchar year;
  44. }
  45. current_time;
  46. #define ctime current_time

  48. sbit RST=P3^0;
  49. sbit SCLK=P3^1;
  50. sbit SDA=P2^6;

  52. //1602的控制脚
  53. sbit lcd1602_rs=P2^7;
  54. sbit lcd1602_en=P2^5;

  56. sbit Scl=P3^4;                        //24C02串行时钟
  57. sbit Sda=P3^5;                        //24C02串行数据

  59. sbit ALAM = P2^1;                //报警        
  60. sbit KEY = P3^6;                //开锁

  62. bit  operation=0;                //操作标志位
  63. bit  pass=0;                        //密码正确标志
  64. bit  ReInputEn=0;                //重置输入充许标志        
  65. bit  s3_keydown=0;                //3秒按键标志位
  66. bit  key_disable=0;                //锁定键盘标志
  67. bit  chushihua=0;       //可以注册卡标志位

  69. unsigned char countt0,second,s1num,flag;        //t0中断计数器,秒计数器

  71. void Delay5Ms(void);                //声明延时函数
  72. unsigned char xdata CardRevBuf[16] = { 0 };

  74. unsigned char code a[]={0xFE,0xFD,0xFB,0xF7};                                 //控盘扫描控制表
  75. //液晶显示数据数组
  76. unsigned char code start_line[]        = {"password:       "};
  77. unsigned char code name[]                  = {"===Coded Lock==="};        //显示名称
  78. unsigned char code Correct[]         = {"     correct    "};                //输入正确
  79. unsigned char code Error1[]           = {"      error     "};          //输入错误
  80. unsigned char code codepass[]        = {"      pass      "};
  81. unsigned char code LockOpen[]        = {"      open      "};                //OPEN
  82. unsigned char code SetNew[]         = {"SetNewWordEnable"};
  83. unsigned char code Input[]           = {"input:          "};                //INPUT
  84. unsigned char code ResetOK[]         = {"ResetPasswordOK "};
  85. unsigned char code initword[]        = {"Init password..."};
  86. unsigned char code Er_try[]                = {"error,try again!"};
  87. unsigned char code again[]                = {"input again     "};
  88. unsigned char code table[]="      :  :     ";

  90. unsigned char InputData[6];                                                                        //输入密码暂存区
  91. unsigned char CurrentPassword[6]={0,0,0,0,0,0};                         //读取EEPROM密码暂存数组
  92. unsigned char TempPassword[6];
  93. unsigned char N=0;                                //密码输入位数记数
  94. unsigned char ErrorCont;                        //错误次数计数
  95. unsigned char CorrectCont;                        //正确输入计数
  96. unsigned char ReInputCont;                         //重新输入计数
  97. unsigned char code initpassword[6]={0,0,0,0,0,0};                        //输入管理员密码后将密码初始为000000
  98. unsigned char code adminpassword[6]={1,3,1,4,2,0};                        //输入管理员密码后将密码初始为000000
  99. unsigned char code adminpassword1[6]={1,3,1,4,2,1};
  100. unsigned char current_id;
  101. char xdata DisplayBuf[10];  //当前读出卡的ID
  102. char xdata DisplayBuf_c[10];  //当前单片机里存的卡ID

  104. void write_eeprom_j(unsigned char j)                  //将对应的ID写入到单片机
  105. {
  106.    
  107.         SectorErase(0x2200+j*0x0200);                   //清空
  108.          byte_write(0x2200+j*0x0200,DisplayBuf[0]);               
  109.          byte_write(0x2201+j*0x0200,DisplayBuf[1]);
  110.         byte_write(0x2202+j*0x0200,DisplayBuf[2]);
  111.         byte_write(0x2203+j*0x0200,DisplayBuf[3]);
  112.         byte_write(0x2204+j*0x0200,DisplayBuf[4]);
  113.         byte_write(0x2205+j*0x0200,DisplayBuf[5]);
  114.         byte_write(0x2206+j*0x0200,DisplayBuf[6]);
  115.         byte_write(0x2207+j*0x0200,DisplayBuf[7]);
  116. }
  117. void write_eeprom_jj(unsigned char j)         //将对应的ID清空
  118. {
  119.    
  120.         SectorErase(0x2200+j*0x0200);                   //清空
  121.          byte_write(0x2200+j*0x0200,' ');               
  122.          byte_write(0x2201+j*0x0200,' ');
  123.         byte_write(0x2202+j*0x0200,' ');
  124.         byte_write(0x2203+j*0x0200,' ');
  125.         byte_write(0x2204+j*0x0210,' ');
  126.         byte_write(0x2205+j*0x0200,' ');
  127.         byte_write(0x2206+j*0x0200,' ');
  128.         byte_write(0x2207+j*0x0200,' ');
  129. }
  130. void read_eeprom_j(uchar j)
  131. {
  132.   DisplayBuf_c[0]= byte_read(0x2200+j*0x0200);
  133.   DisplayBuf_c[1]= byte_read(0x2201+j*0x0200);
  134.   DisplayBuf_c[2]= byte_read(0x2202+j*0x0210);
  135.   DisplayBuf_c[3]= byte_read(0x2203+j*0x0200);
  136.   DisplayBuf_c[4]= byte_read(0x2204+j*0x0200);
  137.   DisplayBuf_c[5]= byte_read(0x2205+j*0x0200);
  138.   DisplayBuf_c[6]= byte_read(0x2206+j*0x0200);
  139.   DisplayBuf_c[7]= byte_read(0x2207+j*0x0200);   

  141. }
  142. //=====================5ms延时==============================
  143. void Delay5Ms(void)
  144. {
  145.         unsigned int TempCyc = 5552;
  146.         while(TempCyc--);
  147. }

  149. //===================400ms延时==============================
  150. void Delay400Ms(void)
  151. {
  152. unsigned char TempCycA = 5;
  153. unsigned int TempCycB;
  154. while(TempCycA--)
  155. {
  156.   TempCycB=7269;
  157.   while(TempCycB--);
  158. }
  159. }

  161. //=============================================================================================
  162. //================================24C02========================================================
  163. //=============================================================================================

  165. void mDelay(uint t) //延时
  166. {
  167.         uchar i;
  168.            while(t--)
  169.            {
  170.                    for(i=0;i<125;i++)
  171.                    {;}
  172.            }
  173. }
  174.    

  176. void Nop(void)                  //空操作
  177. {
  178.          _nop_();                  //仅作延时用一条语句大约1us
  179.          _nop_();
  180.          _nop_();
  181.          _nop_();
  182. }

  184. /*****24c02程序参照24c02时序图*****/
  185. /*起始条件*/

  187. void Start(void)
  188. {
  189.          Sda=1;
  190.          Scl=1;
  191.          Nop();
  192.          Sda=0;
  193.          Nop();
  194. }


  197. /*停止条件*/
  198. void Stop(void)
  199. {
  200.          Sda=0;
  201.          Scl=1;
  202.          Nop();
  203.          Sda=1;
  204.          Nop();
  205. }

  207. /*应答位*/
  208. void Ack(void)
  209. {
  210.         Sda=0;
  211.         Nop();
  212.         Scl=1;
  213.         Nop();
  214.         Scl=0;
  215. }

  217. /*反向应答位*/
  218. void NoAck(void)
  219. {
  220.          Sda=1;
  221.          Nop();
  222.          Scl=1;
  223.          Nop();
  224.          Scl=0;
  225. }

  227. /*发送数据子程序，Data为要求发送的数据*/
  228. void Send(uchar Data)
  229. {
  230.            uchar BitCounter=8;
  231.            uchar temp;
  232.            do
  233.            {
  234.                    temp=Data;                                           //将待发送数据暂存temp
  235.                    Scl=0;
  236.                    Nop();
  237.                    if((temp&0x80)==0x80)                   //将读到的数据&0x80
  238.                    Sda=1;
  239.                    else
  240.                    Sda=0;
  241.                    Scl=1;
  242.                    temp=Data<<1;                                   //数据左移
  243.                    Data=temp;                                           //数据左移后重新赋值Data
  244.                    BitCounter--;                                   //该变量减到0时，数据也就传送完成了
  245.            }
  246.            while(BitCounter);                                   //判断是否传送完成
  247.            Scl=0;
  248. }

  250. /*读一字节的数据，并返回该字节值*/
  251. uchar Read(void)
  252. {
  253.     uchar temp=0;
  254.         uchar temp1=0;
  255.         uchar BitCounter=8;
  256.         Sda=1;
  257.         do
  258.         {
  259.                 Scl=0;
  260.                 Nop();
  261.                 Scl=1;
  262.                 Nop();
  263.                 if(Sda)                                   //数据位是否为1
  264.                         temp=temp|0x01;           //为1 temp的最低位为1（|0x01，就是将最低位变为1）
  265.                 else                                   //如果为0
  266.                         temp=temp&0xfe;           //temp最低位为0（&0xfe（11111110）最低位就是0）
  267.                 if(BitCounter-1)           //BitCounter减1后是否为真
  268.                 {
  269.                         temp1=temp<<1;           //temp左移
  270.                         temp=temp1;
  271.                 }
  272.                 BitCounter--;                   //BitCounter减到0时，数据就接收完了
  273.         }
  274.         while(BitCounter);                   //判断是否接收完成
  275.         return(temp);
  276. }

  278. void WrToROM(uchar Data[],uchar Address,uchar Num)
  279. {
  280.   uchar i;
  281.   uchar *PData;
  282.   PData=Data;
  283.   for(i=0;i<Num;i++)
  284.   {
  285.   Start();
  286.   Send(0xa0);
  287.   Ack();
  288.   Send(Address+i);
  289.   Ack();
  290.   Send(*(PData+i));
  291.   Ack();
  292.   Stop();
  293.   mDelay(20);
  294.   }
  295. }

  297. void RdFromROM(uchar Data[],uchar Address,uchar Num)
  298. {
  299.   uchar i;
  300.   uchar *PData;
  301.   PData=Data;
  302.   for(i=0;i<Num;i++)
  303.   {
  304.   Start();
  305.   Send(0xa0);
  306.   Ack();
  307.   Send(Address+i);
  308.   Ack();
  309.   Start();
  310.   Send(0xa1);
  311.   Ack();
  312.   *(PData+i)=Read();
  313.   Scl=0;
  314.   NoAck();
  315.   Stop();
  316.   }
  317. }
  318. //===================2us延时==============================
  319. void delayus()         //延时2us
  320. {
  321.   _nop_();
  322.   _nop_();
  323. }


  326. //===================DS1302=================================//
  327. //==========================================================//
  328. /************************************************
  329. *名称:DS1302WriteByte
  330. *说明:无
  331. *功能:写入8bit数据
  332. *调用:delayus()
  333. *输入:dat:要写入的数据
  334. *输出:无
  335. *************************************************/
  336. void DS1302WriteByte(uchar dat)
  337. {
  338.     uchar i;
  339.     SCLK=0;//初始时钟线置为0
  340.     delayus();
  341.     for(i=0;i<8;i++)//开始传输8个字节的数据
  342.       {
  343.          SDA=dat&0x01;//取最低位，注意DS1302的数据和地址都是从最低位开始传输的
  344.          delayus();
  345.          SCLK=1;//时钟线拉高，制造上升沿，SDA的数据被传输
  346.          delayus();
  347.          SCLK=0;//时钟线拉低，为下一个上升沿做准备
  348.          dat>>=1;//数据右移一位，准备传输下一位数据
  349.       }
  350. }

  352. /************************************************
  353. *名称:DS1302ReadByte()
  354. *说明:无
  355. *功能:读取8bit的数据
  356. *调用:delayus()
  357. *输入:无
  358. *输出:dat:读取的数据
  359. *************************************************/
  360. uchar DS1302ReadByte()
  361. {
  362.    uchar i,dat;
  363.    delayus();
  364.    for(i=0;i<8;i++)
  365.     {
  366.        dat>>=1;//要返回的数据右移一位
  367.        if(SDA==1)//当数据线为高时，证明该位数据为1
  368.          dat|=0x80;//要传输数据的当前值置为1,若不是,则为0
  369.        SCLK=1;//拉高时钟线
  370.        delayus();
  371.        SCLK=0;//制造下降沿
  372.        delayus();
  373.      }
  374.        SDA=0;
  375.            return dat;//返回读取出的数据

  377. }

  379. /************************************************
  380. *名称:ucharDS1302Read()
  381. *说明:先写地址，后读数据
  382. *功能:从cmd相应地址中读取一个字节的数据
  383. *调用:DS1302WriteByte(),DS1302ReadByte()
  384. *输入:cmd:要写入的控制字节
  385. *输出:dat:读取的数据
  386. *************************************************/
  387. uchar DS1302Read(uchar cmd)
  388. {

  390.    uchar dat;
  391.    RST=0;//初始CE线置为0
  392.    SCLK=0;//初始时钟线置为0
  393.    RST=1;//初始CE置为1，传输开始
  394.    DS1302WriteByte(cmd);//传输命令字，要读取的时间/日历地址   
  395.    dat=DS1302ReadByte();//读取要得到的时间/日期
  396.    SCLK=1;//时钟线拉高
  397.    RST=0;//读取结束，CE置为0，结束数据的传输
  398.    return dat;//返回得到的时间/日期
  399. }

  401. /************************************************
  402. *名称:DS1302Write
  403. *说明:先写地址，后写数据
  404. *功能:向cmd相应地址中写一个字节的数据
  405. *调用:DS1302WriteByte()
  406. *输入:cmd:要写入的控制字,dat:要写入的数据
  407. *输出:无

  409. *************************************************/
  410. void DS1302Write(uchar cmd,uchar dat)
  411. {
  412.    RST=0;//初始CE线置为0
  413.    SCLK=0;//初始时钟线置为0
  414.    RST=1;//初始CE置为1，传输开始
  415.    DS1302WriteByte(cmd);//传输命令字，要写入的时间/日历地址
  416.    DS1302WriteByte(dat);//写入要修改的时间/日期
  417.    SCLK=1;//时钟线拉高
  418.    RST=0;//读取结束，CE置为0，结束数据的传输
  419. }


  422. void Init_DS1302()
  423. {
  424.   DS1302Write(0x8e,0x00);
  425.   /* DS1302Write(WRITE_SECOND,0x00);
  426.   DS1302Write(WRITE_MINUTE,0x33);
  427.   DS1302Write(WRITE_HOUR,0x07);
  428.   DS1302Write(WRITE_DATE,0x07);
  429.   DS1302Write(WRITE_MONTH,0x12);   //         首次下载定时 2016.12.07  7:33:00 星期三
  430.   DS1302Write(WRITE_WEEK,0x03);
  431.   DS1302Write(WRITE_YEAR,0x16);*/
  432.   DS1302Write(0x90,0x01);
  433.   DS1302Write(0x8e,0x80);
  434. }



  438. //==================================================================================================
  439. //=======================================LCD1602====================================================
  440. //==================================================================================================

  442. #define yi 0x80 //LCD第一行的初始位置,因为LCD1602字符地址首位D7恒定为1（100000000=80）
  443. #define er 0x80+0x40 //LCD第二行初始位置（因为第二行第一个字符位置地址是0x40）


  446. //----------------延时函数，后面经常调用----------------------
  447. void delay(uint xms)//延时函数，有参函数
  448. {
  449.         uint x,y;
  450.         for(x=xms;x>0;x--)
  451.          for(y=110;y>0;y--);
  452. }

  454. //--------------------------写指令---------------------------
  455. void write_1602com(uchar com)//****液晶写入指令函数****
  456. {
  457.         lcd1602_rs=0;//数据/指令选择置为指令
  458.         P0=com;//送入数据
  459.         delay(1);
  460.         lcd1602_en=1;//拉高使能端，为制造有效的下降沿做准备
  461.         delay(1);
  462.         lcd1602_en=0;//en由高变低，产生下降沿，液晶执行命令
  463. }

  465. //-------------------------写数据-----------------------------
  466. void write_1602dat(uchar dat)//***液晶写入数据函数****
  467. {
  468.         lcd1602_rs=1;//数据/指令选择置为数据
  469.         P0=dat;//送入数据
  470.         delay(1);
  471.         lcd1602_en=1; //en置高电平，为制造下降沿做准备
  472.         delay(1);
  473.         lcd1602_en=0; //en由高变低，产生下降沿，液晶执行命令
  474. }
  475. //-------------------------写时分秒-----------------------------
  476. void write_sfm(uchar add,char date)        //写时分秒函数
  477. {
  478.    char shi,ge;
  479.    shi=date/16;
  480.    ge=date%16;
  481.    
  482.    write_1602com(0x80+add);
  483.    write_1602dat(0x30+shi);
  484.    write_1602dat(0x30+ge);
  485. }
  486. //-------------------------初始化-------------------------
  487. void lcd_init(void)
  488. {

  490.         write_1602com(0x38);//设置液晶工作模式，意思：16*2行显示，5*7点阵，8位数据
  491.         write_1602com(0x0c);//开显示不显示光标
  492.         write_1602com(0x06);//整屏不移动，光标自动右移
  493.         write_1602com(0x01);//清显示

  495. }


  498. //========================================================================================
  499. //=========================================================================================
  500. //==============将按键值编码为数值=========================
  501. unsigned char coding(unsigned char m)         
  502. {
  503.         unsigned char k;
  504.         switch(m)
  505.         {
  506.                 case (0x11): k=1;break;
  507.                 case (0x21): k=2;break;
  508.                 case (0x41): k=3;break;
  509.                 case (0x81): k='A';break;
  510.                 case (0x12): k=4;break;
  511.                 case (0x22): k=5;break;
  512.                 case (0x42): k=6;break;
  513.                 case (0x82): k='B';break;
  514.                 case (0x14): k=7;break;
  515.                 case (0x24): k=8;break;
  516.                 case (0x44): k=9;break;
  517.                 case (0x84): k='C';break;
  518.                 case (0x18): k='*';break;
  519.                 case (0x28): k=0;break;
  520.                 case (0x48): k='#';break;
  521.                 case (0x88): k='D';break;
  522.         }
  523.         return(k);
  524. }
  525. //=====================按键检测并返回按键值===============================
  526. unsigned char keynum(void)
  527. {
  528.          unsigned char row,col,i;
  529.          P1=0xf0;
  530.          if((P1&0xf0)!=0xf0)
  531.          {
  532.                    Delay5Ms();
  533.         Delay5Ms();
  534.                    if((P1&0xf0)!=0xf0)
  535.                 {
  536.                     row=P1^0xf0;          //确定行线
  537.                         i=0;
  538.                         P1=a[i];                  //精确定位
  539.                         while(i<4)
  540.                         {
  541.                                  if((P1&0xf0)!=0xf0)
  542.                                   {
  543.                                            col=~(P1&0xff);          //确定列线
  544.                                            break;            //已定位后提前退出   
  545.                                   }
  546.                                 else
  547.                                   {
  548.                                            i++;
  549.                                            P1=a[i];
  550.                                   }
  551.                         }
  552.                 }
  553.                 else
  554.                 {
  555.                         return 0;
  556.                 }
  557.                 while((P1&0xf0)!=0xf0);
  558.                 return (row|col);                         //行线与列线组合后返回
  559.          }
  560.          else return 0;                                 //无键按下时返回0
  561. }
  562. //=======================一声提示音，表示有效输入========================
  563. void OneAlam(void)
  564. {
  565.         ALAM=0;
  566.         Delay5Ms();
  567.     ALAM=1;
  568. }
  569. //========================二声提示音，表示操作成功========================
  570. void TwoAlam(void)
  571. {
  572.         ALAM=0;
  573.         Delay5Ms();
  574.     ALAM=1;
  575.     Delay5Ms();
  576.         ALAM=0;
  577.         Delay5Ms();
  578.     ALAM=1;
  579. }
  580. //========================三声提示音,表示错误========================
  581. void ThreeAlam(void)
  582. {
  583.         ALAM=0;
  584.         Delay5Ms();
  585.     ALAM=1;
  586.     Delay5Ms();
  587.         ALAM=0;
  588.         Delay5Ms();
  589.     ALAM=1;
  590.     Delay5Ms();
  591.         ALAM=0;
  592.         Delay5Ms();
  593.     ALAM=1;
  594. }
  595. //=======================显示提示输入=========================
  596. void DisplayChar(void)
  597. {
  598.         unsigned char i;
  599.         if(pass==1)
  600.         {

  602.                 write_1602com(er);                                   //在二行开始显示
  603.                 for(i=0;i<16;i++)
  604.                 {
  605.                         write_1602dat(LockOpen[i]);           //显示open 开锁成功
  606.                 }
  607.         }
  608.         else
  609.         {
  610.                 if(N==0)
  611.                 {

  613.                         write_1602com(er);
  614.                         for(i=0;i<16;i++)
  615.                         {
  616.                                 write_1602dat(Error1[i]);        //显示错误
  617.                         }
  618.                 }
  619.                 else
  620.                 {

  622.                         write_1602com(er);
  623.                         for(i=0;i<16;i++)
  624.                         {
  625.                                 write_1602dat(start_line[i]);//显示开始输入        
  626.                         }
  627.                 }
  628.         }
  629. }

  631. //========================重置密码==================================================
  632. //==================================================================================
  633. void ResetPassword(void)
  634. {
  635.         unsigned char i;        
  636.         unsigned char j;
  637.         if(pass==0)
  638.         {
  639.                 pass=0;                           
  640.                 DisplayChar();           //显示错误
  641.                 ThreeAlam();           //没开锁时按下重置密码报警3声
  642.         }
  643.         else                                   //开锁状态下才能进行密码重置程序
  644.         {
  645.             if(ReInputEn==1)   //开锁状态下，ReInputEn置1，重置密码允许
  646.                 {
  647.                         if(N==6)           //输入6位密码
  648.                         {
  649.                                 ReInputCont++;                        //密码次数计数        
  650.                                 if(ReInputCont==2)                //输入两次密码
  651.                                 {
  652.                                         for(i=0;i<6;)
  653.                                         {
  654.                                                 if(TempPassword[i]==InputData[i])        //将两次输入的新密码作对比
  655.                                                         i++;
  656.                                                 else                                                                //如果两次的密码不同
  657.                                                 {

  659.                                                         write_1602com(er);
  660.                                                         for(j=0;j<16;j++)
  661.                                                         {
  662.                                                                 write_1602dat(Error1[j]);        //显示错误Error
  663.                                                         }
  664.                                                         ThreeAlam();                        //错误提示        
  665.                                                         pass=0;                                        //关锁
  666.                                                         ReInputEn=0;                        //关闭重置功能，
  667.                                                         ReInputCont=0;
  668.                                                         DisplayChar();
  669.                                                         break;
  670.                                                 }
  671.                                         }
  672.                                         if(i==6)
  673.                                         {

  675.                                                 write_1602com(er);
  676.                                                 for(j=0;j<16;j++)
  677.                                                 {
  678.                                                         write_1602dat(ResetOK[j]);          //密码修改成功，显示
  679.                                                 }

  681.                                                 TwoAlam();                                //操作成功提示
  682.                                                  WrToROM(TempPassword,0,6);                //将新密码写入24C02存储
  683.                                                 ReInputEn=0;
  684.                                         }
  685.                                         ReInputCont=0;
  686.                                         CorrectCont=0;
  687.                                 }
  688.                                 else                                          //输入一次密码时
  689.                                 {
  690.                                         OneAlam();

  692.                                         write_1602com(er);
  693.                                         for(j=0;j<16;j++)
  694.                                         {
  695.                                                 write_1602dat(again[j]);                        //显示再输入一次
  696.                                         }                                       
  697.                                         for(i=0;i<6;i++)
  698.                                         {
  699.                                                 TempPassword[i]=InputData[i];                //将第一次输入的数据暂存起来                                                
  700.                                         }
  701.                                 }

  703.                         N=0;                                                //输入数据位数计数器清零
  704.                    }
  705.             }
  706.         }
  707. }
  708. //=======================输入密码错误超过三过，报警并锁死键盘======================
  709. void Alam_KeyUnable(void)
  710. {
  711.         P1=0x00;
  712.         {
  713.                 ALAM=~ALAM;                                 //蜂鸣器一直闪烁鸣响
  714.                 Delay5Ms();
  715.         }
  716. }
  717. //=======================取消所有操作============================================
  718. void Cancel(void)
  719. {        
  720.         unsigned char i;
  721.         unsigned char j;
  722.         //DisplayListChar(0, 1, start_line);
  723.         write_1602com(er);
  724.         for(j=0;j<16;j++)
  725.         {
  726.                 write_1602dat(start_line[j]);          //显示开机输入密码界面
  727.         }
  728.         TwoAlam();                                //提示音
  729.         for(i=0;i<6;i++)
  730.         {
  731.                 InputData[i]=0;                //将输入密码清零
  732.         }
  733.         KEY=1;                                        //关闭锁
  734.         ALAM=1;                                        //报警关
  735.         pass=0;                                        //密码正确标志清零
  736.         ReInputEn=0;                        //重置输入充许标志清零
  737.         ErrorCont=0;                        //密码错误输入次数清零
  738.         CorrectCont=0;                        //密码正确输入次数清零
  739.         ReInputCont=0;                        //重置密码输入次数清零
  740.         s3_keydown=0;
  741.         key_disable=0;                        //锁定键盘标志清零
  742.         N=0;                                        //输入位数计数器清零
  743. }

  745. //==========================确认键，并通过相应标志位执行相应功能===============================
  746. void Ensure(void)
  747. {        
  748.         unsigned char i,j;
  749.         RdFromROM(CurrentPassword,0,6);                                         //从24C02里读出存储密码
  750.     if(N==6)
  751.         {
  752.             if(ReInputEn==0)                                                        //重置密码功能未开启
  753.                 {
  754.                                        
  755.                if((InputData[0]==adminpassword[0])&&(InputData[1]==adminpassword[1])&&(InputData[2]==adminpassword[2])&&(InputData[3]==adminpassword[3])&&(InputData[4]==adminpassword[4])&&(InputData[5]==adminpassword[5]))
  756.                                    {
  757.                                         WrToROM(initpassword,0,6);                                 //强制将初始密码写入24C02存储
  758.                                         write_1602com(er);
  759.                                         for(j=0;j<16;j++)
  760.                                         {
  761.                                                 write_1602dat(initword[j]);                                //显示初始化密码
  762.                                         }
  763.                                         TwoAlam();                                                                        //成功提示音
  764.                                         Delay400Ms();                                                                //延时400ms
  765.                                         TwoAlam();                                                                        //成功提示音
  766.                                         N=0;                                                                                //输入位数计数器清零
  767.                                         //TR0=1;                                                                                
  768.                                 }

  770.                         else if((InputData[0]==adminpassword1[0])&&(InputData[1]==adminpassword1[1])&&(InputData[2]==adminpassword1[2])&&(InputData[3]==adminpassword1[3])&&(InputData[4]==adminpassword1[4])&&(InputData[5]==adminpassword1[5]))
  771.                                    {

  773.                                         TwoAlam();                                                                        //成功提示音
  774.                                         Delay400Ms();                                                                //延时400ms
  775.                                         TwoAlam();                                                                        //成功提示音
  776.                                         N=0;                                                                                //输入位数计数器清零
  777.                                         chushihua=1;                                                                                
  778.                                 }


  781.                         else if((CurrentPassword[0]==InputData[0])&&(CurrentPassword[1]==InputData[1])&&(CurrentPassword[2]==InputData[2])&&(CurrentPassword[3]==InputData[3])&&(CurrentPassword[4]==InputData[4])&&(CurrentPassword[5]==InputData[5]))        //判断输入密码和24c02中的密码是否相同
  782.                                 {
  783.                                         CorrectCont++;        
  784.                                         if(CorrectCont==1)                                //正确输入计数，当只有一次正确输入时，开锁
  785.                                         {
  786.                                                 //DisplayListChar(0,1,LockOpen);
  787.                                                 write_1602com(er);
  788.                                                 for(j=0;j<16;j++)
  789.                                                 {
  790.                                                         write_1602dat(LockOpen[j]);                  //显示open开锁画面
  791.                                                 }
  792.                                                 TwoAlam();                        //操作成功提示音
  793.                                                 KEY=0;                                                                                        //开锁
  794.                                                 pass=1;                                                                                        //置正确标志位
  795.                                                 TR0=1;                                                                                        //开启定时
  796.                                                 for(j=0;j<6;j++)                                                                //将输入清除
  797.                                                 {
  798.                                                         InputData[i]=0;                                                                //开锁后将输入位清零
  799.                                                 }
  800.                                         }        
  801.                                         else if(CorrectCont==2)                                                                                                //当两次正确输入时，开启重置密码功能
  802.                                         {
  803.                                                 write_1602com(er);
  804.                                                 for(j=0;j<16;j++)
  805.                                                 {
  806.                                                         write_1602dat(SetNew[j]);                                        //显示重置密码界面
  807.                                                 }
  808.                                                 TR0=0;
  809.                                                 TwoAlam();                                                                            //操作成功提示
  810.                                                 ReInputEn=1;                                                                        //允许重置密码输入
  811.                                                 CorrectCont=0;                                                                        //正确计数器清零
  812.                                         }                                                                                                //相同一位 i就+1
  813.                                 }
  814.                                 else                                                                         //如果有密码不同
  815.                                 {                                                                                
  816.                                         write_1602com(er);
  817.                                         for(i=0;i<16;i++)
  818.                                         {
  819.                                                 write_1602dat(Error1[i]);        
  820.                                         }
  821.                                         ThreeAlam();
  822.                                         ErrorCont++;                                                //错误次数++
  823.                                         if(ErrorCont==3)                        //错误输入计数达三次时，报警并锁定键盘
  824.                                         {
  825.                                                 write_1602com(er);
  826.                                                 for(i=0;i<16;i++)
  827.                                                 {
  828.                                                         write_1602dat(Error1[i]);        
  829.                                                 }
  830.                                                 TR0=1;                                //开启定时
  831.                                                 key_disable=1;                        //锁定键盘
  832.                                                 pass=0;                                        //pass位清零
  833.                                                 Alam_KeyUnable();
  834.                
  835.                                         }

  837.                                 }

  839.         
  840.         


  843.                 }

  845.                 else                                                                                        //当已经开启重置密码功能时，而按下开锁键，
  846.                 {

  848.                         write_1602com(er);
  849.                         for(j=0;j<16;j++)
  850.                         {
  851.                                 write_1602dat(Er_try[j]);                          //错误，请重新输入
  852.                         }
  853.                         ThreeAlam();                                                          //错误提示音
  854.                 }
  855.         }

  857.         else                                   //密码没有输入到6位时，按下确认键时
  858.         {
  859.                
  860.                 write_1602com(er);
  861.                 for(j=0;j<16;j++)
  862.                 {
  863.                         write_1602dat(Error1[j]);                 //显示错误
  864.                 }

  866.                  ThreeAlam();                                                                                //错误提示音
  867.                 pass=0;        
  868.         }
  869.         
  870.         N=0;                                                                                                        //将输入数据计数器清零，为下一次输入作准备
  871. operation=1;
  872. }
  873. void display_id( unsigned char xdata * SrcBuf )
  874. {

  876.         char xdata *pDisplayChar;
  877.         unsigned char xdata Tmp, i;

  879.         pDisplayChar = DisplayBuf;

  881.         for( i = 0; i < 4; i++ )
  882.         {
  883.                 Tmp = ( ( *SrcBuf ) << 4 ) & 0x0F;        
  884.                 if( ( Tmp >=0 ) && ( Tmp <= 9 )        )
  885.                 {
  886.                         *pDisplayChar ++ = '0' + Tmp;        
  887.                 }
  888.                 else
  889.                 {
  890.                         *pDisplayChar ++ = 'A' + Tmp - 10;
  891.                 }

  893.                 Tmp = ( *SrcBuf ) & 0x0F;        
  894.                 if( ( Tmp >=0 ) && ( Tmp <= 9 )        )
  895.                 {
  896.                         *pDisplayChar ++ = '0' + Tmp;        
  897.                 }
  898.                 else
  899.                 {
  900.                         *pDisplayChar ++ = 'A' + Tmp - 10;
  901.                 }

  903.                 SrcBuf ++;
  904.         }
  905.         *pDisplayChar ++ = '\0';

  907. //        DisplayListChar( 0, 4, DisplayBuf );   
  908.         if(chushihua==1)
  909.         {
  910.     write_1602com(0xc0);
  911.         write_1602dat('I');
  912.         write_1602dat('D');
  913.         write_1602dat(current_id+0x30);
  914.         write_1602dat(':');
  915.         write_1602dat(DisplayBuf[0]);
  916.         write_1602dat(DisplayBuf[1]);
  917.         write_1602dat(DisplayBuf[2]);
  918.         write_1602dat(DisplayBuf[3]);
  919.         write_1602dat(DisplayBuf[4]);
  920.         write_1602dat(DisplayBuf[5]);
  921.         write_1602dat(DisplayBuf[6]);
  922.         write_1602dat(DisplayBuf[7]);
  923.         write_1602dat(' ');
  924.         write_1602dat(' ');write_1602dat(' ');write_1602dat(' ');write_1602dat(' ');
  925.         }
  926. }
  927. void display_no_id()
  928. {

  930.   write_1602com(0xc0);
  931.           write_1602dat('I');
  932.         write_1602dat('D');
  933.         write_1602dat(current_id+0x30);
  934.         write_1602dat(':');
  935.          write_1602dat(DisplayBuf_c[0]);
  936.         write_1602dat(DisplayBuf_c[1]);
  937.         write_1602dat(DisplayBuf_c[2]);
  938.         write_1602dat(DisplayBuf_c[3]);
  939.         write_1602dat(DisplayBuf_c[4]);
  940.         write_1602dat(DisplayBuf_c[5]);
  941.         write_1602dat(DisplayBuf_c[6]);
  942.         write_1602dat(DisplayBuf_c[7]);
  943.                 write_1602dat(' ');
  944.         write_1602dat(' ');write_1602dat(' ');write_1602dat(' ');write_1602dat(' ');
  945. }
  946. void ctrl( void )
  947. {
  948.     uchar j,i;
  949.         if( PcdRequest( PICC_REQIDL, &CardRevBuf[0] ) != MI_OK )//寻天线区内未进入休眠状态的卡，返回卡片类型 2字节        
  950.         {
  951.                 if( PcdRequest( PICC_REQIDL, &CardRevBuf[0] ) != MI_OK )//寻天线区内未进入休眠状态的卡，返回卡片类型 2字节        
  952.                 {
  953.                  if(chushihua==1)
  954.                  {
  955.                  read_eeprom_j(current_id);
  956.                   display_no_id();
  957.                  }
  958.                         return;
  959.                 }        
  960.         }

  962.         if( PcdAnticoll( &CardRevBuf[2] ) != MI_OK ) //防冲撞，返回卡的序列号 4字节
  963.         {
  964.         if(chushihua==1)
  965.         {
  966.         read_eeprom_j(current_id);
  967.          display_no_id();
  968.         }
  969.                 return;        
  970.         }

  972.         if( PcdSelect( &CardRevBuf[2] ) != MI_OK )//选卡
  973.         {
  974.         if(chushihua==1)
  975.         {
  976.          read_eeprom_j(current_id);
  977.            display_no_id();
  978.          }
  979.                 return;
  980.         }

  982.         display_id( &CardRevBuf[2] );
  983.         if(CorrectCont==0&&pass==0)
  984.         {
  985.           for(j=0;j<6;j++)
  986.           {
  987.           read_eeprom_j(j);
  988.            if(DisplayBuf[0]==DisplayBuf_c[0]&&DisplayBuf[1]==DisplayBuf_c[1]&&DisplayBuf[2]==DisplayBuf_c[2]&&DisplayBuf[3]==DisplayBuf_c[3]&&DisplayBuf[4]==DisplayBuf_c[4]&&DisplayBuf[5]==DisplayBuf_c[5])
  989.            {
  990.          
  991.                   CorrectCont=1;
  992.                   write_1602com(er);
  993.                         for(j=0;j<16;j++)
  994.                         {
  995.                                 write_1602dat(LockOpen[j]);        
  996.                         }
  997.                         TwoAlam();                        //操作成功提示音
  998.                         ErrorCont=0;
  999.                         KEY=0;                                                                                        //开锁
  1000.                         pass=1;                                                                                        //置正确标志位
  1001.                         TR0=1;                                                                                        //开启定时
  1002.                         for(j=0;j<6;j++)                                                                //将输入清除
  1003.                         {
  1004.                                 InputData[i]=0;
  1005.                         }
  1006.                 return;
  1007.            }
  1008.           }
  1009.         }
  1010. }

  1012. //==============================主函数===============================
  1013. void main(void)
  1014. {
  1015.          unsigned char KEY,NUM;
  1016.         unsigned char i,j;
  1017.          P1=0xFF;                                    //P1口复位
  1018.         TMOD=0x11;                                   //定义工作方式
  1019.          TL0=0xB0;
  1020.          TH0=0x3C;                                   //定时器赋初值
  1021.          EA=1;                                           //打开中断总开关
  1022.          ET0=1;                                           //打开中断允许开关
  1023.          TR0=0;                                           //打开定时器开关
  1024.          Delay400Ms();         //启动等待，等LCM讲入工作状态
  1025.          lcd_init();         //LCD初始化
  1026.         Init_DS1302();
  1027.         init_rc522();
  1028.         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  1029.         for(i=0;i<15;i++)
  1030.         {
  1031.                 write_1602dat(table[i]);//向液晶屏写开机画面
  1032.         }
  1033.         write_1602com(er);
  1034.         for(i=0;i<16;i++)
  1035.         {
  1036.                 write_1602dat(start_line[i]);//写输入密码等待界面
  1037.         }
  1038.         write_1602com(er+9);        //设置光标位置
  1039. //        write_1602com(0x0f);        //设置光标为闪烁
  1040.          Delay5Ms(); //延时片刻(可不要)

  1042.          N=0;                                                                                                                //初始化数据输入位数
  1043.          while(1)                 //进入循环
  1044.          {
  1045. //     keyscan();
  1046.          if(flag==0)
  1047.          {
  1048.             ctime.second=DS1302Read(READ_SECOND);
  1049.               ctime.minute=DS1302Read(READ_MINUTE);
  1050.               ctime.hour=DS1302Read(READ_HOUR);
  1051.             write_sfm(10,ctime.second);  //送液晶显示
  1052.             write_sfm(7,ctime.minute);
  1053.             write_sfm(4,ctime.hour);
  1054.          }
  1055.                 ctrl();
  1056.                 if(key_disable==1)                                                //锁定键盘标志为1时
  1057.                         Alam_KeyUnable();                                        //报警键盘锁
  1058.                 else
  1059.                         ALAM=1;                                                                //关报警

  1061.                 KEY=keynum();                                                        //读按键的位置码
  1062.                 if(KEY!=0)                                                                //当有按键按下时
  1063.                 {        
  1064.                         if(key_disable==1)                                        //锁定键盘标志为1时
  1065.                         {
  1066.                                 second=0;                                                //秒清零
  1067.                         }
  1068.                         else                                                                //没有锁定键盘时
  1069.                         {
  1070.                                 NUM=coding(KEY);                                //根据按键的位置将其编码，编码值赋值给NUM
  1071.                                 {
  1072.                                         switch(NUM)                                        //判断按键值
  1073.                                         {
  1074.                                                 case ('A'):if(chushihua==1)
  1075.                                                             {
  1076.                                                              current_id++;
  1077.                                                                 if(current_id>5)
  1078.                                                                               current_id=0;
  1079.                                                                          }
  1080.                                                                          else
  1081.                                                                          {
  1082.                                                                                    s1num++;
  1083.                                               flag=1;
  1084.                                                                                     switch(s1num)
  1085.                                                                                           {
  1086.                                                                                              case 1:
  1087.                                                                                                        TR1=0;
  1088.                                                                                                            write_1602com(yi+11);
  1089.                                                                                                            write_1602com(0x0f);
  1090.                                                                                                            DS1302Write(0x8e,0x00);
  1091.                                                                                                            DS1302Write(WRITE_SECOND,0x80);
  1092.                                                                                                            DS1302Write(0x8e,0x80);
  1093.                                                                                                            break;
  1094.                                                                                                  case 2:
  1095.                                                                                                        write_1602com(0x80+8);
  1096.                                                                                                            break;
  1097.                                                                                                  case 3:
  1098.                                                                                                        write_1602com(0x80+5);
  1099.                                                                                                            break;
  1100.                                                                                                  case 4:
  1101.                                                                                                        s1num=0;
  1102.                                                                                                              write_1602com(0x0c);
  1103.                                                                                                            flag=0;
  1104.                                                                                                            DS1302Write(0x8e,0x00);
  1105.                                                                                                            DS1302Write(WRITE_SECOND,0x00);
  1106.                                                                                                            DS1302Write(0x8e,0x80);
  1107.                                                                                                            break;
  1108.                                                                                           
  1109.                                                                                           }
  1110.                                                                          }
  1111.                                                                                                          break;
  1112.                                                 case ('B'):                if(chushihua==1)   
  1113.                                                                   write_eeprom_jj(current_id);
  1114.                                                                                 else if(s1num!=0)
  1115.                                                                                                 {
  1116.                                                                                                                    switch(s1num)
  1117.                                                                                                                          {
  1118.                                                                                                                            case 1:
  1119.                                                                                                                                   second1=ctime.second/16*10+ctime.second%16;
  1120.                                                                                                                                           second1++;
  1121.                                                                                                                                           if(second1==60)
  1122.                                                                                                                                              second1=0;
  1123.                                                                                                                                           ctime.second=second1/10*16+second1%10;
  1124.                                                                                                                                           DS1302Write(0x8e,0x00);
  1125.                                                                                                                                           DS1302Write(WRITE_SECOND,ctime.second);
  1126.                                                                                                                                           DS1302Write(0x8e,0x80);
  1127.                                                                                                                                           write_sfm(10,ctime.second);
  1128.                                                                                                                                           write_1602com(0x80+10);
  1129.                                                                                                                                           break;
  1130.                                                                                                                            case 2:
  1131.                                                                                                                                   minute1=ctime.minute/16*10+ctime.minute%16;
  1132.                                                                                                                                           minute1++;
  1133.                                                                                                                                           if(minute1==60)
  1134.                                                                                                                                              minute1=0;
  1135.                                                                                                                                           ctime.minute=minute1/10*16+minute1%10;
  1136.                                                                                                                                           DS1302Write(0x8e,0x00);
  1137.                                                                                                                                           DS1302Write(WRITE_MINUTE,ctime.minute);
  1138.                                                                                                                                           DS1302Write(0x8e,0x80);
  1139.                                                                                                                                           write_sfm(7,ctime.minute);
  1140.                                                                                                                                           write_1602com(0x80+7);
  1141.                                                                                                                                           break;
  1142.                                                                                                                            case 3:
  1143.                                                                                                                                   hour1=ctime.hour/16*10+ctime.hour%16;
  1144.                                                                                                                                           hour1++;
  1145.                                                                                                                                           if(hour1==24)
  1146.                                                                                                                                              hour1=0;
  1147.                                                                                                                                           ctime.hour=hour1/10*16+hour1%10;
  1148.                                                                                                                                           DS1302Write(0x8e,0x00);
  1149.                                                                                                                                           DS1302Write(WRITE_HOUR,ctime.hour);
  1150.                                                                                                                                           DS1302Write(0x8e,0x80);
  1151.                                                                                                                                           write_sfm(4,ctime.hour);
  1152.                                                                                                                                           write_1602com(0x80+4);
  1153.                                                                                                                                           break;
  1154.                                                                                                                         
  1155.                                                                                                                          }
  1156.                                                                                                 }  
  1157.                                                                                                                                break;
  1158.                                                 case ('C'):if(chushihua==1)
  1159.                                                               write_eeprom_j(current_id);
  1160.                                                                    else if(s1num!=0)
  1161.                                                                    {
  1162.                                                                                     switch(s1num)
  1163.                                                                                          {
  1164.                                                                                            case 1:
  1165.                                                                                                   second1=ctime.second/16*10+ctime.second%16;
  1166.                                                                                                           second1--;
  1167.                                                                                                           if(second1==-1)
  1168.                                                                                                              second1=59;
  1169.                                                                                                           ctime.second=second1/10*16+second1%10;
  1170.                                                                                                           DS1302Write(0x8e,0x00);
  1171.                                                                                                           DS1302Write(WRITE_SECOND,ctime.second);
  1172.                                                                                                           DS1302Write(0x8e,0x80);
  1173.                                                                                                           write_sfm(10,ctime.second);
  1174.                                                                                                           write_1602com(0x80+10);
  1175.                                                                                                           break;
  1176.                                                                                            case 2:
  1177.                                                                                                   minute1=ctime.minute/16*10+ctime.minute%16;
  1178.                                                                                                           minute1--;
  1179.                                                                                                           if(minute1==-1)
  1180.                                                                                                              minute1=59;
  1181.                                                                                                           ctime.minute=minute1/10*16+minute1%10;
  1182.                                                                                                           DS1302Write(0x8e,0x00);
  1183.                                                                                                           DS1302Write(WRITE_MINUTE,ctime.minute);
  1184.                                                                                                           DS1302Write(0x8e,0x80);
  1185.                                                                                                           write_sfm(7,ctime.minute);
  1186.                                                                                                           write_1602com(0x80+7);
  1187.                                                                                                           break;
  1188.                                                                                            case 3:
  1189.                                                                                                   hour1=ctime.hour/16*10+ctime.hour%16;
  1190.                                                                                                           hour1--;
  1191.                                                                                                           if(hour1==-1)
  1192.                                                                                                              hour1=23;
  1193.                                                                                                           ctime.hour=hour1/10*16+hour1%10;
  1194.                                                                                                           DS1302Write(0x8e,0x00);
  1195. ……………………

  1197. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
代码与视频演示.7z (7.06 MB, 下载次数: 197)


评分

参与人数 2黑币 +62 收起 理由
anorec + 12 很给力！
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏5 分享淘帖 顶顶1 踩踩
回复

使用道具 举报

沙发
ID:434146 发表于 2019-11-24 18:37 | 只看该作者
你好 没有对应的电路图文件啊,能分享一下吗?
回复

使用道具 举报

板凳
ID:632402 发表于 2019-12-10 21:47 | 只看该作者
感谢楼主的分享！
回复

使用道具 举报

地板
ID:764690 发表于 2020-5-29 23:02 | 只看该作者
好资料，51黑有你更精彩!!!
回复

使用道具 举报

5#
ID:782249 发表于 2020-6-17 22:31 | 只看该作者
感谢楼主的分享！
回复

使用道具 举报

6#
ID:92810 发表于 2020-6-28 11:40 | 只看该作者

你好 有没有对应的电路图文件
回复

使用道具 举报

7#
ID:880891 发表于 2021-2-1 15:00 | 只看该作者
里面不包含工程文件吗?怎么没有看到?
回复

使用道具 举报

8#
ID:328014 发表于 2021-2-1 15:11 | 只看该作者
苏念 发表于 2021-2-1 15:00
里面不包含工程文件吗?怎么没有看到?

楼主可能不小心把工程文件给删除了,但是下载后我们会发现,里面有工程备份文件,可以把这个备份文件改为工程文件,就顺利打开了整个代码工程了,如图:

51hei.png (12.27 KB, 下载次数: 18)

51hei.png

51hei.png (39.36 KB, 下载次数: 20)

51hei.png

51hei.png (6.98 KB, 下载次数: 19)

51hei.png
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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