标题: 分享一个LCD1602电子闹钟 双闹版 带单片机源程序 [打印本页]

---

作者: liyz    时间: 2017-4-9 17:43
标题: 分享一个LCD1602电子闹钟 双闹版 带单片机源程序


   我是从95年左右开始玩单片机，还买片TD-II单板机（纯机器代码输入的）那时我还没有电脑，我只学会用汇编，现在已经好多年没玩了，最近突然又想玩玩单片机做个闹钟，汇编语言已经忘得差不多了，那就学学用C语言吧，在网上找到几份学习资料逐渐明白了C语言奥秘。这是参考别人的资料花了好几个星期一步一步增加功能修改出来的，已经做了成品给小孩当闹钟用，增加了语音报时(用yf017语音芯片)，存储记忆(24C02)，两组闹钟(一组可设置每周工作日响闹，另一组可设置每天响闹或只响一次，还有再响等功能)，电路图就懒得画了，纯属业余玩玩给大家参考。




附上不错的C51学习资料：
《51单片机C语言快速上手》.pdf (4.6 MB, 下载次数: 100)

2017-4-9 17:37 上传

点击文件名下载附件
下载积分: 黑币 -5

十天学会单片机实例100.docx (198.15 KB, 下载次数: 57)

2017-4-9 17:38 上传

点击文件名下载附件
下载积分: 黑币 -5

单片机源程序：

1. /*******************************************************************************
   
2. *标题：                    DS1302+DS18B20+LCD1602电子时钟                       *
   
3. *                                                                                                   *
   
4. ********************************************************************************
   
5. * 添加闹钟时间记忆，闹铃时长，闹钟再响次数，间隔，周闹钟功能，语音整点报时          *
   
6. *                                                               
   
7. *                        
   
8. ********************************************************************************/                                       
   
9. #include <reg52.h>
   
10. #include <intrins.h>
    
11. #define uchar unsigned char
    
12. #define uint  unsigned int
    
13. #include "24c02.h"
    
14. #include "LCD1602.h"
    
15. #include "DS1302.h"
    
16. #include "DS18B20.h"
    
17. #include "yuyin.h"
    
18. 
    
19. sbit key1=P2^3;                  //调时钟和闹钟键
    
20. sbit key2=P2^2;                  //调时加键,正常走时状态语音报时键
    
21. sbit key3=P2^1;                  //调时减键,闹钟开关
    
22. sbit key4=P2^0;                  //查看闹铃键
    
23. 
    
24. sbit beep = P2^4;                  //蜂鸣器控制IO口
    
25. sbit led1 = P1^0;                  //LED灯，闹铃响标志
    
26. /******************************************************************/
    
27. /*                    函数声明                                    */
    
28. /******************************************************************/                                                                                                
    
29. void Read_RTC(void);
    
30. void temp_to_str();   
    
31. void keyscan();
    
32. 
    
33. bit  ReadRTC_Flag,Display_Flag,Alarm_Flag,Alarm_Flag1,Aset_Flag,yuyin_flag,zd_baoshi,each,setzx=0;      //定义标志位
    
34. uchar miao,fen,shi,ri,yue,week,nian,T,nz_flag,yuyin_shi,yuyin_ge,m=0,n=0,w=0,m1=0;
    
35. uchar set_miao,set_fen,set_shi,set_time,setzx_time,setzx_f,nz_miao,nz_fen,nz_shi,miao_ss;
    
36. 
    
37. char l_tmpdate[7];                    //秒分时日月周年
    
38. uchar TempBuffer[5],nz_week[7];
    
39. uchar code  write_rtc_address[7]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c}; //秒分时日月周年 最低位写位
    
40. uchar code  read_rtc_address[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d}; //秒分时日月周年 最低位读位
    
41. uchar code  nz_week_address[7]={0x10,0x11,0x12,0x13,0x14,0x15,0x16};
    
42.   
    
43. uchar code table1[]="SUN";                             //星期字表
    
44. uchar code table2[]="MON";
    
45. uchar code table3[]="TUE";
    
46. uchar code table4[]="WED";
    
47. uchar code table5[]="THU";
    
48. uchar code table6[]="FRI";
    
49. uchar code table7[]="SAT";
    
50. 
    
51. uchar code tab1[]=" 20  -  -     ";
    
52. uchar code tab2[]="   :  :   ";
    
53. uchar code tab3[14]="Set Alarm!    ";
    
54. uchar code tab4[16]="w:S M T W T F S ";
    
55. uchar code tab5[]="  *ON  *OFF";
    
56. 
    
57. /******************************************************************/
    
58. /*                             毫秒级延时函数                                                       */
    
59. /******************************************************************/
    
60. void delay(uchar a)
    
61. {
    
62.      uchar i;
    
63.      while(a--)
    
64.            {
    
65.               for(i=0;i<250;i++)
    
66.                     {
    
67.                            _nop_();
    
68.                _nop_();
    
69.                            _nop_();
    
70.                _nop_();  
    
71.                         }
    
72.            }   
    
73. }
    
74. 
    
75. void delay1(uchar a)
    
76. {
    
77.      uchar i;
    
78.      while(a--)
    
79.            {
    
80.               for(i=0;i<5;i++)
    
81.                     {}
    
82.            }   
    
83. }
    
84. /********************************************/
    
85. /*      取出EEPROM时钟参数初始化函数         */
    
86. /*******************************************/
    
87. void Set_read()
    
88. {
    
89.         uchar i,*p;
    
90.         p=nz_week_address;             //地址传递
    
91.         for(i=0;i<7;i++)                    //分7次读取
    
92.         {
    
93.                 nz_week[i]=Read24c02(*p);
    
94.                 p++;
    
95.         }
    
96.   set_miao=Read24c02(0x03);
    
97.   set_fen=Read24c02(0x02);
    
98.   set_shi=Read24c02(0x01);
    
99.         set_time=Read24c02(0x05);
    
100.   nz_flag=Read24c02(0x06);
     
101.         setzx_time=Read24c02(0x07);
     
102.         setzx_f=Read24c02(0x08);
     
103.         zd_baoshi=Read24c02(0x09);
     
104.         yuyin_flag=Read24c02(0x0a);
     
105.         nz_miao=Read24c02(0x1a);
     
106.   nz_fen=Read24c02(0x1b);
     
107.   nz_shi=Read24c02(0x1c);
     
108.         each=Read24c02(0x1d);
     
109. }
     
110. 
     
111. /**************************************************
     
112.    初始化函数
     
113. ***************************************************/
     
114. void init()
     
115. {
     
116.         uchar i;
     
117.   Alarm_Flag=0;
     
118.         miao_ss=0;
     
119.         led1=1;
     
120. TMOD=0x01;         //设置定时器0为工作方式1（0000 0001）
     
121. TH0=(65536-50000)/256;                      //装初值50ms一次中断
     
122. TL0=(65536-50000)%256;                      //
     
123. IE=0x82;         //开总中断，开定时器0中断
     
124. TR0=0;
     
125.         write_lcd1602(0x80,0);
     
126.   for(i=0;i<10;i++)
     
127.   {
     
128.             write_lcd1602(tab1[i],1);
     
129.   }
     
130.   write_lcd1602(0x80+0x40+1,0);
     
131.   for(i=0;i<7;i++)
     
132.   {
     
133.             write_lcd1602(tab2[i],1);
     
134.   }
     
135. }
     
136. 
     
137. /******************************************************************/
     
138. /*                                     温度数据转换                                                     */
     
139. /******************************************************************/
     
140. void temp_to_str()   //温度数据转换成液晶字符显示
     
141. {
     
142.   /*TempBuffer[0]=temp_value/100%10+0x30;     //十位
     
143.   TempBuffer[1]=temp_value/10%10+0x30;    //个位
     
144.   TempBuffer[2]='.';   
     
145.   TempBuffer[3]=temp_value%10+0x30;
     
146.   TempBuffer[4]=0xdf;                  //温度符号
     
147.         */
     
148.         TempBuffer[0]=temp_value/100+0x30;     //十位
     
149.   TempBuffer[1]=temp_value%100/10+0x30;    //个位
     
150.   TempBuffer[2]='.';   
     
151.   TempBuffer[3]=temp_value%10+0x30;
     
152.   TempBuffer[4]=0xdf;                  //温度符号
     
153. }
     
154. 
     
155. /******************************************************************/
     
156. /*                                             显示星期                                                     */
     
157. /******************************************************************/
     
158. void write_week(uchar xq)                                                
     
159. {
     
160.         uchar x;
     
161.         write_lcd1602(0x80+12,0);
     
162.         switch(xq)
     
163.         {
     
164.                 case 1:
     
165.                 for(x=0;x<3;x++)
     
166.                 {
     
167.                         write_lcd1602(table1[x],1);
     
168.                 }
     
169.                 break;
     
170.                 case 2:
     
171.                 for(x=0;x<3;x++)
     
172.                 {
     
173.                         write_lcd1602(table2[x],1);
     
174.                 }
     
175.                 break;
     
176.                 case 3:
     
177.                 for(x=0;x<3;x++)
     
178.                 {
     
179.                         write_lcd1602(table3[x],1);
     
180.                 }
     
181.                 break;
     
182.                 case 4:
     
183.                 for(x=0;x<3;x++)
     
184.             {
     
185.                         write_lcd1602(table4[x],1);
     
186.                 }
     
187.                 break;
     
188.                 case 5:
     
189.                 for(x=0;x<3;x++)
     
190.                 {
     
191.                         write_lcd1602(table5[x],1);
     
192.                 }
     
193.                 break;
     
194.                 case 6:
     
195.                 for(x=0;x<3;x++)
     
196.                 {
     
197.                         write_lcd1602(table6[x],1);
     
198.                 }
     
199.                 break;
     
200.                 case 7:
     
201.                 for(x=0;x<3;x++)
     
202.                 {
     
203.                         write_lcd1602(table7[x],1);
     
204.                 }
     
205.                 break;
     
206.         }
     
207.         write_lcd1602(0x80+12,0);        
     
208. }
     
209. /*****************************************************/
     
210. /*                  显示闹钟1开关标志函数                   */
     
211. /*****************************************************/
     
212. void a_lcd()
     
213. {
     
214.         if(nz_flag==1)
     
215.                         {
     
216.                                 write_lcd1602(0x80+0x40,0);
     
217.                                 write_lcd1602('A',1);
     
218.                         }
     
219.                         else
     
220.                         {
     
221.                                 write_lcd1602(0x80+0x40,0);
     
222.                                 write_lcd1602(' ',1);
     
223.                           }
     
224.                         }
     
225. /*****************************************************/
     
226. /*                  显示ON和OFF函数                   */
     
227. /*****************************************************/
     
228. void on_off_lcd(uchar f)
     
229. {
     
230.         uchar i;
     
231.                  write_lcd1602(0x80+0x40+10,0);
     
232.            if(f==1)
     
233.                                           {
     
234.                                                       for(i=0;i<6;i++)        
     
235.                                                    {write_lcd1602(tab5[i],1);         }
     
236.                                                           write_lcd1602(0x80+0x40+13,0);
     
237.                                                  }
     
238.                                                         else
     
239.                                                 {
     
240.                                                         for(i=5;i<11;i++)        
     
241.                                                   {    write_lcd1602(tab5[i],1);        }
     
242.                                                          write_lcd1602(0x80+0x40+13,0);
     
243.                                                 }
     
244. }
     
245. /******************************************************************/
     
246. /*                                             显示函数                                                     */
     
247. /******************************************************************/
     
248. void display()
     
249. {
     
250.         uchar i,ww;
     
251.         Read_RTC();
     
252.         write_sfm(8,miao);
     
253.         write_sfm(5,fen);
     
254.         write_sfm(2,shi);
     
255.         write_nyr(3,nian);
     
256.         write_nyr(6,yue);        
     
257.         write_nyr(9,ri);
     
258.         write_week(week);
     
259.         write_lcd1602(0x80+15,0);
     
260.         if(setzx==1)
     
261. {write_lcd1602(0xf3,1);}
     
262. else
     
263.     {
     
264.         ww=nz_week[week-1];
     
265.         if(ww==1)
     
266.         {write_lcd1602(0xeb,1);}
     
267.         else
     
268.         {write_lcd1602(' ',1);}
     
269.      }
     
270.         a_lcd();
     
271.         ReadTemp();
     
272.         temp_to_str();
     
273.         write_lcd1602(0x80+0x40+11,0);
     
274.         for(i=0;i<5;i++)
     
275.         {
     
276.                 write_lcd1602(TempBuffer[i],1);
     
277.         }
     
278. }
     
279. 
     
280. /******************************************************************/
     
281. /*                   读时钟数据                                   */
     
282. /******************************************************************/
     
283. void Read_RTC(void)                //读取 日历
     
284. {
     
285.          uchar i,*p;
     
286.          p=read_rtc_address;             //地址传递
     
287.          for(i=0;i<7;i++)                     //分7次读取 秒分时日月周年
     
288.          {
     
289.                   l_tmpdate[i]=Read_Ds1302(*p);
     
290.                   p++;
     
291.                                                                                                         
     
292.                   miao=((l_tmpdate[0]&0x70)>>4)*10 + (l_tmpdate[0]&0x0f);
     
293.                   fen =((l_tmpdate[1]&0x70)>>4)*10 + (l_tmpdate[1]&0x0f);
     
294.                   shi =((l_tmpdate[2]&0x70)>>4)*10 + (l_tmpdate[2]&0x0f);
     
295.                   ri  =((l_tmpdate[3]&0x70)>>4)*10 + (l_tmpdate[3]&0x0f);
     
296.                   yue =((l_tmpdate[4]&0x70)>>4)*10 + (l_tmpdate[4]&0x0f);
     
297.                   week=((l_tmpdate[5]&0x70)>>4)*10 + (l_tmpdate[5]&0x0f);
     
298.                    nian=((l_tmpdate[6]&0x70)>>4)*10 + (l_tmpdate[6]&0x0f);                    
     
299.          }
     
300. 
     
301. }
     
302. 
     
303. /******************************************************************/
     
304. /*                                     蜂鸣器发声函数                                         */
     
305. /******************************************************************/
     
306. void di()
     
307. {
     
308.         uchar i;
     
309.         while(key1==0||key2==0||key3==0||key4==0)
     
310.         {
     
311.                 for(i=0;i<50;i++)
     
312.                 {
     
313.                         delay1(4);
     
314.                         beep=~beep;
     
315.                 }               
     
316.         }
     
317. }
     
318. /******************/
     
319. void Abeep()
     
320. {
     
321.         uchar i;
     
322.         for(i=0;i<250;i++)
     
323.                         {
     
324.                                 delay1(4);
     
325.                                 beep=~beep;               
     
326.                                 led1=~led1;
     
327.                         }
     
328.                         delay(50);
     
329.                         for(i=0;i<250;i++)
     
330.                         {
     
331.                                 delay1(4);
     
332.                                 beep=~beep;
     
333.                                 led1=~led1;
     
334.                         }
     
335.                         delay(50);
     
336.                         for(i=0;i<250;i++)
     
337.                         {
     
338.                                 delay1(4);
     
339.                                 beep=~beep;
     
340.                                 led1=~led1;
     
341.                         }
     
342. }
     
343. /*********************返回正常计时状态程序******************************/
     
344. void R_normal()
     
345. 
     
346. {
     
347.             uchar i;
     
348.               TR0=0;
     
349.                           miao_ss=0;
     
350.                                 ReadRTC_Flag=0;
     
351.                                 Display_Flag=0;
     
352.                                 Aset_Flag=0;
     
353.                                 n=0;
     
354.                                 write_lcd1602(0x0c,0);
     
355.                                 if(m!=0||m1!=0||w!=0)
     
356.                                 {
     
357.                                    m=0;
     
358.                              m1=0;
     
359.                                          w=0;
     
360.                                          write_lcd1602(0x80,0);  //清掉Set Alarm                           
     
361.                                                 for(i=0;i<12;i++)
     
362.                                                 {
     
363.                                                         write_lcd1602(tab1[i],1);
     
364.                                                 }
     
365.                                                   write_lcd1602(0x80+0x40+1,0);
     
366.             for(i=0;i<10;i++)
     
367.            {
     
368.                     write_lcd1602(tab2[i],1);
     
369.             }
     
370.                                 }
     
371.                                 
     
372.                                                 display();                        
     
373.                         
     
374.                         }
     
375. 
     
376. /******************************************************************/
     
377. /*                                             闹钟函数                                                             */
     
378. /******************************************************************/
     
379. void alarm()
     
380. {
     
381.         uchar tmp,temp;
     
382.         if((nz_week[week-1]==1)&&(shi==set_shi)&&(fen==set_fen)&&(miao==set_miao))
     
383.         {        
     
384.                 //Read_RTC();               
     
385.                 R_normal();
     
386.                 tmp=set_time+fen;              //计算响铃分钟数
     
387.                 if(tmp>=60)
     
388.                 {tmp=tmp%60;}
     
389.                 Alarm_Flag=1;                                            //闹铃响标志位
     
390.                 setzx=1;
     
391.                 led1=0;
     
392.                 if(yuyin_flag==1)
     
393.                         baoshi(shi,fen,week,0);         //语音报当前时间               
     
394.                 while(Alarm_Flag)
     
395.                 {        
     
396.                         Abeep();
     
397.                         delay(500);
     
398.                         Read_RTC();                           //边响边走时
     
399.                         display();
     
400.                         keyscan();
     
401.                          if(tmp==fen)
     
402.                         {
     
403.                                 Alarm_Flag=0;
     
404.                                 setzx_f--;                   //响铃次数减一次
     
405.                                 if(setzx_f!=0)
     
406.                 {
     
407.                         temp=setzx_time+fen;
     
408.                         if(temp>=60)
     
409.                         {
     
410.                         temp=temp%60;
     
411.                          set_shi++;
     
412.                         if(set_shi>23)        
     
413.                         {set_shi=0;}
     
414.                         }        
     
415.                         set_fen=temp;
     
416.                         led1=0;
     
417.                         if(yuyin_flag==1)
     
418.                           baoshi(shi,fen,week,0);         //语音报当前时间
     
419.             }
     
420.                 else               
     
421.                   {
     
422.                           setzx=0;
     
423.                           led1=1;
     
424.         set_fen=Read24c02(0x02);
     
425.         set_shi=Read24c02(0x01);
     
426.                                 setzx_f=Read24c02(0x08);
     
427.                           if(yuyin_flag==1)
     
428.                           baoshi(shi,fen,week,0);         //语音报当前时间   
     
429.                     }
     
430.                         }
     
431.                 }                                                                        
     
432.         }        
     
433. }
     
434. 
     
435. /******************************************************************/
     
436. /*                                             闹钟1函数                                                             */
     
437. /******************************************************************/
     
438. void alarm1()
     
439. {
     
440.         uchar tmp,temp;
     
441.         if((nz_flag==1)&&(shi==nz_shi)&&(fen==nz_fen)&&(miao==nz_miao))
     
442.         {        
     
443.                 //Read_RTC();               
     
444.                 R_normal();
     
445.                 tmp=set_time+fen;              //计算响铃分钟数
     
446.                 if(tmp>=60)
     
447.                 {tmp=tmp%60;}
     
448.                 Alarm_Flag1=1;                                            //闹铃响标志位
     
449.                 setzx=1;
     
450.                 led1=0;
     
451.                 if(yuyin_flag==1)
     
452.                         baoshi(shi,fen,week,0);         //语音报当前时间               
     
453.                 while(Alarm_Flag1)
     
454.                 {        
     
455.                         Abeep();
     
456.                         delay(500);
     
457.                         Read_RTC();                           //边响边走时
     
458.                         display();
     
459.                         keyscan();
     
460.                          if(tmp==fen)
     
461.                         {
     
462.                                 Alarm_Flag1=0;
     
463.                                 setzx_f--;                   //响铃次数减一次
     
464.                                 if(setzx_f!=0)
     
465.                 {
     
466.                         temp=setzx_time+fen;
     
467.                         if(temp>=60)
     
468.                         {
     
469.                         temp=temp%60;
     
470.                          nz_shi++;
     
471.                         if(nz_shi>23)        
     
472.                         {nz_shi=0;}
     
473.                         }        
     
474.                         nz_fen=temp;
     
475.                         led1=0;
     
476.                         if(yuyin_flag==1)
     
477.                           baoshi(shi,fen,week,0);         //语音报当前时间
     
478.             }
     
479.                 else               
     
480.                   {
     
481.                           setzx=0;
     
482.                           led1=1;
     
483.         nz_fen=Read24c02(0x1b);
     
484.         nz_shi=Read24c02(0x1c);
     
485.                                 setzx_f=Read24c02(0x08);
     
486.                                 if(each==0)
     
487.                                 nz_flag=0;
     
488.                           if(yuyin_flag==1)
     
489.                           baoshi(shi,fen,week,0);         //语音报当前时间   
     
490.                     }
     
491.                         }
     
492.                 }                                                                        
     
493. /*                tmp=fen+5;       //响铃x分钟
     
494.                 if(tmp>=60)
     
495.                 {tmp=tmp%60;}
     
496.                 Alarm_Flag1=1;                                            //闹铃响标志位
     
497.                 led1=0;
     
498.                 if(yuyin_flag==1)
     
499.                          baoshi(shi,fen,week,0);         //语音报闹钟时间               
     
500.                 while(Alarm_Flag1)
     
501.                 {        
     
502.                         Abeep();
     
503.                         delay(500);
     
504.                         Read_RTC();                           //边响边走时
     
505.                         display();
     
506.                         keyscan();
     
507.                          if(tmp==fen)
     
508.                         {
     
509.                                 Alarm_Flag1=0;
     
510.                                 led1=1;
     
511.                         if(each==0)
     
512.                                 nz_flag=0;
     
513.                         if(yuyin_flag==1)
     
514.                           baoshi(shi,fen,week,0);         //语音报闹钟时间   
     
515.                         }
     
516.                 }                                                                        */
     
517.         }        
     
518. }
     
519. 
     
520. /******************************************************************/
     
521. /*                                             键盘扫描函数                                             */
     
522. /******************************************************************/
     
523. void keyscan()
     
524. {
     
525.         uchar i,temp;
     
526.         if(Alarm_Flag==0&&Alarm_Flag1==0&&setzx==0)
     
527.         {
     
528.                 if(key1==0)                                                         //调时功能键
     
529.                 {
     
530.                         delay(9);
     
531.                         if(key1==0)
     
532.                         {
     
533.                                 di();
     
534.                                 while(!key1);                                                                                       //松手检测
     
535.                                 miao_ss=0;
     
536.                 if(Display_Flag==0&&m==0&&w==0&&m1==0)               
     
537.                 {               
     
538.                                 ++n;
     
539.                                 Aset_Flag=1;                          //屏蔽调闹铃功能键，进入调时功能
     
540.                                 ReadRTC_Flag=1;                                                                                         //停止走时
     
541.                                 switch(n)
     
542.                                 {
     
543.                                         case 1: on_off_lcd(zd_baoshi);                                      //按一次功能键闪烁
     
544.                                                             write_lcd1602(0x0f,0);
     
545.                                 break;
     
546.                                         case 2: write_lcd1602(0x80+0x40+9,0);                                     //按两次功能键秒闪烁
     
547.                                                             //Write_Ds1302(0x8e,0x00);                                                //允许写，禁止写保护
     
548.                                                             //Write_Ds1302(0x80,((miao/10)*16+miao%10));        //写入DS1302秒位
     
549.                                                             //Write_Ds1302(0x8e,0x80);                                               //打开写保护
     
550.                                                         break;
     
551.                                         case 3: write_lcd1602(0x80+0x40+6,0);                                 //按三次功能键分闪烁                                
     
552.                                                         break;
     
553.                                         case 4: write_lcd1602(0x80+0x40+3,0);                                 //按四次功能键时闪烁                                                               
     
554.                                                         break;
     
555.                                         case 5: write_lcd1602(0x80+10,0);                                          //按五次功能键日闪烁                                                
     
556.                                                         break;
     
557.                                         case 6: write_lcd1602(0x80+7,0);                                          //按六次功能键月闪烁                                                
     
558.                                                         break;
     
559.                                         case 7:write_lcd1602(0x80+4,0);                                          //按七次功能键年闪烁
     
560.                                                         break;
     
561.                                         case 8: write_lcd1602(0x80+12,0);                                         //按八次功能键周闪烁        
     
562.                                                         break;
     
563.                                         case 9: TR0=0;                                                                        //按九次功能键开始走时，停止闪烁
     
564.                                                 n=0;
     
565.                                                          ReadRTC_Flag=0;                                                
     
566.                                             Aset_Flag=0;
     
567.                                                         write_lcd1602(0x0c,0);
     
568.                                                         Write_Ds1302(0x8e,0x00);
     
569.                                                         Write_Ds1302(0x80,((miao/10)*16+miao%10));
     
570.                                                         Write_Ds1302(0x82,((fen/10)*16+fen%10));
     
571.                                                         Write_Ds1302(0x84,((shi/10)*16+shi%10));
     
572.                                                         Write_Ds1302(0x8e,0x80);
     
573.                                                         break;
     
574.                                 }
     
575.                         }
     
576.                 else
     
577.                 {
     
578.                         if(n==0&&w==0&&m1==0&&m>0)
     
579.                 {
     
580.                         m++;
     
581.                         Alarm_Flag=0;                                                 //初始化闹铃标志位，闹铃不响
     
582.                         Alarm_Flag1=0;        
     
583.                         switch(m)
     
584.                         {        case 2: write_lcd1602(0x80+0x40+9,0);                   //开始设定闹铃，秒位闪烁可调
     
585.                                                 write_lcd1602(0x0f,0);
     
586.                                                 break;
     
587.                                 case 3: write_lcd1602(0x80+0x40+6,0);                   //分位闪烁可调
     
588.                                                 break;
     
589.                                 case 4:        write_lcd1602(0x80+0x40+3,0);                   //时位闪烁可调
     
590.                                                 break;
     
591.                                 case 5:        write_lcd1602(0x80+0x40+14,0);                 //
     
592.                                                 break;               
     
593.                                 case 6:        write_lcd1602(0x80+15,0);                       //
     
594.                                     break;
     
595.                                 case 7:        write_lcd1602(0x80+12,0);                       //
     
596.                                     break;
     
597.                                 case 8:        write_lcd1602(0x80+0x40+11,0);                 //
     
598.                                     break;
     
599.                                 case 9:R_normal();
     
600. //                                                display();                                                           //返回时间显示
     
601.                                                 break;
     
602.                                         }
     
603.                     }        
     
604.                 else
     
605.                 if(n==0&&m==0&&m1==0&&w>0)        
     
606.                 {
     
607.                         w++;
     
608.                         Alarm_Flag=0;                                                 //初始化闹铃标志位，闹铃不响
     
609.                         Alarm_Flag1=0;        
     
610.                         switch(w)
     
611.                         {        case 2: write_lcd1602(0x80+0x40+2,0);                  
     
612.                                                     write_lcd1602(0x0f,0);           //开始闪烁
     
613.                                                 break;
     
614.                                 case 3: write_lcd1602(0x80+0x40+4,0);                  
     
615.                                                 break;
     
616.                                 case 4:        write_lcd1602(0x80+0x40+6,0);                  
     
617.                                                 break;
     
618.                                 case 5:        write_lcd1602(0x80+0x40+8,0);                 //
     
619.                                                 break;               
     
620.                                 case 6:        write_lcd1602(0x80+0x40+10,0);                 //
     
621.                                     break;
     
622.                                 case 7:        write_lcd1602(0x80+0x40+12,0);                 //
     
623.                                     break;
     
624.                                 case 8:        write_lcd1602(0x80+0x40+14,0);                 //
     
625.                                     break;
     
626.                                 case 9:        R_normal();
     
627.                                          break;
     
628.                        }
     
629.                       }
     
630.                 else
     
631.                 {
     
632.                         if(n==0&&m==0&&w==0&&m1>0)
     
633.                         {
     
634.                                 m1++;
     
635.                                 Alarm_Flag=0;                                                 //初始化闹铃标志位，闹铃不响
     
636.                           Alarm_Flag1=0;        
     
637.                                 switch(m1)
     
638.                         {        case 2: write_lcd1602(0x80+0x40+9,0);                   //开始设定闹铃，秒位闪烁可调
     
639.                                                     write_lcd1602(0x0f,0);
     
640.                                                 break;
     
641.                                 case 3: write_lcd1602(0x80+0x40+6,0);                   //分位闪烁可调
     
642.                                                 break;
     
643.                                 case 4:        write_lcd1602(0x80+0x40+3,0);                   //时位闪烁可调
     
644.                                                 break;
     
645.                                 case 5:        on_off_lcd(each);                            //
     
646.                                     break;
     
647.                                 case 6:
     
648.                                        nz_flag=1;                                                                        //开启闹钟检测
     
649.                      R_normal();
     
650.                                         break;
     
651.                                   }
     
652.                                         }
     
653.                      }
     
654.                   }
     
655.                 }
     
656.          }
     
657. }
     
658.            if(Alarm_Flag==0&&Alarm_Flag1==0&&setzx==0)
     
659.   {        if(key4==0)                                                                 //闹铃功能键
     
660.           {
     
661.                 delay(9);
     
662.                 if(key4==0)
     
663.                 {
     
664.                         di();
     
665.                         while(!key4);
     
666.                         if(Aset_Flag==0)        //不是调时钟状态就可以进入调闹钟
     
667.    {               
     
668.                  miao_ss=0;
     
669.                  if(m1==0)
     
670.                  {
     
671.                  if(w==0)
     
672.                  {
     
673.                         m++;
     
674.                         if(m>1)
     
675.                         {m=9;}
     
676.                         Display_Flag=1;                                                 //屏蔽调时功能键，进入调闹铃功能
     
677.                         switch(m)
     
678.                         {
     
679.                                 case 1:        n=0;
     
680.                                                 ReadRTC_Flag=0;                                            //开显示        
     
681.                                                 write_lcd1602(0x0c,0);                        //停止闪烁
     
682.                                                 Write_Ds1302(0x8e,0x00);
     
683.                                                 Write_Ds1302(0x80,((miao/10)*16+miao%10));
     
684.                                                 Write_Ds1302(0x8e,0x80);
     
685.                                                 write_lcd1602(0x80,0);                  //首行写入Set Alarm!
     
686.                                     write_lcd1602('w',1);
     
687.                                     write_lcd1602(':',1);
     
688. //                                    write_lcd1602(' ',1);
     
689.                                                 for(i=3;i<12;i++)
     
690.                                                 {
     
691.                                                         write_lcd1602(tab3[i],1);
     
692.                                                 }
     
693.                                                 write_lcd1602(setzx_f/10+'0',1);
     
694.                                                 write_lcd1602(setzx_f%10+'0',1);
     
695.                                                 write_lcd1602(0xde,1);
     
696.                                                 write_lcd1602(setzx_time/10+'0',1);
     
697.                                                 write_lcd1602(setzx_time%10+'0',1);
     
698.                                                 write_lcd1602(0x80+0x40,0);          //第二行写入设定的时间
     
699.                                                 write_lcd1602('*',1);
     
700.                                                 for(i=0;i<7;i++)
     
701.                                                 {
     
702.                                                         write_lcd1602(tab2[i],1);        
     
703.                                                 }
     
704.                                                 write_lcd1602(0x80+0x40+8,0);
     
705.                                                 write_lcd1602(set_miao/10+'0',1);
     
706.                                           write_lcd1602(set_miao%10+'0',1);
     
707.                                                 write_lcd1602(0x80+0x40+5,0);
     
708.                                                 write_lcd1602(set_fen/10+'0',1);
     
709.                                                 write_lcd1602(set_fen%10+'0',1);
     
710.                                                 write_lcd1602(0x80+0x40+2,0);
     
711.                                                 write_lcd1602(set_shi/10+'0',1);
     
712.                                                 write_lcd1602(set_shi%10+'0',1);
     
713.                                                 write_lcd1602(0x80+0x40+11,0);
     
714.                                                 if(yuyin_flag==1)
     
715.                                                 {write_lcd1602('V',1);}
     
716.                                                 else
     
717.                                                 {write_lcd1602('_',1);}
     
718.                                                 write_lcd1602(' ',1);
     
719.                                                 write_lcd1602(set_time/10+'0',1);
     
720.                                                 write_lcd1602(set_time%10+'0',1);
     
721.                                                 write_lcd1602('m',1);
     
722.                                                 break;
     
723.                                 case 9:
     
724.                                            m=0;                                                                   //关闭更更改闹铃时间
     
725.                                w=1;                  //
     
726.                                     write_lcd1602(0x0c,0); //停止闪烁
     
727.                                     write_lcd1602(0x80,0);                  //首行写入星期表
     
728.                                                 for(i=0;i<16;i++)
     
729.                                                 {
     
730.                                                         write_lcd1602(tab4[i],1);
     
731.                                                 }
     
732.                                                 write_lcd1602(0x80+0x40,0);
     
733.                                                 write_lcd1602('*',1);
     
734.                                                 write_lcd1602(':',1);
     
735.                                                 write_lcd1602(nz_week[0]+'0',1);
     
736.                                                 write_lcd1602(' ',1);
     
737.                                                 write_lcd1602(nz_week[1]+'0',1);
     
738.                                                 write_lcd1602(' ',1);
     
739.                                                 write_lcd1602(nz_week[2]+'0',1);
     
740.                                                 write_lcd1602(' ',1);
     
741.                                                 write_lcd1602(nz_week[3]+'0',1);
     
742.                                                 write_lcd1602(' ',1);
     
743.                                                 write_lcd1602(nz_week[4]+'0',1);
     
744.                                                 write_lcd1602(' ',1);
     
745.                                                 write_lcd1602(nz_week[5]+'0',1);
     
746.                                                 write_lcd1602(' ',1);
     
747.                                                 write_lcd1602(nz_week[6]+'0',1);
     
748.                                                 write_lcd1602(' ',1);
     
749.                                         break;
     
750.                         }
     
751.                 }
     
752.                  else
     
753.                  {
     
754.                         w=0;
     
755.                         m1=1;
     
756.                          write_lcd1602(0x0c,0);     //停止闪烁
     
757.              write_lcd1602(0x80,0);                  //首行写入Set Alarm!
     
758.                                                 for(i=0;i<11;i++)
     
759.                                                 {
     
760.                                                         write_lcd1602(tab3[i],1);
     
761.                                                 }
     
762.                                                 write_lcd1602('E',1);
     
763.                                                 write_lcd1602('.',1);
     
764.                                                 write_lcd1602('d',1);
     
765.                                                 write_lcd1602('a',1);
     
766.                                                 write_lcd1602('y',1);
     
767.                                                 write_lcd1602(0x80+0x40,0);          //第二行写入设定的时间
     
768.                                                 write_lcd1602(' ',1);
     
769.                                                 for(i=0;i<7;i++)
     
770.                                                 {
     
771.                                                         write_lcd1602(tab2[i],1);        
     
772.                                                 }
     
773.                                                 write_lcd1602(0x80+0x40+8,0);
     
774.                                                 write_lcd1602(nz_miao/10+'0',1);
     
775.                                           write_lcd1602(nz_miao%10+'0',1);
     
776.                                                 on_off_lcd(each);
     
777.                                                 write_lcd1602(0x80+0x40+5,0);
     
778.                                                 write_lcd1602(nz_fen/10+'0',1);
     
779.                                                 write_lcd1602(nz_fen%10+'0',1);
     
780.                                                 write_lcd1602(0x80+0x40+2,0);
     
781.                                                 write_lcd1602(nz_shi/10+'0',1);
     
782.                                                 write_lcd1602(nz_shi%10+'0',1);
     
783.                                                 a_lcd();
     
784.                  }
     
785.          }
     
786.                  else
     
787.                  {
     
788.                   R_normal();
     
789.                                         //        display();                                                           //返回时间显示*/
     
790.                         
     
791.                  }
     
792.                 }
     
793.          else         
     
794.          
     
795.            R_normal();
     
796.          
     
797.          }
     
798.         }
     
799. }
     
800.         if(n!=0||m>1||m1>1||w>1)                                                                                                                //功能加键
     
801.         {
     
802.                 if(key2==0)
     
803.                 {
     
804.                         delay(9);
     
805.                         if(key2==0)
     
806.                         {                                       
     
807.                                 di();
     
808.                                 while(!key2);
     
809.                                 miao_ss=0;
     
810.                                 if(Display_Flag==0)
     
811.                                 {
     
812.                                         switch(n)
     
813.                                         {
     
814.                                                 case 1:zd_baoshi=~zd_baoshi;
     
815.                                                        Write24c02(0x09,zd_baoshi);
     
816.                                                              on_off_lcd(zd_baoshi);
     
817.                                                       break;
     
818.                                                 case 2: miao++;
     
819.                                                                 if(miao==60)
     
820.                                                                 miao=0;
     
821.                                                                 write_lcd1602(0x80+0x40+8,0);           //使LCD1602在秒位上显示“加”设好的秒数
     
822.                                                                 write_lcd1602((miao/10)+'0',1);         //十进制转换成LCD1602能显示的字符，显示出来
     
823.                                                                 write_lcd1602((miao%10)+'0',1);
     
824.                                                                 T=(miao/10)*16+(miao%10);                     //十进制转换成DS1302能写的BCD码
     
825.                                                                 Write_Ds1302(0x8e,0x00);                     //允许写，禁止写保护
     
826.                                                                 Write_Ds1302(0x80,T);                              //写入DS1302
     
827.                                                                 Write_Ds1302(0x8e,0x80);                    //打开写保护
     
828.                                                                 //Read_RTC();                                                                                                                                
     
829.                                                                 write_lcd1602(0x80+0x40+9,0);     //写完数据后光标自动右移，所以要归位                                                                                                               
     
830.                                                                 break;
     
831.                                                 case 3: fen++;
     
832.                                                                 if(fen==60)
     
833.                                                                 fen=0;
     
834.                                                                 write_lcd1602(0x80+0x40+5,0);
     
835.                                                                 write_lcd1602((fen/10)+'0',1);
     
836.                                                                 write_lcd1602((fen%10)+'0',1);
     
837.                                                                 T=(fen/10)*16+(fen%10);
     
838.                                                                 Write_Ds1302(0x8e,0x00);
     
839.                                                                 Write_Ds1302(0x82,T);
     
840.                                                                 Write_Ds1302(0x8e,0x80);                                                               
     
841.                                                                 write_lcd1602(0x80+0x40+6,0);
     
842.                                                                 break;
     
843.                                                 case 4: shi++;
     
844.                                                                 if(shi==24)
     
845.                                                                 shi=0;
     
846.                                                                 write_lcd1602(0x80+0x40+2,0);
     
847.                                                                 write_lcd1602((shi/10)+'0',1);
     
848.                                                                 write_lcd1602((shi%10)+'0',1);
     
849.                                                                 T=(shi/10)*16+(shi%10);
     
850.                                                                 Write_Ds1302(0x8e,0x00);
     
851.                                                                 Write_Ds1302(0x84,T);
     
852.                                                                 Write_Ds1302(0x8e,0x80);                                                               
     
853.                                                                 write_lcd1602(0x80+0x40+3,0);
     
854.                                                                 break;
     
855.                                                 case 5: ri++;
     
856.                                                                 if(ri==32)
     
857.                                                                 ri=1;
     
858.                                                                 write_lcd1602(0x80+9,0);
     
859.                                                                 write_lcd1602((ri/10)+'0',1);
     
860.                                                                 write_lcd1602((ri%10)+'0',1);
     
861.                                                                 T=(ri/10)*16+(ri%10);                        
     
862.                                                                 Write_Ds1302(0x8e,0x00);        
     
863.                                                                 Write_Ds1302(0x86,T);
     
864.                                                                 Write_Ds1302(0x8e,0x80);
     
865.                                                                 write_lcd1602(0x80+10,0);
     
866.                                                                 break;
     
867.                                                 case 6: yue++;
     
868.                                                                 if(yue==13)
     
869.                                                                 yue=1;
     
870.                                                                 write_lcd1602(0x80+6,0);
     
871.                                                                 write_lcd1602((yue/10)+'0',1);
     
872.                                                                 write_lcd1602((yue%10)+'0',1);
     
873.                                                                 T=(yue/10)*16+(yue%10);
     
874.                                                                 Write_Ds1302(0x8e,0x00);
     
875.                                                                 Write_Ds1302(0x88,T);
     
876.                                                                 Write_Ds1302(0x8e,0x80);
     
877.                                                                 write_lcd1602(0x80+7,0);
     
878.                                                                 break;
     
879.                                                 case 7: nian++;
     
880.                                                                 if(nian==100)
     
881.                                                                 nian=0;
     
882.                                                                 write_lcd1602(0x80+3,0);
     
883.                                                                 write_lcd1602((nian/10)+'0',1);
     
884.                                                                 write_lcd1602((nian%10)+'0',1);
     
885.                                                                 T=(nian/10)*16+(nian%10);
     
886.                                                                 Write_Ds1302(0x8e,0x00);
     
887.                                                                 Write_Ds1302(0x8c,T);
     
888.                                                                 Write_Ds1302(0x8e,0x80);
     
889.                                                                 write_lcd1602(0x80+4,0);
     
890.                                                                 break;
     
891.                                                 case 8: week++;
     
892.                                                                 if(week==8)
     
893.                                                                 week=1;
     
894.                                                                 write_week(week);
     
895.                                                                 T=(week/10)*16+(week%10);
     
896.                                                                 Write_Ds1302(0x8e,0x00);
     
897.                                                                 Write_Ds1302(0x8a,T);
     
898.                                                                 Write_Ds1302(0x8e,0x80);
     
899.                                                                 break;
     
900.                                         }
     
901.                                 }
     
902.                                 else  
     
903.                                         if(w==0&&m1==0&&m>1)
     
904.                                 {               
     
905.                                         switch(m)
     
906.                                                 {
     
907.                                                          case 2: set_miao++;                     //闹钟秒加1
     
908.                                                                         if(set_miao==60)
     
909.                                                                         set_miao=0;
     
910.                                                                         write_lcd1602(0x80+0x40+8,0);
     
911.                                                                         write_lcd1602(set_miao/10+'0',1);
     
912.                                                                         write_lcd1602(set_miao%10+'0',1);
     
913.                                                                         write_lcd1602(0x80+0x40+9,0);
     
914.                                                                         Write24c02(0x03,set_miao);
     
915.                                                                         break;
     
916.                                                     case 3: set_fen++;                   //闹钟分加1
     
917.                                                                         if(set_fen==60)
     
918.                                                                         set_fen=0;
     
919.                                                                         write_lcd1602(0x80+0x40+5,0);
     
920.                                                                         write_lcd1602(set_fen/10+'0',1);
     
921.                                                                         write_lcd1602(set_fen%10+'0',1);
     
922.                                                                         write_lcd1602(0x80+0x40+6,0);
     
923.                                                                         Write24c02(0x02,set_fen);
     
924.                                                                         break;
     
925.                                                     case 4: set_shi++;                  //闹钟时加1
     
926.                                                                         if(set_shi==24)
     
927.                                                                         set_shi=0;
     
928.                                                                         write_lcd1602(0x80+0x40+2,0);
     
929.                                                                         write_lcd1602(set_shi/10+'0',1);
     
930.                                                                         write_lcd1602(set_shi%10+'0',1);
     
931.                                                                         write_lcd1602(0x80+0x40+3,0);
     
932.                                                                         Write24c02(0x01,set_shi);
     
933.                                                                         break;
     
934.                                                         case 5: set_time++;                   //闹钟响铃时长
     
935.                                                                         if(set_time==31)
     
936.                                                                         set_time=1;
     
937.                                                                         write_lcd1602(0x80+0x40+13,0);
     
938.                                                                         write_lcd1602(set_time/10+'0',1);
     
939.                                                                         write_lcd1602(set_time%10+'0',1);
     
940.                                                                         write_lcd1602(0x80+0x40+14,0);
     
941.                                                                         Write24c02(0x05,set_time);
     
942.                                                                         break;               
     
943.                                                         case 6: setzx_time++;                 //闹钟再响间隔
     
944.                                                                         if(setzx_time==31)
     
945.                                                                         setzx_time=1;
     
946.                                                                         write_lcd1602(0x80+14,0);
     
947.                                                                         write_lcd1602(setzx_time/10+'0',1);
     
948.                                                                         write_lcd1602(setzx_time%10+'0',1);
     
949.                                                                         write_lcd1602(0x80+15,0);
     
950.                                                                         Write24c02(0x07,setzx_time);
     
951.                                                                         break;               
     
952.                                                         case 7: setzx_f++;                    //闹钟响铃次数
     
953.                                                                         if(setzx_f==11)
     
954.                                                                         setzx_f=1;
     
955.                                                                         write_lcd1602(0x80+11,0);
     
956.                                                                         write_lcd1602(setzx_f/10+'0',1);
     
957.                                                                         write_lcd1602(setzx_f%10+'0',1);
     
958.                                                                         write_lcd1602(0x80+12,0);
     
959.                                                                         Write24c02(0x08,setzx_f);
     
960.                                                                         break;
     
961.                                                         case 8: yuyin_flag=~yuyin_flag;
     
962.                                                                         write_lcd1602(0x80+0x40+11,0);
     
963.                                                                         if(yuyin_flag==1)
     
964.                                                         {write_lcd1602('V',1);}
     
965.                                                     else
     
966.                                                         {write_lcd1602('_',1);}
     
967.                                                                         write_lcd1602(0x80+0x40+11,0);
     
968.                                                                         Write24c02(0x0a,yuyin_flag);
     
969.                                                                         break;
     
970.                                                 }
     
971.                                         }
     
972.                                 else
     
973.                                 if(m==0&&m1==0&&w>1)
     
974.                                 {
     
975.                                         switch(w)
     
976.                                         {
     
977.                                                 case 2:                               //星期日闹钟开关，1为开
     
978.                                                 nz_week[0]=1;
     
979.                                                 write_lcd1602(0x80+0x40+2,0);
     
980.                                                 write_lcd1602(nz_week[0]+'0',1);
     
981.                                                 write_lcd1602(0x80+0x40+2,0);
     
982.                                                 Write24c02(0x10,nz_week[0]);
     
983.                                                         break;
     
984.                                                 case 3:                               //星期一闹钟开关
     
985.                                                 nz_week[1]=1;
     
986.                                                 write_lcd1602(0x80+0x40+4,0);
     
987.                                                 write_lcd1602(nz_week[1]+'0',1);
     
988.                                                 write_lcd1602(0x80+0x40+4,0);
     
989.                                                 Write24c02(0x11,nz_week[1]);        
     
990.                                                         break;
     
991.                                                 case 4:                               //星期二闹钟开关
     
992.                                                 nz_week[2]=1;
     
993.                                                 write_lcd1602(0x80+0x40+6,0);
     
994.                                                 write_lcd1602(nz_week[2]+'0',1);
     
995.                                                 write_lcd1602(0x80+0x40+6,0);
     
996.                                                 Write24c02(0x12,nz_week[2]);        
     
997.                                                         break;
     
998.                                                 case 5:                               //星期三闹钟开关
     
999.                                                 nz_week[3]=1;
     
1000.                                                 write_lcd1602(0x80+0x40+8,0);
      
1001.                                                 write_lcd1602(nz_week[3]+'0',1);
      
1002.                                                 write_lcd1602(0x80+0x40+8,0);
      
1003.                                                 Write24c02(0x13,nz_week[3]);        
      
1004.                                                         break;
      
1005.                                                 case 6:                               //星期四闹钟开关
      
1006.                                                 nz_week[4]=1;
      
1007.                                                 write_lcd1602(0x80+0x40+10,0);
      
1008.                                                 write_lcd1602(nz_week[4]+'0',1);
      
1009.                                                 write_lcd1602(0x80+0x40+10,0);
      
1010.                                                 Write24c02(0x14,nz_week[4]);        
      
1011.                                                         break;
      
1012.                                                 case 7:                               //星期五闹钟开关
      
1013.                                                 nz_week[5]=1;
      
1014.                                                 write_lcd1602(0x80+0x40+12,0);
      
1015.                                                 write_lcd1602(nz_week[5]+'0',1);
      
1016.                                                 write_lcd1602(0x80+0x40+12,0);
      
1017.                                                 Write24c02(0x15,nz_week[5]);        
      
1018.                                                         break;
      
1019.                                                 case 8:                               //星期六闹钟开关
      
1020.                                                 
      
1021. 
      
1022. …………限于本文篇幅 余下代码请从51黑下载附件…………
      

复制代码

程序：
电子时钟最终双闹版.rar (20.54 KB, 下载次数: 166)

2017-4-9 17:42 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: lxa0    时间: 2017-4-9 21:59
这个c语言的代码
比汇编代码还复杂啊~~~~~~~~~

---

作者: xuwei517    时间: 2017-4-17 17:13
谢谢楼主的资料 正想学51c语言 很好很有用

---

作者: xuwei517    时间: 2017-5-6 21:55
要是能有个说明就好了 我这调了半天也没太弄明白闹钟设置里的东东 是个很不错的程序

---

作者: xuwei517    时间: 2017-5-6 21:56
而且到了闹钟的时间就死机了呢 卡住不动了 是哪里设置的不对呢

---

作者: liyz    时间: 2017-5-6 23:06
闹钟在语音报时的时候显示屏会停下不走动，语音报完就正常走时了

---

作者: liyz    时间: 2017-5-7 00:04

xuwei517 发表于 2017-5-6 21:55
要是能有个说明就好了 我这调了半天也没太弄明白闹钟设置里的东东 是个很不错的程序

发几张图片说明看看吧

---

作者: liyz    时间: 2018-4-14 09:33

更新一下：做了一点小优化，解决语音报时走时停顿问题 电子时钟最终双闹版(2017.11.30).rar (113.58 KB, 下载次数: 97)

2018-4-14 09:32 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: opop1988    时间: 2018-4-15 12:15
灰常不错，谢谢楼主

---

作者: bit123    时间: 2018-4-18 21:05
楼主，请问你这个设备能否买一个给我，谢谢！急用，需要给女朋友送一个。

---

作者: 七夏。    时间: 2018-5-10 18:20
羡慕大神

---

作者: 15622633856    时间: 2018-5-10 22:00
正想学51c语言，羡慕大神

---

作者: 行云流水    时间: 2018-5-10 22:43
辛苦了，谢谢楼主的资料，

---

作者: mslong    时间: 2018-8-10 03:11
程序试好，可以用，新手可以放心下载

---

作者: 怒天狂龙hbt    时间: 2018-8-10 18:18
谢谢楼主的资料 正想学51c语言 很好很有用

---

作者: haorizi    时间: 2018-8-11 00:44
很好，我也想做一个

---

作者: xsj1877578806    时间: 2018-9-2 19:19
没有接AT24C02就不能显示吗？

---

作者: wulingqing    时间: 2018-9-9 08:05
谢谢楼主的资料  很好很有用

---

作者: SHLMango    时间: 2019-3-28 18:48
楼主，有没有仿真图

---

作者: tigerzq    时间: 2019-3-29 10:45
有历史的牛人呀！

---

作者: 2723678426    时间: 2019-4-4 13:06
正想学51c语言,黑币不够无法下载

---

作者: 最可爱的人    时间: 2019-4-5 10:39
不会设置闹钟

---

作者: yiyuan3085377    时间: 2020-11-23 20:49
为什么我的仿真里led1602不显示

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1