欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 單片機0.8寸數碼管時鐘完整資料 程序+Gerber PCB文件 [打印本頁]

---

作者: lids    時間: 2023-12-7 12:41
標題: 單片機0.8寸數碼管時鐘完整資料 程序+Gerber PCB文件
/*
項目名稱：0.8寸4位共陽數碼管時鐘
1.5個PNP三極管接在共陽極驅動數碼管，這個數碼管小數點都有，冒號是單獨兩個LED
2.設置方法：按k1鍵設置狀態（小時位數碼管閃爍），按K2鍵++，按K3鍵--，長按連加連減；
按K1鍵第二次，分鐘位數碼管閃爍，按K2鍵++，按K3鍵--，長按連加連減；
按K1鍵第三次，退出設置狀態，回到正常走時界面。
3. P2.0-P2.4位驅動口，P1口為段驅動口；

4. 單片機=STC8H1K16（LQFP32封裝） @11.0592MHz   時鐘芯片=DS3231MZ(SOP-8封裝)
2023/12/7 測試通過

測試中的問題：開始數碼管有鬼影，以為程序有問題（這個程序以前驅動0.56寸數碼管是沒問題的），
單片機內部4.1K上拉打開不行，位驅動口設置成推挽都不行；單獨驅動一個LED燈，LED只有亮暗變化，
不能完全關斷；后來在PNP三極管基極加5.1K上拉電阻，三極管才能完全關斷；上拉電阻加在單片機的IO端
都不行；
以前同型號的單片機不加這個上拉電阻是可以的；

單片機都是在某一個寶買的（兩次不是在一家買的），這次買的有這個問題，以前的沒有。
*/
程序只寫了時鐘的，溫度，蜂鳴器沒寫；
附件里面有嘉立創EDA軟件畫的板子的gerber文件，可以直接在嘉立創免費打板，有興趣的可以制作看看有沒有我制作中出現的問題，制作時，Q1不用，R5用跳線短接。

制作出來的實物圖如下：


電路原理圖如下：

附件是完整資料

1. /*
   
2. 項目名稱：0.8寸4位共陽數碼管時鐘
   
3. 1.5個PNP三極管接在共陽極驅動數碼管，這個數碼管小數點都有，冒號是單獨兩個LED
   
4. 2.設置方法：按k1鍵設置狀態（小時位數碼管閃爍），按K2鍵++，按K3鍵--，長按連加連減；
   
5. 按K1鍵第二次，分鐘位數碼管閃爍，按K2鍵++，按K3鍵--，長按連加連減；
   
6. 按K1鍵第三次，退出設置狀態，回到正常走時界面。
   
7. 3. P2.0-P2.4位驅動口，P1口為段驅動口；
   
8. 
   
9. 4. 單片機=STC8H1K16（LQFP32封裝） @11.0592MHz   時鐘芯片=DS3231MZ(SOP-8封裝)
   
10. 2023/12/7 測試通過
    
11. 
    
12. 測試中的問題：開始數碼管有鬼影，以為程序有問題（這個程序以前驅動0.56寸數碼管是沒問題的），
    
13. 單片機內部4.1K上拉打開不行，位驅動口設置成推挽都不行；單獨驅動一個LED燈，LED只有亮暗變化，
    
14. 不能完全關斷；后來在PNP三極管基極加5.1K上拉電阻，三極管才能完全關斷；上拉電阻加在單片機的IO端
    
15. 都不行；
    
16. 以前同型號的單片機不加這個上拉電阻是可以的；
    
17. 
    
18. 單片機都是在某一個寶買的（兩次不是在一家買的），這次買的有這個問題，以前的沒有。
    
19. */
    
20. #include <STC8H.H>
    
21. #include <intrins.h>
    
22. 
    
23. #define uchar unsigned char
    
24. #define uint unsigned int
    
25. 
    
26. 
    
27. //typedef     unsigned char   u8;
    
28. //typedef     unsigned int    u16;
    
29. //typedef     unsigned long   u32;
    
30. 
    
31. sbit k1=P0^0;//        按鍵1 設置 +
    
32. sbit k2=P2^7;//        按鍵2  -
    
33. sbit k3=P3^7;//        
    
34. sbit k4=P2^5;
    
35. sbit out = P3^2;          //輸出端口
    
36. sbit w1 = P2^0;          //設置位驅動口
    
37. sbit w2 = P2^1;
    
38. sbit w3 = P2^2;
    
39. sbit w4 = P2^3;
    
40. 
    
41. sbit w5 = P2^4;        //冒號控制
    
42. 
    
43. sbit BZ = P0^3;//蜂鳴器控制口
    
44. uint count,cont1,cont2,cont3;
    
45. uint fen,fen_temp;
    
46. uchar fen_L,fen_M,miao,num,num2;
    
47. uchar Ledcount;
    
48. uchar num;
    
49. uchar k1_lock,k2_lock,k3_lock;//按鍵鎖
    
50. uchar knum;
    
51. uint shan;//秒點閃爍 計時變量
    
52. 
    
53. uint k1_time_count;          //K1消抖計數
    
54. uint k2_time_count;          //K2消抖計數
    
55. uint k3_time_count;          //K2消抖計數
    
56. 
    
57. bit flag;        //計時啟動標志
    
58. bit flag1;        //按鍵消抖計數標志
    
59. bit flag2;        //按鍵消抖計數標志
    
60. bit save_flag;//數據保存標志
    
61. bit save_flag1;//數據保存標志
    
62. bit set_flag=0; //設置標志
    
63. bit fm_flag;//蜂鳴器
    
64. 
    
65. bit flag3;
    
66. 
    
67. uchar hour,minute,second,year,month,day,date,week;
    
68. uint TH3231;
    
69. bit        ack;                //應答標志位
    
70. 
    
71. uchar code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff,0x46,0xbf,0x8e};//共陽段碼 （0--9、黑屏,C,-,F）
    
72. uchar LedBuff[]={0xff,0xff,0xff,0xff};
    
73. 
    
74. // ------------------------------------------------------------
    
75. // IO口模擬I2C通信
    
76. 
    
77. // ------------------------------------------------------------
    
78. sbit SCL=P3^5; //串行時鐘
    
79. sbit SDA=P3^4; //串行數據
    
80. 
    
81. /********************************************************************************************************
    
82. **         DS3231常數定義
    
83. ********************************************************************************************************/
    
84. #define DS3231_WriteAddress 0xD0    //器件寫地址
    
85. #define DS3231_ReadAddress  0xD1    //器件讀地址
    
86. #define DS3231_SECOND       0x00    //秒
    
87. #define DS3231_MINUTE       0x01    //分
    
88. #define DS3231_HOUR         0x02    //時
    
89. #define DS3231_WEEK         0x03    //星期
    
90. #define DS3231_DAY          0x04    //日
    
91. #define DS3231_MONTH        0x05    //月
    
92. #define DS3231_YEAR         0x06    //年
    
93. 
    
94. #define DS3231_TEMPERATUREH 0x11    //溫度寄存器高字節(8位)        整數部分
    
95. #define DS3231_TEMPERATUREL 0x12    //溫度寄存器低字節(低2位) 小數部分
    
96. 
    
97. 
    
98. 
    
99. #define NACK    1
    
100. #define ACK     0
     
101. /////////////////
     
102. 
     
103. void        Delay5US()           //@12.000MHz           延時5us
     
104. {
     
105.    _nop_(); _nop_();        _nop_();_nop_();         _nop_();_nop_();//STC Y6指令 1T單片機用6個nop，12T用1個nop
     
106. }
     
107. 
     
108. void delay(uint x)
     
109. {
     
110.         uint y,z;
     
111.         for(y=0; y<x; y--)
     
112.                 for(z=0; z<1200; z--);
     
113. 
     
114. }
     
115. 
     
116. 
     
117. /**********************************************
     
118. //IIC Start
     
119. **********************************************/
     
120. void IIC_Start()
     
121. {
     
122.    SCL = 1;               
     
123.    SDA = 1;
     
124.    SDA = 0;
     
125.    SCL = 0;
     
126. }
     
127. 
     
128. /**********************************************
     
129. //IIC Stop
     
130. **********************************************/
     
131. void IIC_Stop()
     
132. {
     
133.    SCL = 0;
     
134.    SDA = 0;
     
135.    SCL = 1;
     
136.    SDA = 1;
     
137. }
     
138. 
     
139. /********************************************************************************************************
     
140. **         3231
     
141. ********************************************************************************************************/
     
142. 
     
143. 
     
144. uchar        BCD2HEX(uchar val)//轉10進制
     
145. {
     
146.         return        ((val>>4)*10)+(val&0x0f);
     
147. }
     
148. 
     
149. uchar        HEX2BCD(uchar val) //轉16進制
     
150. {
     
151.         return        (((val%100)/10)<<4)|(val%10);
     
152. }
     
153. 
     
154. 
     
155. void SendByte(uchar c)
     
156. {
     
157.     uchar BitCnt;
     
158.    
     
159.     for(BitCnt=0;BitCnt<8;BitCnt++)         //要傳送的數據長度為8位
     
160.     {
     
161.         if((c<<BitCnt)&0x80)
     
162.             SDA=1;                          //判斷發送位
     
163.         else
     
164.             SDA=0;     
     
165.         SCL=1;                            //置時鐘線為高，通知被控器開始接收數據位
     
166.         Delay5US();                       //保證時鐘高電平周期大于4μs   
     
167.         SCL=0;
     
168.     }
     
169.     SDA=1;                                  //8位發送完后釋放數據線，準備接收應答位
     
170.     SCL=1;
     
171.     Delay5US();
     
172.     if(SDA==1)
     
173.         ack=0;   
     
174.     else
     
175.         ack=1;                              //判斷是否接收到應答信號
     
176.     SCL=0;
     
177.     Delay5US();
     
178. }           
     
179. 
     
180. uchar RcvByte()
     
181. {
     
182.    uchar retc;
     
183.    uchar BitCnt;
     
184. 
     
185.    retc=0;
     
186.    SDA=1;                           //置數據線為輸入方式
     
187.    for(BitCnt=0;BitCnt<8;BitCnt++)
     
188.    {
     
189.         SCL=0;                      //置時鐘線為低，準備接收數據位      
     
190.         Delay5US();                 //時鐘低電平周期大于4.7μs                       
     
191.         SCL=1;                      //置時鐘線為高使數據線上數據有效
     
192.         Delay5US();
     
193.         retc=retc<<1;
     
194.         if(SDA==1)
     
195.             retc=retc+1;            //讀數據位,接收的數據位放入retc中
     
196.         Delay5US();
     
197.    }
     
198.    SCL=0;
     
199.    return(retc);
     
200. }                           
     
201. 
     
202. void Ack_I2C(bit a)
     
203. {
     
204.         SDA        =        a;  
     
205.     SCL=1;                     
     
206.     Delay5US();             //時鐘低電平周期大于4us   
     
207.     SCL=0;                  //清時鐘線，鉗住I2C總線以便繼續接收
     
208.     Delay5US();   
     
209. }                                            
     
210. 
     
211. uchar write_byte(uchar addr, uchar write_data)
     
212. {
     
213.     IIC_Start();
     
214.     SendByte(DS3231_WriteAddress);
     
215.     if (ack == 0)
     
216.         return 0;
     
217.    
     
218.     SendByte(addr);   
     
219.     if (ack == 0)
     
220.         return 0;
     
221.    
     
222.     SendByte(write_data);
     
223.     if (ack == 0)
     
224.         return 0;
     
225.    
     
226.     IIC_Stop();
     
227.     Delay5US();      
     
228.     Delay5US();      
     
229.     return 1;
     
230. }                                          
     
231. 
     
232. uchar read_current()
     
233. {
     
234.     uchar read_data;
     
235.     IIC_Start();
     
236.     SendByte(DS3231_ReadAddress);
     
237.     if(ack==0)
     
238.         return(0);              
     
239.     read_data = RcvByte();
     
240.     Ack_I2C(1);
     
241.     IIC_Stop();
     
242.     return read_data;
     
243. }                                                
     
244. 
     
245. uchar read_random(uchar random_addr)
     
246. {
     
247.     uchar Tmp;
     
248.         IIC_Start();
     
249.     SendByte(DS3231_WriteAddress);
     
250.     if(ack==0)
     
251.         return(0);            
     
252.     SendByte(random_addr);
     
253.     if(ack==0)
     
254.         return(0);
     
255.         Tmp=read_current();
     
256.         if(random_addr==DS3231_HOUR)
     
257.                 Tmp&=0x3f;
     
258.                                             
     
259.     return(BCD2HEX(Tmp));//都轉10進制輸出
     
260. }
     
261. 
     
262. /***********************/
     
263. uchar read_random1(uchar random_addr)  //這個是讀溫度函數
     
264. {
     
265.     uchar Tmp;
     
266. //        write_byte(0x0e,0x20);//0x0e寄存器的CONV位置1開啟溫度轉換，要這句，溫度實時刷新，這句不要，溫度要64s才刷新1次
     
267.                                                   //數碼管顯示不能要這句，否則溫度值小數部分亂跳
     
268.         IIC_Start();
     
269.     SendByte(DS3231_WriteAddress);
     
270.     if(ack==0)
     
271.         return(0);            
     
272.     SendByte(random_addr);
     
273.     if(ack==0)
     
274.         return(0);
     
275.         Tmp=read_current();
     
276.         return Tmp;
     
277. }                                 
     
278. 
     
279. void ModifyTime(uchar address,uchar num)
     
280. {
     
281.     uchar temp=0;
     
282.            if(address>6 && address <0) return;
     
283.     temp=HEX2BCD(num);
     
284.         write_byte(address,temp);
     
285. }
     
286. 
     
287. 
     
288. 
     
289. ////////////////
     
290. 
     
291. void IapIdle()
     
292. {
     
293.     IAP_CONTR = 0;                              //關閉IAP功能
     
294.     IAP_CMD = 0;                                //清除命令寄存器
     
295.     IAP_TRIG = 0;                               //清除觸發寄存器
     
296.     IAP_ADDRH = 0x80;                           //將地址設置到非IAP區域
     
297.     IAP_ADDRL = 0;
     
298. }
     
299. 
     
300. char IapRead(int addr)
     
301. {
     
302.     char dat;
     
303. 
     
304.     IAP_CONTR = 0x80;                           //使能IAP
     
305.     IAP_TPS = 12;                               //設置等待參數12MHz
     
306.     IAP_CMD = 1;                                //設置IAP讀命令
     
307.     IAP_ADDRL = addr;                           //設置IAP低地址
     
308.     IAP_ADDRH = addr >> 8;                      //設置IAP高地址
     
309.     IAP_TRIG = 0x5a;                            //寫觸發命令(0x5a)
     
310.     IAP_TRIG = 0xa5;                            //寫觸發命令(0xa5)
     
311.     _nop_();
     
312.     dat = IAP_DATA;                             //讀IAP數據
     
313.     IapIdle();                                  //關閉IAP功能
     
314. 
     
315.     return dat;
     
316. }
     
317. 
     
318. void IapProgram(int addr, char dat)
     
319. {
     
320.     IAP_CONTR = 0x80;                           //使能IAP
     
321.     IAP_TPS = 12;                               //設置等待參數12MHz
     
322.     IAP_CMD = 2;                                //設置IAP寫命令
     
323.     IAP_ADDRL = addr;                           //設置IAP低地址
     
324.     IAP_ADDRH = addr >> 8;                      //設置IAP高地址
     
325.     IAP_DATA = dat;                             //寫IAP數據
     
326.     IAP_TRIG = 0x5a;                            //寫觸發命令(0x5a)
     
327.     IAP_TRIG = 0xa5;                            //寫觸發命令(0xa5)
     
328.     _nop_();
     
329.     IapIdle();                                  //關閉IAP功能
     
330. }
     
331. 
     
332. void IapErase(int addr)
     
333. {
     
334.     IAP_CONTR = 0x80;                           //使能IAP
     
335.     IAP_TPS = 12;                               //設置等待參數12MHz
     
336.     IAP_CMD = 3;                                //設置IAP擦除命令
     
337.     IAP_ADDRL = addr;                           //設置IAP低地址
     
338.     IAP_ADDRH = addr >> 8;                      //設置IAP高地址
     
339.     IAP_TRIG = 0x5a;                            //寫觸發命令(0x5a)
     
340.     IAP_TRIG = 0xa5;                            //寫觸發命令(0xa5)
     
341.     _nop_();                                    //
     
342.     IapIdle();                                  //關閉IAP功能
     
343. }
     
344. ////////////////////
     
345. void Timer0Init(void)                //2毫秒@11.0592MHz
     
346. {
     
347.         AUXR |= 0x80;                //定時器時鐘1T模式
     
348.         TMOD &= 0xF0;                //設置定時器模式  16位自動重載
     
349.         TL0 = 0x9A;                //設置定時初始值
     
350.         TH0 = 0xA9;                //設置定時初始值
     
351.         TF0 = 0;                //清除TF0標志
     
352.         TR0 = 1;                //定時器0開始計時
     
353.         EA = 1;                        //開總中斷
     
354.         ET0 = 1;                //開T0中斷
     
355. }
     
356. 
     
357. 
     
358. //void Timer0Init(void)                //5毫秒@11.0592MHz
     
359. //{
     
360. //        AUXR |= 0x80;                //定時器時鐘1T模式
     
361. //        TMOD &= 0xF0;                //設置定時器模式
     
362. //        TL0 = 0x00;                //設置定時初始值
     
363. //        TH0 = 0x28;                //設置定時初始值
     
364. //        TF0 = 0;                //清除TF0標志
     
365. //        TR0 = 1;                //定時器0開始計時
     
366. //        EA = 1;                        //開總中斷
     
367. //        ET0 = 1;                //開T0中斷
     
368. //}
     
369. /////////////////////////////
     
370. void keyscan()
     
371. {
     
372.         uchar temp;
     
373.         hour = read_random(DS3231_HOUR);
     
374.         minute = read_random(DS3231_MINUTE) ;
     
375.         second = read_random(DS3231_SECOND);
     
376. 
     
377.         
     
378.                 if(k1)        //
     
379.                 {                                                //
     
380.                         k1_time_count=0;
     
381.                         k1_lock=0;
     
382.                         flag1 = 0;
     
383.                 }
     
384.                 else if((k1_lock==0))
     
385.                 {
     
386.                         flag1 = 1; //按鍵按下 消抖計時標志置1 開始消抖計時
     
387.                         if((k1_time_count==10))  //20微秒
     
388.                         {
     
389.                                 k1_time_count=0;
     
390.                                 k1_lock=1;
     
391.                                 knum++;
     
392.                                 if(knum==3)
     
393.                                 {
     
394.                                         knum=0;
     
395.                                         second=0;
     
396.                                         write_byte(DS3231_SECOND, second); //秒寫0
     
397.                                 }
     
398.                         }
     
399.                 }
     
400. 
     
401. /////////////////////////////
     
402.         if(knum==1)  //設置 狀態
     
403.         {
     
404.                 if(k2 ==1)                                   //++
     
405.                 {
     
406.                         k2_time_count=0;
     
407.                         k2_lock=0;
     
408.                         flag2 = 0;
     
409.                 }
     
410.                 else if(k2_lock==0)
     
411.                 {
     
412.                 //        flag = 0;
     
413.                         flag2 = 1;
     
414.                 //        save_flag = 1;
     
415.                         if(k2_time_count==10)                //短按
     
416.                         {
     
417.                                 k2_time_count=0;
     
418.                                 k2_lock=1;
     
419.                                 hour++;
     
420.                                 if(hour>23)
     
421.                                         hour=0;
     
422.                                 temp=HEX2BCD(hour);
     
423.                                 write_byte(DS3231_HOUR, temp);
     
424.                         }        
     
425.                 }
     
426.                 else if(k2_time_count==500)                 //長按
     
427.                 {
     
428.                    cont1=0; num=0;
     
429.                    k1_time_count=450;
     
430.                         hour++;
     
431.                         if(hour>23)
     
432.                                 hour=0;
     
433.                         temp=HEX2BCD(hour);        //10進制轉16進制
     
434.                         write_byte(DS3231_HOUR, temp);
     
435. 
     
436.                 }
     
437. //////////////////////////
     
438.                 if(k3 == 1)                                   //--
     
439.                 {
     
440.                         k3_time_count=0;
     
441.                         k3_lock=0;
     
442.                         flag3 = 0;
     
443.                 }
     
444.                 else if(k3_lock==0)
     
445.                 {
     
446.                
     
447.                         flag3 = 1;
     
448.                         save_flag1 = 1;
     
449.                         if(k3_time_count==10)                //短按
     
450.                         {
     
451.                                 cont1=0; num=0;
     
452.                                 k3_time_count=0;
     
453.                                 k3_lock=1;
     
454.                                 hour--;
     
455.                                 if(hour==255)
     
456.                                         hour=23;
     
457.                                 temp=HEX2BCD(hour);
     
458.                                 write_byte(DS3231_HOUR, temp);
     
459. 
     
460.                         }
     
461.                                 
     
462.                 }
     
463.                 else if(k3_time_count==500)                 //長按
     
464.                 {
     
465.                    cont1=0; num=0;  
     
466.                    k3_time_count=450;
     
467.                                 hour--;
     
468.                         if(hour==255)
     
469.                                 hour=23;
     
470.                         temp=HEX2BCD(hour);
     
471.                         write_byte(DS3231_HOUR, temp);
     
472. 
     
473.                 }
     
474.         }
     
475.   ////////////////////////////////
     
476.         if(knum==2)
     
477.         {
     
478.                 if(k2 ==1)                                   //++
     
479.                 {
     
480.                         k2_time_count=0;
     
481.                         k2_lock=0;
     
482.                         flag2 = 0;
     
483.                 }
     
484.                 else if(k2_lock==0)
     
485.                 {
     
486.                 //        flag = 0;
     
487.                         flag2 = 1;
     
488.                 //        save_flag = 1;
     
489.                         if(k2_time_count==10)                //短按
     
490.                         {
     
491.                                 k2_time_count=0;
     
492.                                 k2_lock=1;
     
493.                                 minute++;
     
494.                                 if(minute>59)
     
495.                                         minute=0;
     
496.                                 temp=HEX2BCD(minute);
     
497.                                 write_byte(DS3231_MINUTE, temp);
     
498.                         }        
     
499.                 }
     
500.                 else if(k2_time_count==500)                 //長按
     
501.                 {
     
502.                    cont1=0; num=0;
     
503.                    k1_time_count=450;
     
504.                         minute++;
     
505.                         if(minute>59)
     
506.                                 minute=0;
     
507.                         temp=HEX2BCD(minute);
     
508.                         write_byte(DS3231_MINUTE, temp);
     
509. 
     
510.                 }
     
511. //////////////////////////
     
512.                 if(k3 == 1)                                   //--
     
513.                 {
     
514.                         k3_time_count=0;
     
515.                         k3_lock=0;
     
516.                         flag3 = 0;
     
517.                 }
     
518.                 else if(k3_lock==0)
     
519.                 {
     
520.                
     
521.                         flag3 = 1;
     
522.                         save_flag1 = 1;
     
523.                         if(k3_time_count==10)                //短按
     
524.                         {
     
525.                                 cont1=0; num=0;
     
526.                                 k3_time_count=0;
     
527.                                 k3_lock=1;
     
528.                                 minute--;
     
529.                                 if(minute==255)
     
530.                                         minute=59;
     
531.                                 temp=HEX2BCD(minute);
     
532.                                 write_byte(DS3231_MINUTE, temp);
     
533.                         }
     
534.                                 
     
535.                 }
     
536.                 else if(k3_time_count==500)                 //長按
     
537.                 {
     
538.                    cont1=0; num=0;  
     
539.                    k3_time_count=450;
     
540.                                 minute--;
     
541.                                 if(minute==255)
     
542.                                         minute=59;
     
543.                                 temp=HEX2BCD(minute);
     
544.                                 write_byte(DS3231_MINUTE, temp);
     
545.                 }
     
546.         }
     
547. }
     
548. 
     
549. ///////////////////////////////
     
550. void display_sf() //顯示 時分
     
551. {
     
552. //                        year = read_random(DS3231_YEAR);               
     
553. //                    month = read_random(DS3231_MONTH);        
     
554. //                    day = read_random(DS3231_DAY);        
     
555. //                    week = read_random(DS3231_WEEK);
     
556.         hour = read_random(DS3231_HOUR);
     
557.         minute = read_random(DS3231_MINUTE) ;
     
558.         second = read_random(DS3231_SECOND);
     
559.         if(knum==0)
     
560.         {
     
561.                 LedBuff[0]= table[hour/10];
     
562.                 LedBuff[1]= table[hour%10];
     
563.                 LedBuff[2]= table[minute/10];
     
564.                 LedBuff[3]= table[minute%10];
     
565.         }
     
566.         if(knum==1)
     
567.         {
     
568.                 if(shan>250)
     
569.                 {
     
570.                         LedBuff[0]= table[hour/10];
     
571.                         LedBuff[1]= table[hour%10];
     
572.                 }
     
573.                 else
     
574.                 {
     
575.                         LedBuff[0]= table[10];
     
576.                         LedBuff[1]= table[10];
     
577.                
     
578.                 }
     
579.                 LedBuff[2]= table[minute/10];
     
580.                 LedBuff[3]= table[minute%10];
     
581.         }
     
582.         if(knum==2)
     
583.         {
     
584.                
     
585.                 LedBuff[0]= table[hour/10];
     
586.                 LedBuff[1]= table[hour%10];
     
587.                
     
588.                 if(shan>250)
     
589.                 {
     
590.                         LedBuff[2]= table[minute/10];
     
591.                         LedBuff[3]= table[minute%10];
     
592.                 }
     
593.                 else
     
594.                 {
     
595.                         LedBuff[2]= table[10];
     
596.                         LedBuff[3]= table[10];               
     
597.                 }
     
598.         }
     
599. }
     
600. 
     
601. 
     
602. /*************數碼管顯示函數1***************/
     
603. /*
     
604. void Display1(uint num)   //顯示時間程序
     
605. {
     
606.         uchar A1,A2,A3,A4;
     
607.         A1 = num/1000;    //千位
     
608.         A2 = num%1000/100;   //百位
     
609.         A3 = num%100/10;    //十位
     
610.         A4 = num%10;    //個位
     
611.                 if(A1==0)
     
612.                 LedBuff[0]= table[10];    //千位為0不顯示
     
613. //                else
     
614. //                LedBuff[0]= table[A1];
     
615. 
     
616.                 if((A2==0) && (A1==0))          //千位百位都為0百位不顯示
     
617.                 LedBuff[1]= table[10];    //
     
618.                 else
     
619.                 LedBuff[1]= table[A2];                //
     
620. 
     
621.                 if((A2==0) && (A1==0) && (A3==0))          //千位百位十位都為0十位不顯示
     
622.                 LedBuff[2]= table[10];
     
623.                 else
     
624.                 LedBuff[2]= table[A3];
     
625. 
     
626.                 if((shan>250) && (set_flag==0) && (flag==1))//非設置狀態+計時狀態，第4位數碼管的小數點閃爍
     
627.                 LedBuff[3]= table[A4]&0x7f;      //顯示分個位
     
628.                 else
     
629.                 LedBuff[3]= table[A4];
     
630. } */
     
631. ////////////////////////
     
632. //void Display() //顯示off
     
633. //{
     
634. //        LedBuff[0]= table[10];
     
635. //        LedBuff[1]= table[0];
     
636. //        LedBuff[2]= table[13];
     
637. //        LedBuff[3]= table[13];
     
638. //}
     
639. 
     
640. /////////////////////
     
641. 
     
642. void main()
     
643. {
     
644.         Timer0Init();
     
645.         P0M0 = 0x0f;   //
     
646.     P0M1 = 0x00;   //
     
647.     P1M0 = 0x00;   //
     
648.         P1M1 = 0x00;
     
649.     P2M0 = 0x1f;   //p2.0-p2.4 設為推挽輸出
     
650.     P2M1 = 0x00;
     
651.     P3M0 = 0x04;  //P3.2設為推挽輸出才能驅動繼電器
     
652.     P3M1 = 0x00;
     
653.     P4M0 = 0x00;
     
654.     P4M1 = 0x00;
     
655.     P5M0 = 0x00;
     
656.     P5M1 = 0x00;
     
657. 
     
658. //        P2PU=0x10;
     
659. //        P2DR=0X00;
     
660. //        out = 0;
     
661. 
     
662. //        fen_L = IapRead(0x0001);
     
663. //        fen_M = IapRead(0x0002);
     
664. //        if(fen_L==255)
     
665. //                fen_L = 254;
     
666. //        if(fen_M==255)
     
667. //                fen_M = 0;
     
668. //        fen = fen_M*256 + fen_L;
     
669. //        fen_temp=fen;
     
670. //
     
671. //        w5=1;
     
672.         while(1)
     
673.         {
     
674.                 display_sf();
     
675.                 keyscan();
     
676. 
     
677.                 if(shan>250)
     
678.                 {w5=1;  BZ=1;}
     
679.                 else {w5=0; BZ=0;}
     
680.         }
     
681. }
     
682. 
     
683. void timer0() interrupt 1
     
684. {
     
685. //        if(flag3==0)
     
686. //        {
     
687. //                cont2++;
     
688. //                if(cont2==500) //1秒
     
689. //                {
     
690. //                        cont2=0;
     
691. //                        num2++;
     
692. //                        if(num2==3)//開機延時3秒啟動輸出
     
693. //                        {
     
694. //                                num2=0;
     
695. //                                flag=1;        //計時標志置1
     
696. ////                                out = 1;//打開輸出
     
697. //                                fm_flag=1;//啟動蜂鳴器
     
698. //                                flag3=1;
     
699. //                        }
     
700. //                }
     
701. //        }
     
702. 
     
703.         if(fm_flag)
     
704.         {
     
705.                 BZ = 0;        //蜂鳴器開
     
706.                 cont3++;
     
707.                 if(cont3==100)//0.2秒
     
708.                 {
     
709.                         cont3=0;
     
710.                         BZ = 1;         //蜂鳴器關
     
711.                         fm_flag=0;        
     
712.                 }        
     
713.         }
     
714.                                                                                                                                                                  
     
715.         shan++;
     
716.         if(shan==500)
     
717.         {
     
718.                 shan=0;
     
719.         }
     
720. 
     
721.         Ledcount++;
     
722.         P1=0xff;   //消影
     
723.         if(Ledcount==4)
     
724.         {
     
725.                 Ledcount=0;
     
726.         }
     
727.         switch(Ledcount)
     
728.         {
     
729.                 case 0: w2 = 1; w3 = 1; w4 = 1;w1 = 0; P1 = LedBuff[0];  break;
     
730.                 case 1: w1 = 1; w3 = 1; w4 = 1;w2 = 0; P1 = LedBuff[1];  break;
     
731.                 case 2: w1 = 1; w2 = 1; w4 = 1;w3 = 0; P1 = LedBuff[2];  break;
     
732.                 case 3: w1 = 1; w2 = 1; w3 = 1;w4 = 0; P1 = LedBuff[3];  break;
     
733.                 default: break;
     
734.         }
     
735.         
     
736. 
     
737. 
     
738.         if(flag1) //按鍵消抖計時
     
739.         {k1_time_count++;}
     
740. 
     
741.         if(flag2) //按鍵消抖計時
     
742.         {k2_time_count++;}
     
743. 
     
744.         if(flag3) //按鍵消抖計時
     
745.         {k3_time_count++;}
     
746. 
     
747. 
     
748.    /*     if(set_flag) //無按鍵 3秒退出設置狀態
     
749.         {
     
750.                 cont1++;
     
751.                 if(cont1==500) //1秒到
     
752.                 {
     
753.                         cont1=0;
     
754.                         num++;
     
755.                         if(num==3)
     
756.                         {
     
757.                                 num=0;
     
758.                                 set_flag=0;//設置標志清零，退出設置狀態
     
759.                                 flag=1;         //計時標志置1，開始計時
     
760.                                 fm_flag=1;//啟動蜂鳴器，響一下
     
761.                         }               
     
762.                 }
     
763.         }*/
     
764. }
     
765. 
     

復制代碼

程序和Gerber格式的PCB文件下載: 0.8寸數碼管時鐘.zip (542.14 KB, 下載次數: 44)

2023-12-7 12:36 上傳

點擊文件名下載附件
下載積分: 黑幣 -5

---

作者: clyf    時間: 2023-12-9 21:20
這個資料好啊，多謝

---

作者: lids    時間: 2023-12-11 12:55
重新做了一個，沒有第一個的問題，看來的是第一個單片機有問題

---

作者: lids    時間: 2023-12-11 15:50
這次制作有點不順，ds3231（8腳封裝）的，加0.22F的法拉電容，開始兩天測試掉電能繼續走時，過了兩天再來測試，掉電重新上電，時間就亂了。手上有一個DS3231模塊，把模塊接在板上，掉電繼續走時正常；看來ds3231（8腳封裝）的這個時鐘芯片也有問題

---

作者: lids    時間: 2023-12-12 09:09
這是時間和溫度輪流顯示的程序

1. /*
   
2. 項目名稱：0.8寸4位共陽數碼管時鐘
   
3. 1.5個PNP三極管接在共陽極驅動數碼管，這個數碼管小數點都有，冒號是單獨兩個LED
   
4. 2.設置方法：按k1鍵設置狀態（小時位數碼管閃爍），按K2鍵++，按K3鍵--，長按連加連減；
   
5. 按K1鍵第二次，分鐘位數碼管閃爍，按K2鍵++，按K3鍵--，長按連加連減；
   
6. 按K1鍵第三次，退出設置狀態，回到正常走時界面。
   
7. 3. P2.0-P2.4位驅動口，P1口為段驅動口；
   
8. 
   
9. 4. 單片機=STC8H1K16（LQFP32封裝） @11.0592MHz   時鐘芯片=DS3231MZ(SOP-8封裝)
   
10. 測試通過
    
11. 第一次發的程序按鍵長按有bug，也改好了。
    
12. 
    
13. 
    
14. */
    
15. #include <STC8H.H>
    
16. #include <intrins.h>
    
17. #include "ds18b20.h"
    
18. //#include "delay.h"
    
19. #define uchar unsigned char
    
20. #define uint unsigned int
    
21. 
    
22. 
    
23. //typedef     unsigned char   u8;
    
24. //typedef     unsigned int    u16;
    
25. //typedef     unsigned long   u32;
    
26. 
    
27. sbit k1=P0^0;//        按鍵1 設置 +
    
28. sbit k2=P2^7;//        按鍵2  -
    
29. sbit k3=P3^7;//        
    
30. sbit k4=P2^5;
    
31. sbit out = P3^2;          //輸出端口
    
32. sbit w1 = P2^0;          //設置位驅動口
    
33. sbit w2 = P2^1;
    
34. sbit w3 = P2^2;
    
35. sbit w4 = P2^3;
    
36. 
    
37. sbit w5 = P2^4;        //冒號控制
    
38. 
    
39. sbit BZ = P0^3;//蜂鳴器控制口
    
40. uint count,cont1,cont2,cont3;
    
41. uint fen,fen_temp;
    
42. uchar fen_L,fen_M,miao,num,num2;
    
43. uchar Ledcount;
    
44. uchar num;
    
45. uchar k1_lock,k2_lock,k3_lock;//按鍵鎖
    
46. uchar knum;
    
47. uint shan,shan1;//秒點閃爍 計時變量
    
48. 
    
49. uint k1_time_count;          //K1消抖計數
    
50. uint k2_time_count;          //K2消抖計數
    
51. uint k3_time_count;          //K3消抖計數
    
52. 
    
53. bit flag;        //計時啟動標志
    
54. bit flag1;        //按鍵消抖計數標志
    
55. bit flag2;        //按鍵消抖計數標志
    
56. bit save_flag;//數據保存標志
    
57. bit save_flag1;//數據保存標志
    
58. bit set_flag=0; //設置標志
    
59. bit fm_flag;//蜂鳴器
    
60. 
    
61. bit flag3;
    
62. bit qh_flag,qh_flag1;
    
63. uchar hour,minute,second,year,month,day,date,week;
    
64. uint TH3231;
    
65. bit        ack;                //應答標志位
    
66. 
    
67. uchar code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff,0xC6,0xbf,0x8e};//共陽段碼 （0--9、黑屏,C,-,F）0X46 C帶點，0xc6C不帶點
    
68. uchar LedBuff[]={0xff,0xff,0xff,0xff};
    
69. 
    
70. // ------------------------------------------------------------
    
71. // IO口模擬I2C通信
    
72. 
    
73. // ------------------------------------------------------------
    
74. sbit SCL=P3^5; //串行時鐘
    
75. sbit SDA=P3^4; //串行數據
    
76. 
    
77. /********************************************************************************************************
    
78. **         DS3231常數定義
    
79. ********************************************************************************************************/
    
80. #define DS3231_WriteAddress 0xD0    //器件寫地址
    
81. #define DS3231_ReadAddress  0xD1    //器件讀地址
    
82. #define DS3231_SECOND       0x00    //秒
    
83. #define DS3231_MINUTE       0x01    //分
    
84. #define DS3231_HOUR         0x02    //時
    
85. #define DS3231_WEEK         0x03    //星期
    
86. #define DS3231_DAY          0x04    //日
    
87. #define DS3231_MONTH        0x05    //月
    
88. #define DS3231_YEAR         0x06    //年
    
89. 
    
90. #define DS3231_TEMPERATUREH 0x11    //溫度寄存器高字節(8位)        整數部分
    
91. #define DS3231_TEMPERATUREL 0x12    //溫度寄存器低字節(低2位) 小數部分
    
92. 
    
93. 
    
94. 
    
95. #define NACK    1
    
96. #define ACK     0
    
97. /////////////////
    
98. 
    
99. //void        Delay5US()           //@12.000MHz           延時5us
    
100. //{
     
101. //   _nop_(); _nop_();        _nop_();_nop_();         _nop_();_nop_();//STC Y6指令 1T單片機用6個nop，12T用1個nop
     
102. //}
     
103. 
     
104. void Delay5US()                //@11.0592MHz         STC Y6指令
     
105. {
     
106.         unsigned char i;
     
107. 
     
108.         _nop_();
     
109.         i = 16;
     
110.         while (--i);
     
111. }
     
112. 
     
113. 
     
114. void delay(uint x)
     
115. {
     
116.         uint y,z;
     
117.         for(y=0; y<x; y--)
     
118.                 for(z=0; z<1200; z--);
     
119. 
     
120. }
     
121. 
     
122. 
     
123. /**********************************************
     
124. //IIC Start
     
125. **********************************************/
     
126. void IIC_Start()
     
127. {
     
128.    SCL = 1;               
     
129.    SDA = 1;
     
130.    SDA = 0;
     
131.    SCL = 0;
     
132. }
     
133. 
     
134. /**********************************************
     
135. //IIC Stop
     
136. **********************************************/
     
137. void IIC_Stop()
     
138. {
     
139.    SCL = 0;
     
140.    SDA = 0;
     
141.    SCL = 1;
     
142.    SDA = 1;
     
143. }
     
144. 
     
145. /********************************************************************************************************
     
146. **         3231
     
147. ********************************************************************************************************/
     
148. 
     
149. 
     
150. uchar        BCD2HEX(uchar val)//轉10進制
     
151. {
     
152.         return        ((val>>4)*10)+(val&0x0f);
     
153. }
     
154. 
     
155. uchar        HEX2BCD(uchar val) //轉16進制
     
156. {
     
157.         return        (((val%100)/10)<<4)|(val%10);
     
158. }
     
159. 
     
160. 
     
161. void SendByte(uchar c)
     
162. {
     
163.     uchar BitCnt;
     
164.    
     
165.     for(BitCnt=0;BitCnt<8;BitCnt++)         //要傳送的數據長度為8位
     
166.     {
     
167.         if((c<<BitCnt)&0x80)
     
168.             SDA=1;                          //判斷發送位
     
169.         else
     
170.             SDA=0;     
     
171.         SCL=1;                            //置時鐘線為高，通知被控器開始接收數據位
     
172.         Delay5US();                       //保證時鐘高電平周期大于4μs   
     
173.         SCL=0;
     
174.     }
     
175.     SDA=1;                                  //8位發送完后釋放數據線，準備接收應答位
     
176.     SCL=1;
     
177.     Delay5US();
     
178.     if(SDA==1)
     
179.         ack=0;   
     
180.     else
     
181.         ack=1;                              //判斷是否接收到應答信號
     
182.     SCL=0;
     
183.     Delay5US();
     
184. }           
     
185. 
     
186. uchar RcvByte()
     
187. {
     
188.    uchar retc;
     
189.    uchar BitCnt;
     
190. 
     
191.    retc=0;
     
192.    SDA=1;                           //置數據線為輸入方式
     
193.    for(BitCnt=0;BitCnt<8;BitCnt++)
     
194.    {
     
195.         SCL=0;                      //置時鐘線為低，準備接收數據位      
     
196.         Delay5US();                 //時鐘低電平周期大于4.7μs                       
     
197.         SCL=1;                      //置時鐘線為高使數據線上數據有效
     
198.         Delay5US();
     
199.         retc=retc<<1;
     
200.         if(SDA==1)
     
201.             retc=retc+1;            //讀數據位,接收的數據位放入retc中
     
202.         Delay5US();
     
203.    }
     
204.    SCL=0;
     
205.    return(retc);
     
206. }                           
     
207. 
     
208. void Ack_I2C(bit a)
     
209. {
     
210.         SDA        =        a;  
     
211.     SCL=1;                     
     
212.     Delay5US();             //時鐘低電平周期大于4us   
     
213.     SCL=0;                  //清時鐘線，鉗住I2C總線以便繼續接收
     
214.     Delay5US();   
     
215. }                                            
     
216. 
     
217. uchar write_byte(uchar addr, uchar write_data)
     
218. {
     
219.     IIC_Start();
     
220.     SendByte(DS3231_WriteAddress);
     
221.     if (ack == 0)
     
222.         return 0;
     
223.    
     
224.     SendByte(addr);   
     
225.     if (ack == 0)
     
226.         return 0;
     
227.    
     
228.     SendByte(write_data);
     
229.     if (ack == 0)
     
230.         return 0;
     
231.    
     
232.     IIC_Stop();
     
233.     Delay5US();      
     
234.     Delay5US();      
     
235.     return 1;
     
236. }                                          
     
237. 
     
238. uchar read_current()
     
239. {
     
240.     uchar read_data;
     
241.     IIC_Start();
     
242.     SendByte(DS3231_ReadAddress);
     
243.     if(ack==0)
     
244.         return(0);              
     
245.     read_data = RcvByte();
     
246.     Ack_I2C(1);
     
247.     IIC_Stop();
     
248.     return read_data;
     
249. }                                                
     
250. 
     
251. uchar read_random(uchar random_addr)
     
252. {
     
253.     uchar Tmp;
     
254.         IIC_Start();
     
255.     SendByte(DS3231_WriteAddress);
     
256.     if(ack==0)
     
257.         return(0);            
     
258.     SendByte(random_addr);
     
259.     if(ack==0)
     
260.         return(0);
     
261.         Tmp=read_current();
     
262.         if(random_addr==DS3231_HOUR)
     
263.                 Tmp&=0x3f;
     
264.                                             
     
265.     return(BCD2HEX(Tmp));//都轉10進制輸出
     
266. }
     
267. 
     
268. /***********************/
     
269. uchar read_random1(uchar random_addr)  //這個是讀溫度函數
     
270. {
     
271.     uchar Tmp;
     
272. //        write_byte(0x0e,0x20);//0x0e寄存器的CONV位置1開啟溫度轉換，要這句，溫度實時刷新，這句不要，溫度要64s才刷新1次
     
273.                                                   //數碼管顯示不能要這句，否則溫度值小數部分亂跳
     
274.         IIC_Start();
     
275.     SendByte(DS3231_WriteAddress);
     
276.     if(ack==0)
     
277.         return(0);            
     
278.     SendByte(random_addr);
     
279.     if(ack==0)
     
280.         return(0);
     
281.         Tmp=read_current();
     
282.         return Tmp;
     
283. }                                 
     
284. 
     
285. void ModifyTime(uchar address,uchar num)
     
286. {
     
287.     uchar temp=0;
     
288.            if(address>6 && address <0) return;
     
289.     temp=HEX2BCD(num);
     
290.         write_byte(address,temp);
     
291. }
     
292. 
     
293. 
     
294. 
     
295. ////////////////
     
296. /*
     
297. void IapIdle()
     
298. {
     
299.     IAP_CONTR = 0;                              //關閉IAP功能
     
300.     IAP_CMD = 0;                                //清除命令寄存器
     
301.     IAP_TRIG = 0;                               //清除觸發寄存器
     
302.     IAP_ADDRH = 0x80;                           //將地址設置到非IAP區域
     
303.     IAP_ADDRL = 0;
     
304. }
     
305. 
     
306. char IapRead(int addr)
     
307. {
     
308.     char dat;
     
309. 
     
310.     IAP_CONTR = 0x80;                           //使能IAP
     
311.     IAP_TPS = 12;                               //設置等待參數12MHz
     
312.     IAP_CMD = 1;                                //設置IAP讀命令
     
313.     IAP_ADDRL = addr;                           //設置IAP低地址
     
314.     IAP_ADDRH = addr >> 8;                      //設置IAP高地址
     
315.     IAP_TRIG = 0x5a;                            //寫觸發命令(0x5a)
     
316.     IAP_TRIG = 0xa5;                            //寫觸發命令(0xa5)
     
317.     _nop_();
     
318.     dat = IAP_DATA;                             //讀IAP數據
     
319.     IapIdle();                                  //關閉IAP功能
     
320. 
     
321.     return dat;
     
322. }
     
323. 
     
324. void IapProgram(int addr, char dat)
     
325. {
     
326.     IAP_CONTR = 0x80;                           //使能IAP
     
327.     IAP_TPS = 12;                               //設置等待參數12MHz
     
328.     IAP_CMD = 2;                                //設置IAP寫命令
     
329.     IAP_ADDRL = addr;                           //設置IAP低地址
     
330.     IAP_ADDRH = addr >> 8;                      //設置IAP高地址
     
331.     IAP_DATA = dat;                             //寫IAP數據
     
332.     IAP_TRIG = 0x5a;                            //寫觸發命令(0x5a)
     
333.     IAP_TRIG = 0xa5;                            //寫觸發命令(0xa5)
     
334.     _nop_();
     
335.     IapIdle();                                  //關閉IAP功能
     
336. }
     
337. 
     
338. void IapErase(int addr)
     
339. {
     
340.     IAP_CONTR = 0x80;                           //使能IAP
     
341.     IAP_TPS = 12;                               //設置等待參數12MHz
     
342.     IAP_CMD = 3;                                //設置IAP擦除命令
     
343.     IAP_ADDRL = addr;                           //設置IAP低地址
     
344.     IAP_ADDRH = addr >> 8;                      //設置IAP高地址
     
345.     IAP_TRIG = 0x5a;                            //寫觸發命令(0x5a)
     
346.     IAP_TRIG = 0xa5;                            //寫觸發命令(0xa5)
     
347.     _nop_();                                    //
     
348.     IapIdle();                                  //關閉IAP功能
     
349. }
     
350. */
     
351. ////////////////////
     
352. void Timer0Init(void)                //2毫秒@11.0592MHz
     
353. {
     
354.         AUXR |= 0x80;                //定時器時鐘1T模式
     
355.         TMOD &= 0xF0;                //設置定時器模式  16位自動重載
     
356.         TL0 = 0x9A;                //設置定時初始值
     
357.         TH0 = 0xA9;                //設置定時初始值
     
358.         TF0 = 0;                //清除TF0標志
     
359.         TR0 = 1;                //定時器0開始計時
     
360.         EA = 1;                        //開總中斷
     
361.         ET0 = 1;                //開T0中斷
     
362. }
     
363. 
     
364. 
     
365. //void Timer0Init(void)                //5毫秒@11.0592MHz
     
366. //{
     
367. //        AUXR |= 0x80;                //定時器時鐘1T模式
     
368. //        TMOD &= 0xF0;                //設置定時器模式
     
369. //        TL0 = 0x00;                //設置定時初始值
     
370. //        TH0 = 0x28;                //設置定時初始值
     
371. //        TF0 = 0;                //清除TF0標志
     
372. //        TR0 = 1;                //定時器0開始計時
     
373. //        EA = 1;                        //開總中斷
     
374. //        ET0 = 1;                //開T0中斷
     
375. //}
     
376. /////////////////////////////
     
377. void keyscan()
     
378. {
     
379.         uchar temp;
     
380.         hour = read_random(DS3231_HOUR);
     
381.         minute = read_random(DS3231_MINUTE) ;
     
382.         second = read_random(DS3231_SECOND);
     
383. 
     
384.         
     
385.         if(k1)        //
     
386.         {                                                //
     
387.                 k1_time_count=0;
     
388.                 k1_lock=0;
     
389.                 flag1 = 0;
     
390.         }
     
391.         else if((k1_lock==0))
     
392.         {
     
393.                 flag1 = 1; //按鍵按下 消抖計時標志置1 開始消抖計時
     
394.                 if((k1_time_count==10))  //20毫秒
     
395.                 {
     
396.                         k1_time_count=0;
     
397.                         k1_lock=1;
     
398.                         knum++;
     
399.                         if(knum==3)
     
400.                         {
     
401.                                 knum=0;
     
402.                                 second=0;
     
403.                                 write_byte(DS3231_SECOND, second); //秒寫0
     
404.                         }
     
405.                 }
     
406.         }
     
407. 
     
408. /////////////////////////////
     
409.         if(knum==1)  //設置小時
     
410.         {
     
411.                 if(k2 ==1)                                   //++
     
412.                 {
     
413.                         k2_time_count=0;
     
414.                         k2_lock=0;
     
415.                         flag2 = 0;
     
416.                 }
     
417.                 else if(k2_lock==0)
     
418.                 {
     
419.                 //        flag = 0;
     
420.                         flag2 = 1;
     
421.                 //        save_flag = 1;
     
422.                         if(k2_time_count==10)                //短按
     
423.                         {
     
424.                                 k2_time_count=0;
     
425.                                 k2_lock=1;
     
426.                                 hour++;
     
427.                                 if(hour>23)
     
428.                                         hour=0;
     
429.                                 temp=HEX2BCD(hour);
     
430.                                 write_byte(DS3231_HOUR, temp);
     
431.                         }        
     
432.                 }
     
433.                 else if(k2_time_count>500)                 //長按
     
434.                 {
     
435.                   // cont1=0; num=0;
     
436.                    k2_time_count=400;
     
437.                         hour++;
     
438.                         if(hour>23)
     
439.                                 hour=0;
     
440.                         temp=HEX2BCD(hour);        //10進制轉16進制
     
441.                         write_byte(DS3231_HOUR, temp);
     
442. 
     
443.                 }
     
444. //////////////////////////
     
445.                 if(k3 == 1)                                   //--
     
446.                 {
     
447.                         k3_time_count=0;
     
448.                         k3_lock=0;
     
449.                         flag3 = 0;
     
450.                 }
     
451.                 else if(k3_lock==0)
     
452.                 {
     
453.                
     
454.                         flag3 = 1;
     
455.                 //        save_flag1 = 1;
     
456.                         if(k3_time_count==10)                //短按
     
457.                         {
     
458.                         //        cont1=0; num=0;
     
459.                                 k3_time_count=0;
     
460.                                 k3_lock=1;
     
461.                                 hour--;
     
462.                                 if(hour==255)
     
463.                                         hour=23;
     
464.                                 temp=HEX2BCD(hour);
     
465.                                 write_byte(DS3231_HOUR, temp);
     
466. 
     
467.                         }
     
468.                                 
     
469.                 }
     
470.                 else if(k3_time_count>500)                 //長按
     
471.                 {
     
472.                   // cont1=0; num=0;  
     
473.                    k3_time_count=400;         //長按200ms連減
     
474.                                 hour--;
     
475.                         if(hour==255)
     
476.                                 hour=23;
     
477.                         temp=HEX2BCD(hour);
     
478.                         write_byte(DS3231_HOUR, temp);
     
479. 
     
480.                 }
     
481.         }
     
482.   ////////////////////////////////
     
483.         if(knum==2)                 //設置分鐘
     
484.         {
     
485.                 if(k2 ==1)                                   //++
     
486.                 {
     
487.                         k2_time_count=0;
     
488.                         k2_lock=0;
     
489.                         flag2 = 0;
     
490.                 }
     
491.                 else if(k2_lock==0)
     
492.                 {
     
493.                 //        flag = 0;
     
494.                         flag2 = 1;
     
495.                 //        save_flag = 1;
     
496.                         if(k2_time_count==10)                //短按
     
497.                         {
     
498.                                 k2_time_count=0;
     
499.                                 k2_lock=1;
     
500.                                 minute++;
     
501.                                 if(minute>59)
     
502.                                         minute=0;
     
503.                                 temp=HEX2BCD(minute);
     
504.                                 write_byte(DS3231_MINUTE, temp);
     
505.                         }        
     
506.                 }
     
507.                 else if(k2_time_count>500)                 //長按
     
508.                 {
     
509.                   // cont1=0; num=0;
     
510.                    k2_time_count=400;
     
511.                         minute++;
     
512.                         if(minute>59)
     
513.                                 minute=0;
     
514.                         temp=HEX2BCD(minute);
     
515.                         write_byte(DS3231_MINUTE, temp);
     
516. 
     
517.                 }
     
518. //////////////////////////
     
519.                 if(k3 == 1)                                   //--
     
520.                 {
     
521.                         k3_time_count=0;
     
522.                         k3_lock=0;
     
523.                         flag3 = 0;
     
524.                 }
     
525.                 else if(k3_lock==0)
     
526.                 {
     
527.                
     
528.                         flag3 = 1;
     
529.                 //        save_flag1 = 1;
     
530.                         if(k3_time_count==10)                //短按
     
531.                         {
     
532.                         //        cont1=0; num=0;
     
533.                                 k3_time_count=0;
     
534.                                 k3_lock=1;
     
535.                                 minute--;
     
536.                                 if(minute==255)
     
537.                                         minute=59;
     
538.                                 temp=HEX2BCD(minute);
     
539.                                 write_byte(DS3231_MINUTE, temp);
     
540.                         }
     
541.                                 
     
542.                 }
     
543.                 else if(k3_time_count>500)                 //長按
     
544.                 {
     
545.                   // cont1=0; num=0;  
     
546.                    k3_time_count=400;
     
547.                         minute--;
     
548.                         if(minute==255)
     
549.                                 minute=59;
     
550.                         temp=HEX2BCD(minute);
     
551.                         write_byte(DS3231_MINUTE, temp);
     
552.                 }
     
553.         }
     
554. }
     
555. 
     
556. ///////////////////////////////
     
557. void display_sf() //顯示 時分
     
558. {
     
559. //                        year = read_random(DS3231_YEAR);               
     
560. //                    month = read_random(DS3231_MONTH);        
     
561. //                    day = read_random(DS3231_DAY);        
     
562. //                    week = read_random(DS3231_WEEK);
     
563.         hour = read_random(DS3231_HOUR);
     
564.         minute = read_random(DS3231_MINUTE) ;
     
565.         second = read_random(DS3231_SECOND);
     
566.         if(knum==0)
     
567.         {
     
568.                 LedBuff[0]= table[hour/10];
     
569.                 LedBuff[1]= table[hour%10];
     
570. 
     
571.                 LedBuff[2]= table[minute/10];
     
572.                 LedBuff[3]= table[minute%10];
     
573.                 if(shan>250)
     
574.                 {w5=1; }
     
575.                 else {w5=0;}
     
576. 
     
577. 
     
578.         }
     
579.         if(knum==1)
     
580.         {
     
581.                 if(shan1>125)        
     
582.                 {
     
583.                         LedBuff[0]= table[hour/10];
     
584.                         LedBuff[1]= table[hour%10];
     
585.                 }
     
586.                 else
     
587.                 {
     
588.                         LedBuff[0]= table[10];
     
589.                         LedBuff[1]= table[10];
     
590.                
     
591.                 }
     
592.                 LedBuff[2]= table[minute/10];
     
593.                 LedBuff[3]= table[minute%10];
     
594.         }
     
595.         if(knum==2)
     
596.         {
     
597.                
     
598.                 LedBuff[0]= table[hour/10];
     
599.                 LedBuff[1]= table[hour%10];
     
600.                
     
601.                 if(shan1>125)
     
602.                 {
     
603.                         LedBuff[2]= table[minute/10];
     
604.                         LedBuff[3]= table[minute%10];
     
605.                 }
     
606.                 else
     
607.                 {
     
608.                         LedBuff[2]= table[10];
     
609.                         LedBuff[3]= table[10];               
     
610.                 }
     
611.         }
     
612. }
     
613. 
     
614. 
     
615. ///////////////////////
     
616. 
     
617. void ds18b20disp(uint Value)
     
618. {
     
619.         if(s==0) //顯示正溫度
     
620.         {
     
621.                 if((Value/1000)>0)//大于100度顯示最高位
     
622.                         LedBuff[0]= table[Value/1000];               
     
623.                 else                        
     
624.                         LedBuff[0]=table[10];//小于100度不顯示最高位
     
625.         }else {LedBuff[0]=s;}//顯示負號
     
626.         LedBuff[1]=table[Value%1000/100];        //十位
     
627.         LedBuff[2]=table[Value%100/10];//
     
628.         LedBuff[3]=table[11];
     
629. }  
     
630. /////////////////////
     
631. 
     
632. /////////////////////
     
633. 
     
634. void main()
     
635. {
     
636.         Timer0Init();
     
637.         P0M0 = 0x00;   //
     
638.     P0M1 = 0x00;   //
     
639.     P1M0 = 0x00;   //
     
640.         P1M1 = 0x00;
     
641.     P2M0 = 0x1f;   //p2.0-p2.4 設為推挽輸出
     
642.     P2M1 = 0x00;
     
643.     P3M0 = 0x04;  //P3.2設為推挽輸出才能驅動繼電器
     
644.     P3M1 = 0x00;
     
645.     P4M0 = 0x00;
     
646.     P4M1 = 0x00;
     
647.     P5M0 = 0x10;
     
648.     P5M1 = 0x00;
     
649. 
     
650. //        P2PU=0x10;
     
651. //        P2DR=0X00;
     
652. //        w5=1;
     
653.         while(1)
     
654.         {
     
655.                
     
656.                 keyscan();
     
657.                 if(qh_flag==0)
     
658.                 {
     
659.                         display_sf();
     
660.                 }
     
661.                 else
     
662.                 {
     
663.                         if(knum==0)
     
664.                         {
     
665.                                 read_temp();         //DS18B20溫度
     
666.                                 ds18b20disp(tvalue);
     
667.                                 w5=1;
     
668.                         }
     
669.                 }
     
670. 
     
671.                 if(knum!=0)
     
672.                 {
     
673.                         qh_flag=0;
     
674.                 }
     
675. //                if(shan>250)
     
676. //                {BZ=1;}
     
677. //                else {BZ=0;}
     
678.                
     
679. //                BZ=0;
     
680. //                Delay_us(10);//實測11us（延時函數里面4個_nop_();@11.0592MHz）
     
681. //                BZ=1;
     
682. //                Delay_us(10);
     
683.                  
     
684.         }
     
685. }
     
686. 
     
687. void timer0() interrupt 1
     
688. {
     
689. 
     
690.         static uint i,j;
     
691.         /*
     
692.         if(fm_flag)
     
693.         {
     
694.                 BZ = 0;        //蜂鳴器開
     
695.                 cont3++;
     
696.                 if(cont3==100)//0.2秒
     
697.                 {
     
698.                         cont3=0;
     
699.                         BZ = 1;         //蜂鳴器關
     
700.                         fm_flag=0;        
     
701.                 }        
     
702.         } */
     
703.                                                                                                                                                                  
     
704.         shan++;
     
705.         if(shan==500)
     
706.         {
     
707.                 shan=0;
     
708.         }
     
709. 
     
710.         if(knum != 0)
     
711.         {
     
712.                 shan1++;
     
713.                 if(shan1==250)
     
714.                         shan1=0;
     
715.         }
     
716. 
     
717.         Ledcount++;
     
718.         P1=0xff;   //消影
     
719.         if(Ledcount==4)
     
720.         {
     
721.                 Ledcount=0;
     
722.         }
     
723.         switch(Ledcount)
     
724.         {
     
725.                 case 0: w2 = 1; w3 = 1; w4 = 1;w1 = 0; P1 = LedBuff[0];  break;
     
726.                 case 1: w1 = 1; w3 = 1; w4 = 1;w2 = 0; P1 = LedBuff[1];  break;
     
727.                 case 2: w1 = 1; w2 = 1; w4 = 1;w3 = 0; P1 = LedBuff[2];  break;
     
728.                 case 3: w1 = 1; w2 = 1; w3 = 1;w4 = 0; P1 = LedBuff[3];  break;
     
729.                 default: break;
     
730.         }
     
731.         
     
732. 
     
733. 
     
734.         if(flag1) //按鍵消抖計時
     
735.         {k1_time_count++;}
     
736. 
     
737.         if(flag2) //按鍵消抖計時
     
738.         {k2_time_count++;}
     
739. 
     
740.         if(flag3) //按鍵消抖計時
     
741.         {k3_time_count++;}
     
742. 
     
743.         if(qh_flag1==0 && knum==0)
     
744.         {
     
745.                 i++;
     
746.                 if(i==500)
     
747.                 {
     
748.                         i=0;
     
749.                         j++;
     
750.                         if(j==7)
     
751.                         {
     
752.                                 j=0;
     
753.                                 qh_flag=1;
     
754.                                 qh_flag1=1;
     
755.                         }
     
756.                 }
     
757.         }
     
758.         else
     
759.         {
     
760.                 if(knum==0)
     
761.                 {
     
762.                         i++;
     
763.                         if(i==500)
     
764.                         {
     
765.                                 i=0;
     
766.                                 j++;
     
767.                                 if(j==3)
     
768.                                 {
     
769.                                         j=0;
     
770.                                         qh_flag=0;
     
771.                                         qh_flag1=0;
     
772.                                 }
     
773.                         }
     
774.                 }
     
775.         }
     
776. 
     
777. }
     
778. 
     
779. [code]#ifndef __DS18B20_H__
     
780. #define __DS18B20_H__
     
781. 
     
782. //#include "delay.h"
     
783. #define uchar unsigned char
     
784. #define uint unsigned int
     
785. 
     
786. /*定義DS18B20數據線*/
     
787. sbit DQ = P0^1;
     
788. //sbit DQ = P5^4;
     
789. 
     
790. /*DS18B20驅動程序------------------------------------------------------------*/
     
791. uchar data disdata[5];
     
792. uint tvalue;//溫度值
     
793. uint s;
     
794. void Delay_us(uchar i)        //us延時 STC  Y6指令 使用STC8系列
     
795. {                                                 //@11.0592MHz
     
796.          while(i--)
     
797.          {        
     
798.          _nop_();
     
799.      _nop_();
     
800.          _nop_();
     
801.      _nop_();
     
802.          ////////////
     
803.          _nop_(); //_nop_();// _nop_();        _nop_();
     
804.          }
     
805. }  
     
806. 
     
807. 
     
808. 
     
809. 
     
810. /*單總線初始化時序*/
     
811. bit ds_init()
     
812. {
     
813.         bit i;
     
814.         DQ = 1;
     
815.         _nop_();_nop_();_nop_();_nop_();_nop_();
     
816.         DQ = 0;
     
817.         Delay_us(250); Delay_us(250);//拉低總線499.45us 掛接在總線上的18B20將會全部被復位
     
818.         DQ = 1; //釋放總線
     
819.         Delay_us(38); //延時37.95us 等待18B20發回存在信號
     
820.         i = DQ;
     
821.         Delay_us(145); //141.95us
     
822.         DQ = 1;
     
823.         _nop_();
     
824.         return (i);
     
825. }
     
826. /*寫一個字節*/
     
827. void write_byte_ds18b20(uchar dat)
     
828. {
     
829.         uchar i;
     
830.         for(i=0;i<8;i++)
     
831.         {
     
832.                 DQ = 0;
     
833.                 _nop_();//產生些時序
     
834.                 DQ = dat & 0x01;
     
835.                 Delay_us(78);//76.95us
     
836.                 DQ = 1; //釋放總線準備下一次數據寫入
     
837.                 _nop_();
     
838.                 dat >>= 1;
     
839.         }
     
840. }
     
841. 
     
842. uchar read_byte()
     
843. {
     
844.         uchar i, j, dat;
     
845.         for(i=0;i<8;i++)
     
846.         {
     
847.                 DQ = 0;
     
848.                 _nop_();//產生讀時序
     
849.                 DQ = 1;
     
850.                 _nop_();//釋放總線
     
851.                 j = DQ;
     
852.                 Delay_us(78);//76.95us
     
853.                 DQ = 1;
     
854.                 _nop_();
     
855.                 dat = (j<<7)|(dat>>1);        
     
856.         }
     
857.         return (dat);
     
858. }
     
859. 
     
860. read_temp()
     
861. {
     
862. //        float tt;
     
863.         uchar L,M;
     
864.            ds_init();   
     
865.            write_byte_ds18b20(0xcc);//*跳過讀序列號*/
     
866.            write_byte_ds18b20(0x44);//*啟動溫度轉換*/
     
867.                 Delay_us(100);
     
868.            ds_init();   
     
869.            write_byte_ds18b20(0xcc);//*跳過讀序列號*/
     
870.            write_byte_ds18b20(0xbe);//*讀取溫度*/
     
871.                 Delay_us(100);
     
872.            L=read_byte();
     
873.            M=read_byte();
     
874.            tvalue=M;
     
875.            tvalue<<=8;
     
876.            tvalue=tvalue|L;
     
877. 
     
878. 
     
879. //        if(M >= 0x08)        //判斷是否為負數
     
880. //        {
     
881. //                tvalue = ~tvalue + 1;//負數是以補碼的形式存放的需要取反加1
     
882. //                s = "-";  //顯示負數符號
     
883. //        }
     
884. //        else s = 0;           //為正數則不顯示負數符號
     
885. 
     
886. 
     
887.            tvalue=tvalue*(0.625);//溫度值擴大10倍，精確到1位小數
     
888.         return(tvalue);
     
889. }
     
890. /*溫度值顯示-----------------------------------------------------------------*/
     
891. /*
     
892. void ds1820disp()
     
893. {
     
894.         disdata[0]=tvalue%1000/100+0x30;         //十位數
     
895.         disdata[1]=tvalue%100/10+0x30;           //個位數
     
896.         disdata[2]=tvalue%10+0x30;               //小數位   
     
897.         if(disdata[0]==0x30) { disdata[0]=0x20; }//如果十位為0，不顯示
     
898.         set1616pic(5,4,0,1);                                         //顯示"溫度計圖標"
     
899.         write_com(0x30); write_com(0x06);        
     
900.         write_com(0x9d);           //在液晶上顯示溫度起始位置："28.8°C
     
901.         write_data(disdata[0]);    //顯示十位         
     
902.         write_data(disdata[1]);    //顯示個位         
     
903.         write_data(0x2e);          //顯示小數點         
     
904.         write_data(disdata[2]);    //顯示小數位
     
905.         set1616pic(8,4,0,0);           //在第8列第4行不反白的°C圖標
     
906. }  */
     
907. /*---------------------------------------------------------------------------*/
     
908. #endif

復制代碼

---

作者: lids    時間: 2023-12-21 15:16
ds3231（8腳封裝）買了兩家的，都是掉電走時有問題，重新買了ds3231（16腳封裝）的掉電走時很好，看來ds3231（8腳封裝）掉電走時是有問題的

---

作者: bxyyhan    時間: 2023-12-23 20:25

lids 發表于 2023-12-21 15:16
ds3231（8腳封裝）買了兩家的，都是掉電走時有問題，重新買了ds3231（16腳封裝）的掉電走時很好，看來ds323 ...

我用的就是8腳的，沒發現問題。秒點不需要單獨用三極管驅動，公共端接在gon第二個個的公共端就行了，我都是這樣處理的。

---

作者: lids    時間: 2023-12-27 15:21
掉電走時，重新上電時間會亂的問題解決了，原因是I2C總線的上拉電阻要接在單片機的IO口，并且要上拉到5V，時鐘芯片是3.3V供電（DS3231芯片3.3V供電比5V供電走時精度高些），時鐘芯片SDA  SCL的上拉不用

---

作者: bxyyhan    時間: 2024-1-5 16:31
把第三個數碼管倒過來，利用點來模擬秒點閃爍，我都是這樣做的。DS3231直接利用5V供電精度沒問題，

---

作者: lids    時間: 2024-1-8 11:27

bxyyhan 發表于 2024-1-5 16:31
把第三個數碼管倒過來，利用點來模擬秒點閃爍，我都是這樣做的。DS3231直接利用5V供電精度沒問題，

我這數碼管是一體的，不是單獨的四個。數碼管倒過來那種我做過的，兩個秒點有點丑，才做這種四位一體帶秒點的數碼管的

---

歡迎光臨 (http://m.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影