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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机时钟为什么实际和仿真上的时间不一样呢?
返回列表 发新帖
查看: 3326|回复: 2
打印 上一主题 下一主题
收起左侧

单片机时钟为什么实际和仿真上的时间不一样呢?

[复制链接]
跳转到指定楼层
楼主
ID:308346 发表于 2018-5-9 21:34 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
不是应该在烧录程序的时候会和电脑上的时间一致吗？
仿真上显示的是正确的时间，但烧录到开发板上的时间就不对，年份初始化为13-01-01，时间为00：00：00，星期为星期一（应该是星期二才对）不想加按键调时，这个问题可以解决吗？

附上仿真图和实际图



以下附单片机代码部分：

  1. #include <reg52.h>                 //调用单片机头文件
  2. #define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
  3. #define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535
  4. #include "eeprom52.h"
  5. #include "intrins.h"

  7. bit flag_200ms ;
  8. bit flag_100ms ;

  10. sbit dq   = P3^7;          //18b20 IO口的定义

  12. uint temperature ;    //温度变量

  14. uchar menu_1,menu_2;

  16. #include "ds1302.h"
  17. #include "lcd1602.h"

  19. /******************把数据保存到单片机内部eeprom中******************/
  20. void write_eeprom(){
  21.         SectorErase(0x2000);
  22.         byte_write(0x2000, fen1);
  23.         byte_write(0x2001, shi1);
  24.         byte_write(0x2002, open1);
  25.         byte_write(0x2058, a_a);        
  26. }

  28. /******************把数据从单片机内部eeprom中读出来*****************/
  29. void read_eeprom(){
  30.         fen1  = byte_read(0x2000);
  31.         shi1  = byte_read(0x2001);
  32.         open1 = byte_read(0x2002);
  33.         a_a   = byte_read(0x2058);
  34. }

  36. /**************开机自检eeprom初始化*****************/
  37. void init_eeprom(){
  38.         read_eeprom();                //先读
  39.         if(a_a != 1)                //新的单片机初始单片机内问eeprom
  40.         {
  41.                 fen1  = 3;
  42.                 shi1  = 8;
  43.                 open1  = 1;
  44.                 a_a = 1;
  45.                 write_eeprom();           //保存数据
  46.         }        
  47. }

  49. /***********************18b20初始化函数*****************************/
  50. void init_18b20(){
  51.         bit q;
  52.         dq = 1;                                //把总线拿高
  53.         delay_uint(1);            //15us
  54.         dq = 0;                                //给复位脉冲
  55.         delay_uint(80);                //750us
  56.         dq = 1;                                //把总线拿高 等待
  57.         delay_uint(10);                //110us
  58.         q = dq;                                //读取18b20初始化信号
  59.         delay_uint(20);                //200us
  60.         dq = 1;                                //把总线拿高 释放总线
  61. }

  63. /*************写18b20内的数据***************/
  64. void write_18b20(uchar dat){
  65.         uchar i;
  66.         for(i=0;i<8;i++){                                         //写数据是低位开始
  67.                 dq = 0;                         //把总线拿低写时间隙开始
  68.                 dq = dat & 0x01; //向18b20总线写数据了
  69.                 delay_uint(5);         // 60us
  70.                 dq = 1;                         //释放总线
  71.                 dat >>= 1;
  72.         }        
  73. }

  75. /*************读取18b20内的数据***************/
  76. uchar read_18b20(){
  77.         uchar i,value;
  78.         for(i=0;i<8;i++){
  79.                 dq = 0;                         //把总线拿低读时间隙开始
  80.                 value >>= 1;         //读数据是低位开始
  81.                 dq = 1;                         //释放总线
  82.                 if(dq == 1)                 //开始读写数据
  83.                         value |= 0x80;
  84.                 delay_uint(5);         //60us        读一个时间隙最少要保持60us的时间
  85.         }
  86.         return value;                 //返回数据
  87. }

  89. /*************读取温度的值 读出来的是小数***************/
  90. uint read_temp(){
  91.         uint value;
  92.         uchar low;                           //在读取温度的时候如果中断的太频繁了，就应该把中断给关了，否则会影响到18b20的时序
  93.         init_18b20();                   //初始化18b20
  94.         write_18b20(0xcc);           //跳过64位ROM
  95.         write_18b20(0x44);           //启动一次温度转换命令
  96.         delay_uint(50);                   //500us
  97.         init_18b20();                   //初始化18b20
  98.         write_18b20(0xcc);           //跳过64位ROM
  99.         write_18b20(0xbe);           //发出读取暂存器命令
  100.         EA = 0;
  101.         low = read_18b20();           //读温度低字节
  102.         value = read_18b20();  //读温度高字节
  103.         EA = 1;
  104.         value <<= 8;                   //把温度的高位左移8位
  105.         value |= low;                   //把读出的温度低位放到value的低八位中
  106.         value *= 0.625;               //转换到温度值 小数
  107.         return value;                   //返回读出的温度 带小数
  108. }

  110. /******************1ms 延时函数*******************/
  111. void delay_1ms(uint q){
  112.         uint i,j;
  113.         for(i=0;i<q;i++)
  114.                 for(j=0;j<120;j++);
  115. }

  117. /******************写星期函数*******************/
  118. void write_week(uchar hang,uchar add,uchar week)//写星期函数
  119. {
  120.         if(hang==1)   
  121.                 write_com(0x80+add);
  122.         else
  123.                 write_com(0x80+0x40+add);         
  124.         switch(week){
  125.                 case 1:write_data('M');//星期数为1时，显示
  126.                            write_data('O');
  127.                            write_data('N');
  128.                            break;
  129.            
  130.                 case 2:write_data('T');//星期数据为2时显示
  131.                            write_data('U');
  132.                            write_data('E');
  133.                            break;
  134.                
  135.                 case 3:write_data('W');//星期数据为3时显示
  136.                            write_data('E');
  137.                            write_data('D');
  138.                            break;
  139.                
  140.                 case 4:write_data('T');//星期数据为4是显示
  141.                            write_data('H');
  142.                            write_data('U');
  143.                            break;
  144.                
  145.                 case 5:write_data('F');//星期数据为5时显示
  146.                            write_data('R');
  147.                            write_data('I');
  148.                            break;
  149.                
  150.                 case 6:write_data('S');//星期数据为6时显示
  151.                            write_data('T');
  152.                            write_data('A');
  153.                            break;
  154.                
  155.                 case 7:write_data('S');//星期数据为7时显示
  156.                            write_data('U');
  157.                            write_data('N');
  158.                            break;
  159.         }
  160. }

  162. /*************时钟显示***************/
  163. void init_1602_ds1302(){
  164.         write_sfm2_ds1302(1,1,shi);                   //显示时
  165.         write_sfm2_ds1302(1,4,fen);                   //显示分
  166.         write_sfm2_ds1302(1,7,miao);           //显示秒
  167.         write_week(2,12,week);                                                //显示星期
  168.         write_sfm3_18B20(1,11,temperature);           //显示温度
  169.         
  170.         write_sfm2_ds1302(2,2,nian);   //显示年
  171.         write_sfm2_ds1302(2,5,yue);           //显示月        
  172.         write_sfm2_ds1302(2,8,ri);           //显示日         
  173. }                                                                           

  175. /*************定时器0初始化程序***************/
  176. void init_time0()          {
  177.         EA   = 1;                   //开总中断
  178.         TMOD = 0X01;          //定时器0、工作方式1
  179.         ET0  = 1;                  //开定时器0中断
  180.         TR0  = 1;                  //允许定时器0定时
  181. }

  183. /*****************主函数********************/
  184. void main(){        
  185.         delay_1ms(150);
  186.         P0 = P1 = P2 = P3 = 0xff;                //单片机IO口初始化为1
  187.         init_time0();                 //初始化定时器
  188.         init_ds1302();                 //ds1302初始化
  189.         init_1602();                 //lcd1602初始化
  190.         init_1602_dis_csf(); //lcd1602初始化显示
  191.         init_eeprom();       //开始初始化保存的数据
  192.         temperature = read_temp();        //先读出温度的值
  193.         delay_1ms(650);
  194.         temperature = read_temp();        //先读出温度的值
  195.         while(1){
  196.                 if(flag_200ms == 1){        
  197.                         flag_200ms = 0;
  198.                         if(menu_1 == 0){
  199.                                 read_time();                  //读时间
  200.                                 temperature = read_temp();        //先读出温度的值
  201.                                 init_1602_ds1302();   //显示时钟
  202.                         }
  203.                 }
  204.                 delay_1ms(1);
  205.         }
  206. }

  208. /**************定时器0中断程序*****************/
  209. void time0() interrupt 1{                        
  210.         static uchar value;
  211.         TH0 = 0X3C;
  212.         TL0 = 0XB0;           //50ms
  213.         value ++;           
  214.         if((value % 2) == 0)         //100ms  
  215.                 flag_100ms = 1;         
  216.         if(value >= 6)                         //200ms
  217.         {
  218.                 value = 0;
  219.                 flag_200ms = 1;
  220.         }
  221. }



  225. //////////////////////////*****************************************//////////
  226. #ifndef _DS1302_H_
  227. #define _DS1302_H_

  229. /******************
  230.         ds1302 内部RAM   RAM0  1100 000R/W   1读 0写
  231.                                          RAM1  1100 001R/W  
  232.                                                .......
  233.                                          RAM30 1111 110R/W   
  234. ********************/

  236. sbit clk = P3^6;          //ds1302时钟线定义
  237. sbit io =  P3^4;          //数据线
  238. sbit rst = P3^5;          //复位线
  239.                                                 //秒  分   时   日   月  年   星期         
  240. uchar code write_add[]={0x80,0x82,0x84,0x86,0x88,0x8c,0x8a};   //写地址
  241. uchar code read_add[] ={0x81,0x83,0x85,0x87,0x89,0x8d,0x8b};   //读地址
  242. uchar code init_ds[]  ={0x58,0x00,0x00,0x01,0x01,0x13,0x01};

  244. //uchar miao,fen,shi,ri,yue,week,nian;
  245. uchar  miao,fen,shi,ri,yue,week,nian;        
  246. uchar i;
  247. uchar fen1=0x11,shi1=0;          //两个闹钟变量的定义
  248. bit open1;

  250. /*************写一个数据到对应的地址里***************/
  251. void write_ds1302(uchar add,uchar dat)
  252. {               
  253.         rst = 1;                         //把复位线拉高
  254.         for(i=0;i<8;i++){                                     //低位在前
  255.                 clk = 0;                 //时钟线拿低开始写数据
  256.                 io = add & 0x01;            
  257.                 add >>= 1;                 //把地址右移一位
  258.                 clk = 1;                 //时钟线拿高
  259.         }        
  260.         for(i=0;i<8;i++){
  261.                 clk = 0;                 //时钟线拿低开始写数据
  262.                 io = dat & 0x01;
  263.                 dat >>= 1;                 //把数据右移一位
  264.                 clk = 1;                 //时钟线拿高
  265.         }
  266.         rst = 0;                         //复位线合低
  267.         clk = 0;
  268.         io = 0;
  269. }

  271. /*************从对应的地址读一个数据出来***************/
  272. uchar read_ds1302(uchar add){
  273.         uchar value,i;
  274.         rst = 1;                         //把复位线拿高
  275.         for(i=0;i<8;i++){                                     //低位在前
  276.                 clk = 0;                 //时钟线拿低开始写数据
  277.                 io = add & 0x01;            
  278.                 add >>= 1;                 //把地址右移一位
  279.                 clk = 1;                 //时钟线拿高
  280.         }               
  281.         for(i=0;i<8;i++){
  282.                 clk = 0;                 //时钟线拿低开始读数据
  283.                 value >>= 1;
  284.                 if(io == 1)
  285.                         value |= 0x80;
  286.                 clk = 1;                 //时钟线拿高
  287.         }
  288.         rst = 0;                         //复位线合低
  289.         clk = 0;
  290.         io = 0;
  291.         return value;                 //返回读出来的数据
  292. }

  294. /*************把要的时间 年月日 都读出来***************/
  295. void read_time(){
  296.         miao = read_ds1302(read_add[0]);        //读秒
  297.         fen  = read_ds1302(read_add[1]);        //读分
  298.         shi  = read_ds1302(read_add[2]);        //读时
  299.         ri   = read_ds1302(read_add[3]);        //读日
  300.         yue  = read_ds1302(read_add[4]);        //读月
  301.         nian = read_ds1302(read_add[5]);        //读年
  302.         week = read_ds1302(read_add[6]);        //读星期           
  303. }

  305. /*************把要写的时间 年月日 都写入ds1302里***************/
  306. void write_time(){
  307.         write_ds1302(0x8e,0x00);                        //打开写保护
  308.         write_ds1302(write_add[0],miao);        //写秒
  309.         write_ds1302(write_add[1],fen);                //写分
  310.         write_ds1302(write_add[2],shi);                //写时
  311.         write_ds1302(write_add[3],ri);                //写日
  312.         write_ds1302(write_add[4],yue);                //写月
  313.         write_ds1302(write_add[5],nian);        //写年
  314.         write_ds1302(write_add[6],week);        //写星期
  315.         write_ds1302(0x8e,0x80);                        //关闭写保护
  316. }

  318. /*************把数据保存到ds1302 RAM中**0-31*************/
  319. void write_ds1302ram(uchar add,uchar dat){
  320.         add <<= 1;     //地址是从第二位开始的
  321.         add &= 0xfe;   //把最低位清零  是写的命令
  322.         add |= 0xc0;   //地址最高两位为 1  
  323.         write_ds1302(0x8e,0x00);
  324.         write_ds1302(add,dat);        
  325.         write_ds1302(0x8e,0x80);
  326. }

  328. /*************把数据从ds1302 RAM读出来**0-31*************/
  329. uchar read_ds1302ram(uchar add){
  330.         add <<= 1;     //地址是从第二位开始的
  331.         add |= 0x01;   //把最高位置1  是读命令
  332.         add |= 0xc0;   //地址最高两位为 1  
  333.         return(read_ds1302(add));        
  334. }

  336. /*************初始化ds1302时间***************/
  337. void init_ds1302(){
  338.         uchar i;
  339.         rst = 0;        //第一次读写数据时要把IO口拿低
  340.         clk = 0;
  341.         io = 0;
  342.         i = read_ds1302ram(30);///***DS1302与RAM相关的寄存器，单个RAM单元，共31个，每个单元组态为一个8位的字节，其命令控制字为COH~FDH***///
  343.                                                    ///***把数据从30地址中毒出来***///
  344.         if(i != 3){        
  345.                 i = 3;
  346.                 write_ds1302ram(30,i);                         //4050   4100                 3080

  348.                 write_ds1302(0x8e,0x00);                    //打开写保护
  349.                 for(i=0;i<7;i++)
  350.                         write_ds1302(write_add[i],init_ds[i]);        //把最高位值0 允许ds1302工作
  351.                 write_ds1302(0x8e,0x80);        //关写保护
  352.         }
  353. }
  354. #endif











  366. //////////////////////////*****************************************//////////
  367. #ifndef _EEPROM52_H_
  368. #define _EEPROM52_H_
  369. uchar a_a;
  370. #include <intrins.h>

  372. #define RdCommand 0x01 //定义ISP的操作命令
  373. #define PrgCommand 0x02
  374. #define EraseCommand 0x03
  375. #define Error 1
  376. #define Ok 0
  377. #define WaitTime 0x01 //定义CPU的等待时间
  378. sfr ISP_DATA=0xe2;  //寄存器申明
  379. sfr ISP_ADDRH=0xe3;
  380. sfr ISP_ADDRL=0xe4;
  381. sfr ISP_CMD=0xe5;
  382. sfr ISP_TRIG=0xe6;
  383. sfr ISP_CONTR=0xe7;

  385. /* ================ 打开 ISP,IAP 功能 ================= */
  386. void ISP_IAP_enable(void){
  387.          EA = 0;       /* 关中断   */
  388.          ISP_CONTR = ISP_CONTR & 0x18;       /* 0001,1000 */
  389.          ISP_CONTR = ISP_CONTR | WaitTime; /* 写入硬件延时 */
  390.          ISP_CONTR = ISP_CONTR | 0x80;       /* ISPEN=1  */
  391. }

  393. /* =============== 关闭 ISP,IAP 功能 ================== */
  394. void ISP_IAP_disable(void){
  395.          ISP_CONTR = ISP_CONTR & 0x7f; /* ISPEN = 0 */
  396.          ISP_TRIG = 0x00;
  397.          EA   =   1;   /* 开中断 */
  398. }

  400. /* ================ 公用的触发代码 ==================== */
  401. void ISPgoon(void){
  402.          ISP_IAP_enable();   /* 打开 ISP,IAP 功能 */
  403.          ISP_TRIG = 0x46;  /* 触发ISP_IAP命令字节1 */
  404.          ISP_TRIG = 0xb9;  /* 触发ISP_IAP命令字节2 */
  405.          _nop_();
  406. }

  408. /* ==================== 字节读 ======================== */
  409. unsigned char byte_read(unsigned int byte_addr)
  410. {
  411.         EA = 0;
  412.          ISP_ADDRH = (unsigned char)(byte_addr >> 8);/* 地址赋值 */
  413.          ISP_ADDRL = (unsigned char)(byte_addr & 0x00ff);
  414.          ISP_CMD   = ISP_CMD & 0xf8;   /* 清除低3位  */
  415.          ISP_CMD   = ISP_CMD | RdCommand; /* 写入读命令 */
  416.          ISPgoon();       /* 触发执行  */
  417.          ISP_IAP_disable();    /* 关闭ISP,IAP功能 */
  418.          EA  = 1;
  419.          return (ISP_DATA);    /* 返回读到的数据 */
  420. }

  422. /* ================== 扇区擦除 ======================== */
  423. void SectorErase(unsigned int sector_addr){
  424.          unsigned int iSectorAddr;
  425.          iSectorAddr = (sector_addr & 0xfe00); /* 取扇区地址 */
  426.          ISP_ADDRH = (unsigned char)(iSectorAddr >> 8);
  427.          ISP_ADDRL = 0x00;
  428.          ISP_CMD = ISP_CMD & 0xf8;   /* 清空低3位  */
  429.          ISP_CMD = ISP_CMD | EraseCommand; /* 擦除命令3  */
  430.          ISPgoon();       /* 触发执行  */
  431.          ISP_IAP_disable();    /* 关闭ISP,IAP功能 */
  432. }

  434. /* ==================== 字节写 ======================== */
  435. void byte_write(unsigned int byte_addr, unsigned char original_data){
  436.          EA  = 0;
  437. //         SectorErase(byte_addr);
  438.          ISP_ADDRH = (unsigned char)(byte_addr >> 8);  /* 取地址  */
  439.          ISP_ADDRL = (unsigned char)(byte_addr & 0x00ff);
  440.          ISP_CMD  = ISP_CMD & 0xf8;    /* 清低3位 */
  441.          ISP_CMD  = ISP_CMD | PrgCommand;  /* 写命令2 */
  442.          ISP_DATA = original_data;   /* 写入数据准备 */
  443.          ISPgoon();       /* 触发执行  */
  444.          ISP_IAP_disable();     /* 关闭IAP功能 */
  445.          EA =1;
  446. }
  447. #endif








  456. //////////////////////////*****************************************//////////
  457. #ifndef _LCD1602_H_
  458. #define _LCD1602_H_

  460. #define uchar unsigned char
  461. #define uint unsigned int

  463. #define data_1602 P0
  464. uchar code table_num[]="0123456789abcdefg";

  466. sbit rs=P2^6;         //寄存器选择信号 H:数据寄存器          L:指令寄存器
  467. sbit rw=P2^5;         //寄存器选择信号 H:数据寄存器          L:指令寄存器
  468. sbit e =P2^7;         //片选信号   下降沿触发

  470. /***********************延时函数************************/
  471. void delay_uint(uint q){
  472.         while(q--);
  473. }

  475. /***********************lcd1602写命令函数************************/
  476. void write_com(uchar com){
  477.         e=0;
  478.         rs=0;
  479.         rw=0;
  480.         P0=com;
  481.         delay_uint(3);
  482.         e=1;
  483.         delay_uint(25);
  484.         e=0;
  485. }

  487. /***********************lcd1602写数据函数************************/
  488. void write_data(uchar dat){
  489.         e=0;
  490.         rs=1;
  491.         rw=0;
  492.         P0=dat;
  493.         delay_uint(3);
  494.         e=1;
  495.         delay_uint(25);
  496.         e=0;        
  497. }

  499. /***********************lcd1602初始化设置************************/
  500. void init_1602()         //lcd1602初始化设置
  501. {
  502.         write_com(0x38);        //
  503.         write_com(0x0c);
  504.         write_com(0x06);
  505. }

  507. /***********************lcd1602上显示两位十进制数************************/
  508. void write_sfm1(uchar hang,uchar add,uchar date)        ///***显示星期函数***从十位开始写///
  509. {
  510.         if(hang==1)   
  511.                 write_com(0x80+add);
  512.         else
  513.                 write_com(0x80+0x40+add);
  514.         write_data(table_num[date % 10]);        
  515. }  

  517. /***********************lcd1602上显示两位十进制数************************/
  518. void write_sfm2(uchar hang,uchar add,uchar date)  ///***显示时分秒函数***从十位开始写///
  519. {
  520.         if(hang==1)   
  521.                 write_com(0x80+add);
  522.         else
  523.                 write_com(0x80+0x40+add);
  524.         write_data(table_num[date / 10 % 10]);        
  525.         write_data(table_num[date % 10]);        
  526. }


  529. /***********************lcd1602上显示两位十进制数************************/
  530. void write_sfm3_18B20(uchar hang,uchar add,uint date)  ///***显示温度函数***从十位开始写///
  531. {
  532.         if(hang==1)   
  533.                 write_com(0x80+add);
  534.         else
  535.                 write_com(0x80+0x40+add);
  536.         write_data(0x30+date/100%10);
  537.         write_data(0x30+date/10%10);
  538.         write_data('.');
  539.         write_data(0x30+date%10);        
  540. }



  544. /***********************lcd1602上显示两位十进制数************************/
  545. void write_sfm2_ds1302(uchar hang,uchar add,uchar date){
  546.         if(hang==1)   
  547.                 write_com(0x80+add);
  548.         else
  549.                 write_com(0x80+0x40+add);         
  550.         write_data(table_num[date/16]);
  551.         write_data(table_num[date%16]);        
  552. }

  554. /***********************lcd1602上显示这字符函数************************/
  555. void write_string(uchar hang,uchar add,uchar *p){
  556.         if(hang==1)   
  557.                 write_com(0x80+add);
  558.         else
  559.                 write_com(0x80+0x40+add);
  560.                 while(1)                                                                                                                 
  561.                 {
  562.                         if(*p == '\0')  break;
  563.                         write_data(*p);
  564.                         p++;
  565.                 }        
  566. }

  568. /*****************控制光标函数********************/
  569. void write_guanbiao(uchar hang,uchar add,uchar date){               
  570.         if(hang==1)   
  571.                 write_com(0x80+add);
  572.         else
  573.                 write_com(0x80+0x40+add);
  574.         if(date == 1)
  575.                 write_com(0x0f);     //显示光标并且闪烁        
  576.         else
  577.                 write_com(0x0c);   //关闭光标
  578. }        

  580. /***********************lcd1602上显示特定的字符************************/
  581. void write_zifu(uchar hang,uchar add,uchar date){
  582.         if(hang==1)   
  583.                 write_com(0x80+add);
  584.         else
  585.                 write_com(0x80+0x40+add);
  586.         write_data(date);        
  587. }

  589. /***********************lcd1602清除显示************************/
  590. void clear_1602(){
  591.         write_string(1,0,"                ");
  592.         write_string(2,0,"                ");
  593. }

  595. /****************开机液晶显示函数 初始化液晶的内容********************************/
  596. void init_1602_dis_csf()  //初始化液晶
  597. {
  598.         write_string(1,0,"   :  :    00.0");               
  599.         write_string(2,0,"20  -  -       ");        
  600.         write_zifu(1,15,0xdf);  //显示度        
  601. }
  602. #endif
复制代码



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

使用道具 举报

沙发
ID:303383 发表于 2018-5-9 23:04 | 只看该作者
提示: 作者被禁止或删除 内容自动屏蔽
回复

使用道具 举报

板凳
ID:293977 发表于 2018-5-9 23:23 | 只看该作者
因为时间信息是存储在时钟芯片里的，解决办法就是你第一次烧录的时候把你设定的时间信息写到时钟芯片里，之后烧录就不要再去改动里面的时间信息了。如果需要再重新改时钟芯片里的时钟信息。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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