标题: 带GPS授时语音报时的大数字万年历制作 附单片机程序 DS12C887 DS3231芯片 [打印本页]
作者: yyhyyhyyh    时间: 2020-10-31 04:08
标题: 带GPS授时语音报时的大数字万年历制作 附单片机程序 DS12C887 DS3231芯片
制作出来的万年历实物图如下,走时非常精准：

提醒：
1、所有标 C1、C2、C3、R1的元件先不用安装，主要为抗干扰预留，若在使用中不正常才可安装。
2、所有电阻阻值前标“*”表示该电阻可根据LED元件性能或个人使用习惯浮动调节。
3、如果使用mini_USB，需要一定的焊接功夫。可先将焊锡加在5个引脚焊盘上。
4、不能使用劣等供电电源，板子上很多芯片都怕高频干扰！

注意：
1、在有GPS连接的情况下，+、-、EXIT 无效，短按MOD可强制GPS校时。
2、冒号闪烁开关、整点报时开关变量保存入24C02，断电不丢失。
3、调时中，秒不可调整。调到分钟时秒自动回零。
4、调时中可随时按EXIT不保存退出，也可以一直按MOD保存退出。







P0 ：DS12C887-AD

//max7219
sbit DIN  = P1^0;
sbit LOAD = P1^1;
sbit CLK  = P1^2;

//控制冒号是否闪烁
sbit BLK  = P1^3;     

//按键 MOD + - EXIT
sbit K1  = P1^4; //K1-调时设置，长按进入时间设置；短按作为日期时间下一项。当gps有效时，短按以gps时间校时
sbit K2  = P1^5; //K2-调时中作+，    运行中作为报时
sbit K3  = P1^6; //K3-调时中作-，    （运行中可留作12/24模式切换）
sbit K4  = P1^7; //K4-调时中作确认、返回；运行中作是否报时选择键

//DS3231，24C02
sbit SCL= P2^0;   
sbit SDA= P2^1;   

P2^2 : DHT11

//语音报时指示灯
sbit SND  = P2^3;

//DS12C887 控制IO
sbit DS  = P2^4;   //兼做电波钟BPC的P0控制
sbit RW  = P2^5;
sbit AS  = P2^6;
sbit CS  = P2^7;

P3^0 ：串口RXD
P3^1 ：串口TXD

//DS3231 SQW
sbit INT0= P3^2;

//PWM语音芯片
sbit BUSY = P3^3;
sbit DATA = P3^4;
sbit RST  = P3^5;

P3^6 ： 红外;
P3^7 ： DS18B20;

供电电路：
一、电源预留宽电压输入降压：
1、1117-5
2、7805
若有5V电源，可以将降压芯片输入输出短接。

二、电源输入滤波部分可根据使用的电源质量酌情考虑

三、1.5KE68CA为双向过压保险设计，可无视！

四、部分器件使用3.3V电压，因此使用1117-3.3。输出必须22uF和0.1uF滤波。



24C02是存储冒号是否闪烁及整点报时开关

万年历语音报时芯片与τ 宝原版芯片不一样，地址向后错一位。

原版芯片开机送电产生脉冲即会播报第一个地址“零”，新版定制芯片把第一个地址留空。而且在地址最后额外增加了3个语音：猫叫、老鼠叫、猫叫老鼠叫混合。

语音芯片有3个接口：
SPK1_1、SPK1_2并联，哪个使用方便就接哪个。喇叭建议8Ω/0.25--0.5W
SPK2_1 为放大语音，一般不建议使用。


单片机源程序如下:
  1. //89C52RC + 11.0592M
  2. //语音报时，手动调时，gps授时，电脑校时
  3. //GPS有效信号（VA）稳定达10分钟后自动校时
  4. //电脑可串口发送数据强制校时 GPRMC,024813.640,,,,,,,,150706,X
  5. //                                                         标志头         时分秒                          日月年 标志尾
  6. //DS3231 SQW已引入中断P3.2，但本程序未使用外部中断
  7. //2016.5.10
  8. #include<reg52.h>
  9. #include <intrins.h>
  10. #include <string.h>
  11. #include "DS3231.h"
  12. #include "nongli.h"
  13. #include "iic.h"
  14. /********************************************************************************************************************
  15.                 以下为GPS部分定义
  16. 因时间关系，gps数据应该加校验处理，防止出现乱码情况，虽然gps被干扰的情况很罕见。待其他有精力的玩家来解决
  17. ********************************************************************************************************************/
  18. //GPS数据存储数组
  19. u8 time[6];        //时间
  20. u8 date[6];        //日期
  21. bit va;                           //有效
  22. bit QJ;                           //电脑发送强制校时信号
  23. bit tswc;                   //调时完成标志

  25. //串口中断需要的变量
  26. u8 seg_count;        //逗号计数器
  27. u8 dot_count;        //小数点计数器
  28. u8 byte_count;        //位数计数器

  30. u8 mode;                //0：结束模式，1：命令模式，2：数据模式
  31. u8 buf_full;            //1：整句接收完成，相应数据有效。0：缓存数据无效。
  32. u8 cmd[5];            //命令类型存储数组

  34. typedef  struct        _TIMER          /** 作时区转换时需要用到年、月、日进一 **/
  35. {
  36.     u8 Hour;
  37.     u8 Min;
  38.     u8 Sec;
  39.     u8 Day;
  40.     u8 Mon;
  41.     u8 Year;
  42. } TIMER;
  43. TIMER BjTime;

  45. void InitBps();                           /**  串口初始化 **/
  46. void UTCToLocal(TIMER *GPS_DataTmp);  //时区转换
  47. void Set_DStime(u8 sel);
  48. void GetGpsTime(void);
  49. void FormatString(char *p);
  50. void updatetime();

  52. int gpscount=0;  //gps有效计时

  54. /////////////////////////////////////
  55. sbit DIN  = P1^0;
  56. sbit LOAD = P1^1;
  57. sbit CLK  = P1^2;

  59. sbit BUSY = P3^3;
  60. sbit DATA = P3^4;
  61. sbit RST  = P3^5;

  63. /********按键部分 按键采用定时器配合状态机        **/
  64. bit  TS_Mode;//调时标志
  65. u8   Tcount;  //10ms计数

  67. xdata        uint        F_50ms_Loop                =        0;
  68. xdata        uint        F_500ms_Loop        =        0;

  70. bit        F_50ms        =        1;
  71. bit        F_500ms        =        1;
  72.          
  73. u8   KeyValue;

  75. sbit K1  = P1 ^ 4; //K1-调时设置，长按进入时间设置；短按作为日期时间下一项。当gps有效时，短按以gps时间校时
  76. sbit K2  = P1 ^ 5; //K2-调时中作+，        运行中作为手动报时
  77. sbit K3  = P1 ^ 6; //K3-调时中作-，        运行中作冒号闪烁开关
  78. sbit K4  = P1 ^ 7; //K4-调时中作确认、返回；运行中作整点报时开关

  80. sbit BLK  = P1 ^ 3;         //冒号是否闪烁
  81. sbit SND  = P2 ^ 3;         //语音报时指示灯
  82. bit bs;
  83. bit ss,sb;  //冒号闪烁标志

  85. void key_scan(void);
  86. void Led_Flash(u8 n,bit f);


  89. u8   DStime[8]={0,0,0,0,0,0,0,0};//秒，分，时，周，日，月，年，温度
  90. u8   S[7]={0,0,0,0,0,0,0};//调时时的中间变量

  92. bit sound;//报时指示灯标志 是否允许报时
  93. u8 spkcount;//报时段参数

  95. u8 e;//对应调时的位置
  96. u8  item, max, mini;

  98. void FormatDT();

  100. void Delay_50us(uint t)        //50us延迟函数
  101. {
  102.      u8 j;
  103.          for(;t>0;t--)
  104.           for(j=19;j>0;j--);
  105. }


  108. void speak(uint z)      //赋值变量 Z  Z等于几就播放第几段
  109. {
  110.     RST = 1;                          //语音芯片的复位脚为高电平//
  111.     Delay_50us(4);      //持续 200us//
  112.     RST = 0;                          //然后复位脚置零//
  113.     Delay_50us(4);
  114.         z++;                                /*自己定制语音芯片后移一位,如果使用原版报时芯片，此句应删除*/
  115.     while(z > 0)            //若 Z等于 0 则不工作，若大于 0则继续自减//
  116.     {
  117.         DATA = 1;                  //data 脚位为高电平//
  118.         Delay_50us(3);    //持续 100us//
  119.         DATA = 0;                  //然后置零//
  120.         Delay_50us(3);    //持续 100us这三句的意思就是发从一个 100us的脉冲（高低各 100us）//
  121.         z--;             //z 自减完成后开始播放对应的语音（因为z 是几就播放第几段）//
  122.     }
  123. }

  125. //          八点整
  126. //    八点  零一分
  127. //    八点  十  分
  128. //    八点  十一分
  129. //    八点二十  分
  130. //          八点二十一分
  131. //  十一点
  132. //二十  点
  133. //二十一点
  134. void baoshi()//7--21点报时
  135. {
  136.           if(spkcount<1 || spkcount>9) return;

  138.          

  140. //第二级MAX7219写入字（16位）

  142. void WriteWord_2 (u8 addr, u8 num) //发现与第二及第三块相连的数码管闪烁,增加了空操作后就不闪烁了!!
  143. {
  144.     LOAD = 0;
  145.     _nop_();
  146.     SendChar (NoOp);
  147.     _nop_();
  148.     SendChar (0);

  150.     _nop_();
  151.     SendChar (addr);
  152.     _nop_();
  153.     SendChar (num);
  154.     _nop_();
  155.     SendChar (NoOp);
  156.     _nop_();
  157.     SendChar (0);
  158.     _nop_();

  160.     LOAD = 1;
  161. }

  163. //            向第三级MAX7219写入字（16位）
  164. void WriteWord_1 (u8 addr, u8 num) //发现与第二及第三块相连的数码管闪烁,增加了空操作后就不闪烁了!!
  165. {
  166.     LOAD = 0;
  167.     _nop_();
  168.     SendChar (NoOp);
  169.     _nop_();
  170.     SendChar (0);
  171.     _nop_();
  172.     SendChar (NoOp);
  173.     _nop_();
  174.     SendChar (0);
  175.     _nop_();
  176.     SendChar (addr);
  177.     _nop_();
  178.     SendChar (num);
  179.     _nop_();
  180.     LOAD = 1;
  181. }
  182. void init()
  183. {
  184.     K1 = 1;
  185.     K2 = 1;
  186.     K3 = 1;
  187.     K4 = 1;

  189.         QJ=0;
  190.         SND=1;//关
  191.         sound=0;
  192.         RST=0;
  193.         DATA=0;
  194.         Tcount=0;


  197.         TS_Mode=0;
  198.         KeyValue=0;
  199.         tswc=0;

  201.         ss=Read_02_Data(0);
  202.         Delay_50us(40);

  204.         SND=Read_02_Data(2);
  205.         Delay_50us(40);

  207.         clrwdt;
  208.         bs=0;

  210. }
  211. void InitDis (void)
  212. {
  213.     WriteWord_1 (ScanLimit,ScanDigit-1);        /*设置扫描界限*/
  214.     WriteWord_1 (DecodeMode,DecodeDigit);      /*设置译码模式*/
  215.     WriteWord_1 (Intensity,IntensityGrade);    /*设置亮度*/
  216.     WriteWord_1 (ShutDown,NormalOperation);    /*设置电源工作模式*/
  217.    
  218.     WriteWord_2 (ScanLimit,ScanDigit-2);        /*设置扫描界限*/
  219.     WriteWord_2 (DecodeMode,DecodeDigit);      /*设置译码模式*/
  220.     WriteWord_2 (Intensity,IntensityGrade);   /*设置亮度*/
  221.     WriteWord_2 (ShutDown,NormalOperation);    /*设置电源工作模式*/

  223.     WriteWord_3 (ScanLimit,ScanDigit);         /*设置扫描界限*/
  224.     WriteWord_3 (DecodeMode,DecodeDigit);      /*设置译码模式*/
  225.     WriteWord_3 (Intensity,IntensityGrade);    /*设置亮度*/
  226.     WriteWord_3 (ShutDown,NormalOperation);    /*设置电源工作模式*/
  227. }
  228. /*日期、时间设置函数---------------------------------------------------------*/

  230. void        GetDateTime()        //获取DS3231当前日期和时间
  231. {
  232.                 u8        Tmp,i;
  233.                 for(i=0;i<7;i++)
  234.                 {
  235.                     if(i==3)         //星期不理睬
  236.                            continue;
  237.                         Tmp=read_random(i);        
  238.                         if(i==2)
  239.                                 Tmp&=0x3f;        //时的格式单独处理
  240.                         DStime[i]        =        BCD2HEX(Tmp);               
  241.                 }
  242. }
  243. void        ShowTime(bit b)        //更新信息
  244. {
  245.         WriteWord_2 (Digit4, DStime[0]/10);
  246.         WriteWord_2 (Digit5, DStime[0]%10);
  247.                 if(gpscount)
  248.                 {
  249.                     WriteWord_3 (Digit4, BjTime.Sec/10);   //测试gps走时
  250.                     WriteWord_3 (Digit5, BjTime.Sec%10);
  251.                 }
  252.            if(b) //更新全部信息
  253.            {
  254.                 if(DStime[3]==0 ||DStime[3]==7)         //星期日=8
  255.                         DStime[3]=8;
  256.                 DStime[7]=read_temp() ;

  258.                 WriteWord_2 (Digit0, DStime[2]<10 ? 0x0F:DStime[2]/10);
  259.                 WriteWord_2 (Digit1, DStime[2]%10);
  260.                 WriteWord_2 (Digit2, DStime[1]/10);
  261.                 WriteWord_2 (Digit3, DStime[1]%10);

  263.                         WriteWord_1 (Digit0, DStime[6]/10);
  264.                 WriteWord_1 (Digit1, DStime[6]%10);
  265.                 WriteWord_1 (Digit2, DStime[5]<10?0x0F:1);
  266.                 WriteWord_1 (Digit3, DStime[5]%10);
  267.                 WriteWord_1 (Digit4, DStime[4]<10?0x0F:DStime[4]/10);
  268.                 WriteWord_1 (Digit5, DStime[4]%10);
  269.                 WriteWord_1 (Digit6, DStime[3]);        
  270.         
  271.                 WriteWord_3 (Digit0, month_moon<10? 0x0F:1);
  272.                 WriteWord_3 (Digit1, month_moon%10);
  273.                 WriteWord_3 (Digit2, day_moon<10? 0x0F:day_moon/10);
  274.                 WriteWord_3 (Digit3, day_moon%10);

  276.                         if(!gpscount)
  277.                         {
  278.                         WriteWord_3 (Digit4, 0x0F);   //无湿度计
  279.                         WriteWord_3 (Digit5, 0x0F);
  280.                         }
  281.                 if(DStime[7]<128)//正数时直接显示
  282.                 {
  283.                                 WriteWord_3 (Digit6, DStime[7] / 10);
  284.                                 WriteWord_3 (Digit7, DStime[7] % 10);
  285.                 }
  286.                 else
  287.                 {
  288.                                 WriteWord_3 (Digit6, 0x0A);//负数显示 -
  289.                                 WriteWord_3 (Digit7, DStime[7] % 10);        //零下只显示一位        
  290.                 }        

  292.                 }
  293. }
  294. void        Led_Flash(u8 n,bit f)        //调试时闪烁提示效果
  295. {
  296.     if(n < 3)
  297.     {
  298.         if(f)
  299.         {
  300.             WriteWord_1 (n*2 + 1, 0x0F);
  301.             WriteWord_1 (n*2 + 2, 0x0F);
  302.         }
  303.         else
  304.         {
  305.             WriteWord_1 (n*2 + 1, S[n] / 10);
  306.             WriteWord_1 (n*2 + 2, S[n] % 10);
  307.         }                                                                                                                                                                                                                                                                                                                        
  308.     }
  309.     else
  310.     {
  311.                 if(f)
  312.         {
  313.             WriteWord_2 ((n-4)*2 + 1, 0x0F);
  314.             WriteWord_2 ((n-4)*2 + 2, 0x0F);

  316.         }
  317.         else
  318.         {
  319.             WriteWord_2 ((n-4)*2 + 1, S[n] / 10);
  320.             WriteWord_2 ((n-4)*2 + 2, S[n] % 10);
  321.         }

  323.     }
  324. }
  325. void updatetime()
  326. {
  327.         u8 i;
  328.                 S[3]= Conver_WEEK( S[0], S[1], S[2]);
  329.                 if(S[3]== 0)
  330.                    S[3]=7;
  331.         for(i = 0; i < 7; i++)
  332.         {
  333.             if(S[i] != DStime[6-i])
  334.                 ModifyTime(6-i, S[i]);
  335.         }
  336. }
  337. //按键扫描，定时10ms执行一次
  338. static u8 KeyScan(void)
  339. {
  340.     if(K1 == 0)return KEY_VALUE_1 ;
  341.     if(K2 == 0)return KEY_VALUE_2 ;
  342.     if(K3 == 0)return KEY_VALUE_3 ;
  343.     if(K4 == 0)return KEY_VALUE_4 ;
  344.     return KEY_NULL ;
  345. }
  346. u8  GetKey(void)
  347. {
  348.     static u8 s_u8KeyState = KEY_STATE_INIT ;
  349.     static u8 s_u8KeyTimeCount = 0 ;
  350.     static u8 s_u8LastKey = KEY_NULL ;  //保存按键释放时候的键值
  351.     u8 KeyTemp = KEY_NULL ;
  352.     KeyTemp = KeyScan() ;        //获取键值
  353.     switch(s_u8KeyState)
  354.     {
  355.             case KEY_STATE_INIT :
  356.             {
  357.                 if(KEY_NULL != (KeyTemp))
  358.                 {
  359.                     s_u8KeyState = KEY_STATE_WOBBLE ;
  360.                 }
  361.             }
  362.             break ;
  363.             case KEY_STATE_WOBBLE :      //消抖
  364.             {
  365.                 s_u8KeyState = KEY_STATE_PRESS ;
  366.             }
  367.             break ;
  368.             case KEY_STATE_PRESS :
  369.             {
  370.                 if(KEY_NULL != (KeyTemp))
  371.                 {
  372.                     s_u8LastKey = KeyTemp ; //保存键值,以便在释放按键状态返回键值
  373.                     KeyTemp |= KEY_DOWN ;  //按键按下
  374.                     s_u8KeyState = KEY_STATE_LONG ;
  375.                 }
  376.                 else
  377.                 {
  378.                     s_u8KeyState = KEY_STATE_INIT ;
  379.                 }
  380.             }
  381.             break ;
  382.             case KEY_STATE_LONG :
  383.             {
  384.                 if(KEY_NULL != (KeyTemp))
  385.                 {
  386.                     if(++s_u8KeyTimeCount > KEY_LONG_PERIOD)
  387.                     {
  388.                         s_u8KeyTimeCount = 0 ;
  389.                         KeyTemp |= KEY_LONG ;  //长按键事件发生
  390.                         s_u8KeyState = KEY_STATE_CONTINUE ;
  391.                     }
  392.                 }
  393.                 else
  394.                 {
  395.                     s_u8KeyState = KEY_STATE_RELEASE ;
  396.                 }
  397.             }
  398.             break ;
  399.             case KEY_STATE_CONTINUE :
  400.             {
  401.                 if(KEY_NULL != (KeyTemp))
  402.                 {
  403.                     if(++s_u8KeyTimeCount > KEY_CONTINUE_PERIOD)
  404.                     {
  405.                         s_u8KeyTimeCount = 0 ;
  406.                         KeyTemp |= KEY_CONTINUE ;
  407.                     }
  408.                 }
  409.                 else
  410.                 {
  411.                     s_u8KeyState = KEY_STATE_RELEASE ;
  412.                 }
  413.             }
  414.             break ;
  415.             case KEY_STATE_RELEASE :
  416.             {
  417.                 s_u8LastKey |= KEY_UP ;
  418.                 KeyTemp = s_u8LastKey ;
  419.                 s_u8KeyState = KEY_STATE_INIT ;
  420.             }
  421.             break ;
  422.             default :
  423.                 break ;
  424.     }
  425.     return KeyTemp ; //返回键值
  426. }
  427. void  KeyProc(void)
  428. {
  429.                 u8 i;
  430.         if(!va && !TS_Mode && KeyValue == (KEY_VALUE_1 | KEY_LONG))   //无gps+长按K1进入调时
  431.         {
  432.             TS_Mode = 1;                //进入调时模式
  433.             for(i = 0; i < 7; i++)         
  434.             {
  435.                 S[i] = DStime[6 - i];
  436.             }
  437.         }

  439.         if(KeyValue == (KEY_VALUE_1 | KEY_DOWN))
  440.         {
  441.             if(TS_Mode)                //在调时状态下进入下一项设置
  442.             {
  443.                 if(S[e] != DStime[6 - e] || e>4)
  444.                 {
  445.                     ModifyTime(6 - e, S[e]);
  446.                     DStime[6 - e] = S[e];
  447.                 }
  448.                                 
  449.                 e++;
  450.                 if(e == 3) //跳过调整星期
  451.                     e++;

  453.                 if (e == 5)        //调到分钟时，秒置零
  454.                 {
  455.                                         S[6]=0;
  456.                             WriteWord_2 (5, 0);
  457.                             WriteWord_2 (6, 0);
  458.                                 }
  459.                 if (e > 5)
  460.                 {
  461.                     ModifyTime(0, 0);
  462.                                         e = 0;
  463.                     TS_Mode = 0;                                //修改退出
  464.                                         tswc=1;                                       
  465.                 }
  466.             }

  468.             if(va)                   //有gps按下即强制校时
  469.             {
  470.                 GetGpsTime();
  471.                 updatetime();
  472.             }
  473.         }

  475.         if(KeyValue == (KEY_VALUE_2 | KEY_DOWN))        //+
  476.         {
  477.             if(TS_Mode)
  478.             {
  479.                 item = S[e];
  480.                 item++;//数加 1
  481.                 Set_DStime(e);
  482.             }
  483.             else //运行中做报时键
  484.             {
  485.                 sound = 1;
  486.                 spkcount = 9;
  487.             }
  488.         }
  489.         if(KeyValue == (KEY_VALUE_3 | KEY_DOWN))        //-
  490.         {
  491.             if(TS_Mode)
  492.             {
  493.                 item = S[e];
  494.                                 if(item == 0)
  495.                                 {
  496.                                         if(e==4)
  497.                                                 item=23;
  498.                                          else
  499.                                                 item=59;
  500.                                 }
  501.                                 else
  502.                 item--;//数减 1
  503.                 Set_DStime(e);
  504.             }
  505.                         else
  506.                         {
  507.                                 ss=~ss;         //闪烁
  508.                                 sb=1;
  509.                         }
  510.         }

  512.         if(KeyValue == (KEY_VALUE_4 | KEY_DOWN))        //EXIT
  513.         {
  514.             if(TS_Mode)
  515.             {
  516.                 TS_Mode = 0;                       //退出调时
  517.                 e = 0;                                   //"下一项"计数器清0
  518.                 //updatetime();
  519.                                 tswc=1;
  520.             }
  521.             else
  522.             {
  523.                 SND = ~SND;                          /**  运行模式中 K4 作语音报时切换键  **/
  524.                                 bs=1;                                
  525.             }
  526.         }
  527. }

  529. void main()//主函数
  530. {
  531.     u8 Temp, TempT;
  532.     u8 i = 0;
  533.     u8 ee = 0;
  534.     bit d = 0;
  535.     e = 0;
  536.     TempT = Temp = 0;

  538.     init();
  539.     InitDis ();
  540.     InitBps();
  541.     Delayms(100);

  543.     GetDateTime();

  545.     Conversion( DStime[6], DStime[5], DStime[4]);
  546.     DStime[3] = Conver_WEEK( DStime[6], DStime[5], DStime[4]);
  547.     ShowTime(1);

  549.     BLK = 0;
  550.     clrwdt;
  551.         

  553.     while(1)//进入无限循环
  554.     {
  555.         if(TS_Mode  == 0)         //运行模式
  556.         {
  557.             if(F_50ms)        //50ms标志
  558.             {
  559.                 GetDateTime();
  560.                 F_50ms        =        0;
  561.             }

  563.             if(QJ)        //电脑发送的校时信息
  564.             {
  565.                 GetGpsTime();
  566.                 updatetime();
  567.                                 tswc=1;
  568.                 QJ = 0;
  569.             }

  571.             if(Temp != DStime[0]) //不用频繁更新，有变化才更新一次
  572.             {
  573.                 if(va && TempT != BjTime.Sec) //如果接收到GPRMC有效数据
  574.                 {
  575.                     TempT = BjTime.Sec;
  576.                     if(gpscount++ == 600) //持续有效达10分钟即自动校时，可根据GPS性能调整
  577.                     {
  578.                         GetGpsTime();
  579.                         updatetime();
  580.                     }
  581.                     if(gpscount > 86400) //若gps挂机超过1天则回零
  582.                         gpscount = 0;
  583.                 }
  584.                 else
  585.                 {
  586.                     gpscount = 0;
  587.                     va = 0;
  588.                 }

  590.                 if(DStime[0] == 0 ||  tswc)  //每分钟或调时完成全部刷新
  591.                 {
  592.                     if(DStime[1] == 0)        //每小时
  593.                     {
  594.                         //Conversion( DStime[6], DStime[5], DStime[4]);
  595.                         //DStime[3]        = Conver_WEEK( DStime[6], DStime[5], DStime[4]);
  596.                         
  597.                         if(DStime[2] > 6 && DStime[2] < 22 )        //7--21点报时
  598.                         {
  599.                             InitDis ();//每小时初始化一次
  600.                                                         if(!SND )
  601.                                                         {
  602.                                                                 sound = 1;         //整点报时
  603.                                     spkcount = 9;
  604.                                                         }
  605.                         }
  606.                                                 else  //夜间节能模式
  607.                                                 {
  608.                                                         WriteWord_1 (Intensity,0);
  609.                                                         WriteWord_2 (Intensity,0);
  610.                                                         WriteWord_3 (Intensity,0);
  611.                                                 }

  613.                     }
  614.                     Conversion( DStime[6], DStime[5], DStime[4]);
  615.                     DStime[3]        = Conver_WEEK( DStime[6], DStime[5], DStime[4]);
  616.                     ShowTime(1); //每分钟全部更新一次 ,调整完时间退出后全部更新一次
  617.                     if(tswc)
  618.                     {
  619.                                                 tswc = 0;
  620.                     }
  621.                     
  622.                 }
  623.                 else
  624.                     ShowTime(0);  //只更新秒

  626.                 Temp = DStime[0];

  628.                                 if(sb)
  629.                                 {
  630.                                   Write_02_Data(0,ss);
  631.                                   Delay_50us(40);
  632.                                   sb=0;                                                                  
  633.                                 }
  634.                                 if(ss)
  635.                         BLK=~BLK;          //开启冒号闪烁
  636.             }
  637.             if(sound && BUSY)
  638.             {
  639.                 baoshi();
  640.                 if(spkcount < 1 || spkcount > 20 )
  641.                     sound = 0; //退出报时
  642.             }
  643.                         if(bs) //报时存储
  644.                         {
  645.                                   Write_02_Data(2,SND);
  646.                                   Delay_50us(40);
  647.                                   bs=0;
  648.                         }

  650.         }
  651.         else
  652.         {
  653.             //调试状态，led应闪烁指示调整位
  654.             if(F_500ms)        //500ms标志
  655.             {
  656.                 d = ~d;
  657.                 if(e != ee )   //调整下一项时防止上一项不亮
  658.                 {
  659.                     Led_Flash(ee, 0);
  660.                     ee = e;
  661.                 }
  662.                 Led_Flash(e, d);

  664.                 F_500ms        =        0;
  665.             }
  666.             //if()        //进入调时超过5分钟后自动退出 （该功能略）
  667.         }
  668.         clrwdt;        //设置看门狗
  669.     }
  670. }

  672. /*-----------------------------日期、时间设置函数-----------------------------*/
  673. //被调数据加一或减一，并检查数据范围，写入3231指定地址保存
  674. void ds_w(u8 sel)
  675. {
  676.     if(item > max) item = mini;         //查看数值是否在有效范围之内
  677.     if(item < mini) item = max;         //如果数值小于最小值，则自动等于最大值
  678.         S[sel]=item;
  679. }
  680. void Set_DStime(u8 sel)  //根据选择调整的相应项目加1并写入DS3231，函数参数是按动设置键的次数
  681. {
  682.     if(sel == 3 || sel == 6)  return; //星期不用设置
  683.         /*        秒不用设置，调到分钟时，秒置零
  684.         if(sel == 6)
  685.     {
  686.         max = 59;
  687.         mini = 0;
  688.         ds_w(sel);                  //被调数据加一或减一函数
  689.     }        
  690.         //秒7，按动7次显示 调整秒钟
  691.     //秒钟数据的最大值是59，最小值是0
  692.         */

  694.     if(sel == 5)
  695.     {
  696.         max = 59;
  697.         mini = 0;
  698.         ds_w(sel);

  700.     }        
  701.         //分钟6，按动6次显示 调整分钟
  702.     //分钟数据的最大值是59，最小值是0

  704.     if(sel == 4)
  705.     {
  706.         max = 23;
  707.         mini = 0;
  708.         ds_w(sel);

  710.     }        //小时5，按动5次显示 调整小时
  711.     //小时数据最大值23，最小值是0        

  713.     if(sel == 2)
  714.     {
  715.         if(S[1] == 2 && S[0] % 4 != 0)
  716.         {
  717.             max = 28;    //平年2月28天
  718.             mini = 1;
  719.         }
  720.         if(S[1] == 2 && S[0] % 4 == 0)
  721.         {
  722.             max = 29;    //闰年2月29天
  723.             mini = 1;
  724.         }
  725.         if(S[1] == 1 || S[1] == 3 || S[1] == 5 || S[1] == 7 || S[1] == 8 || S[1] == 10 || S[1] == 12)
  726.         {
  727.             max = 31;    //31天的月份
  728.             mini = 1;
  729.         }
  730.         if(S[1] == 4 || S[1] == 6 || S[1] == 9 || S[1] == 11)
  731.         {
  732.             max = 30;    //30天的月份
  733.             mini = 1;
  734.         }
  735. ……………………

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

所有资料51hei提供下载:
万年历.7z (3.73 MB, 下载次数: 185)

作者: jdf    时间: 2020-10-31 10:42
感谢分享，最好能附上原理图和打板文件
作者: tian_000    时间: 2020-10-31 21:49
感谢分享，这个有点大
作者: 93mxt    时间: 2021-3-2 01:02
一乐原创
作者: xjx51    时间: 2021-8-19 14:50
语音芯片建议用NVC080C系列的，可以改音量，内存也很大，资料上网找
作者: kz0018    时间: 2022-5-23 13:20
描述的很详细，楼主辛苦！实际制作大部分都是贴片器件，焊接任务太大了，不易成功，不过还是要谢谢分享
作者: kz0018    时间: 2022-6-7 17:52
资料丰富齐全，表述清晰明了，多谢分享！
作者: kz0018    时间: 2022-7-14 12:13
今天仔细看了一遍，感觉大数码管电源5v电压似乎驱动不了，四个led串联至少要有7v以上的电压才可点亮，如何设计电源？应有详细描述。
作者: 懒洋洋y    时间: 2022-7-14 14:16
jdf 发表于 2020-10-31 10:42
感谢分享，最好能附上原理图和打板文件

非常好用
作者: lksbbs    时间: 2022-7-22 09:17
kz0018 发表于 2022-5-23 13:20
描述的很详细，楼主辛苦！实际制作大部分都是贴片器件，焊接任务太大了，不易成功，不过还是要谢谢分享

贴片的最好焊了,胶水粘上热风枪随便吹吹就好
作者: joyb    时间: 2023-10-28 17:45
请教GPS模块是哪个？



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1