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

標題: 單片機+1302數碼管時鐘程序調不了時間 [打印本頁]

---

作者: wdmcp    時間: 2021-9-26 00:07
標題: 單片機+1302數碼管時鐘程序調不了時間
參考了幾個程序的核心部分，自己修改組合了一下，就想實現一個基本的可調時鐘。一共3個按鍵，設置，加，減。按設置可以在時，分鐘之間切換，同時相應位會閃爍。秒是采用的led指示，通過定時器中斷試驗出的計數值來控制，不是特別準確，主要起裝飾作用。。目前的現象是，能按照初始時間走時，按設置能切換閃爍，但無法加減小時或者分鐘，應該是往1302寫數據的程序有問題，但也沒看出來有什么問題，沒有解決的思路了，希望各位高手指點一下錯誤。

單片機源程序如下:

1. #include<reg52.h>
   
2. #include <intrins.h>
   
3. #define uint unsigned int
   
4. #define uchar unsigned char
   
5. uint milsec;
   
6. uchar i,t,a,d,sec,hour,hour1,min,min1,flag,temp,key=0,S_flag=0,k=0;
   
7. 
   
8. unsigned char led[12]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xbf,0xff};  //用一維數組定義0-9、橫杠、全滅
   
9. 
   
10. unsigned char b[4]={0x07,0x0b,0x0d,0x0e}; //掃描
    
11. 
    
12. unsigned char c[4];
    
13. 
    
14. sbit dula=P2^6;
    
15. sbit wela=P2^7;
    
16. 
    
17. sbit SCLK=P1^0;    //1302接口
    
18. sbit IO=P1^1;
    
19. sbit RST=P1^2;
    
20. 
    
21. sbit ACC0=ACC^0;
    
22. sbit ACC7=ACC^7;
    
23. 
    
24. //sbit key=P3^7;                //按鍵接口
    
25. sbit key1=P3^3;
    
26. sbit key2=P3^1;
    
27. sbit key3=P3^2;
    
28. sbit S5=P1^3;                 //指示秒的led
    
29. 
    
30. void delay(uint xms)//ms延時函數
    
31. {
    
32.         uint x,y;
    
33.         for(x=xms;x>0;x--)
    
34.          for(y=110;y>0;y--);
    
35. }
    
36. 
    
37. 
    
38. /*********************over***********************/
    
39. /********************ds1302****************************/
    
40. void write_byte(uchar dat)
    
41. {
    
42.         ACC=dat;
    
43.         RST=1;
    
44.         for(a=8;a>0;a--)
    
45.         {
    
46.                 IO=ACC0;
    
47.                 SCLK=0;
    
48.                 SCLK=1;
    
49.                 ACC=ACC>>1;
    
50.         }
    
51. }
    
52. uchar read_byte()
    
53. {
    
54.         RST=1;
    
55.         for(a=8;a>0;a--)
    
56.         {
    
57.                 ACC7=IO;
    
58.                 SCLK=1;
    
59.                 SCLK=0;
    
60.                 ACC=ACC>>1;
    
61. 
    
62.         }
    
63.         return (ACC);
    
64. }
    
65. void write_1302(uchar add,uchar dat)
    
66. {
    
67. 
    
68.         RST=0;
    
69.         SCLK=0;
    
70.         RST=1;
    
71.         write_byte(add);
    
72.         write_byte(dat);
    
73.         SCLK=1;
    
74.         RST=0;
    
75. }
    
76. uchar read_1302(uchar add)
    
77. {
    
78.         uchar temp;
    
79.         RST=0;
    
80.         SCLK=0;
    
81.         RST=1;
    
82.         write_byte(add);
    
83.         temp=read_byte();
    
84.         SCLK=1;
    
85.         RST=0;
    
86.         return(temp);
    
87. }
    
88. uchar BCD_Decimal(uchar bcd)
    
89. {
    
90. uchar Decimal;
    
91. Decimal=bcd>>4;
    
92. return(Decimal=Decimal*10+(bcd&=0x0F));
    
93. }
    
94. 
    
95. uchar Decimal_BCD(uchar dec)
    
96. {
    
97.   uchar bcd;
    
98.   bcd=((dec%10)&0x0f)|(((dec/10)<<4)&0xf0);
    
99.   return bcd;
    
100. }
     
101. 
     
102. 
     
103. 
     
104. void ds1302_init()
     
105. {
     
106. RST=0;
     
107. SCLK=0;
     
108. write_1302(0x8e,0x00);          //關寫保護
     
109. 
     
110. write_1302(0xc0,0xfe);         
     
111. write_1302(0xc2,0xff);
     
112.         
     
113. write_1302(0x80,0x00);  //寫初始sec
     
114. write_1302(0x82,0x10);        //寫初始min
     
115. write_1302(0x84,0x18);         //寫初始hour
     
116.         
     
117. write_1302(0x8e,0x80);        //開寫保護
     
118. 
     
119. }
     
120. 
     
121. 
     
122. 
     
123. 
     
124. void display()
     
125. {
     
126.         
     
127.     switch(key)
     
128.         {
     
129.         case 0: c[0]=led[hour/10];
     
130.                         c[1]=led[hour%10];
     
131.                         c[2]=led[min/10];
     
132.                     c[3]=led[min%10];
     
133.                         break;
     
134. 
     
135.         case 1:        if(S_flag==0)   
     
136.             {     
     
137.                         c[0]=led[hour/10];
     
138.                         c[1]=led[hour%10];
     
139.             }   
     
140.             else   
     
141.             {
     
142.                         c[0]=0xff;
     
143.                         c[1]=0xff;
     
144.             }   
     
145.                         
     
146.                         c[2]=led[min/10];
     
147.                         c[3]=led[min%10];
     
148.                         break;
     
149. 
     
150.         case 2:        c[0]=led[hour/10];
     
151.                         c[1]=led[hour%10];
     
152.                
     
153.                 if(S_flag==0)   
     
154.             {     
     
155.                         c[2]=led[min/10];
     
156.                         c[3]=led[min%10];
     
157.             }   
     
158.             else   
     
159.             {
     
160.                         c[2]=0xff;
     
161.                         c[3]=0xff;
     
162.             }  
     
163.                         break;         
     
164. 
     
165.         }                                       
     
166. }
     
167.         
     
168. 
     
169. void init()
     
170. {
     
171.         TMOD=0x01;
     
172.         TH0=0xfc;     //定時1ms   
     
173.     TL0=0x18;
     
174.         EA=1;
     
175.         ET0=1;
     
176.         TR0=1;
     
177.         S5=0;
     
178. }
     
179. 
     
180. 
     
181. void cmg(void)//數碼管鎖存函數
     
182. {
     
183.         dula=1;
     
184.         P0=0x00;
     
185.         dula=0;
     
186.         wela=1;
     
187.         P0=0x00;
     
188.         wela=0;
     
189. }
     
190. 
     
191. 
     
192. 
     
193. void keyscan()
     
194. {
     
195. 
     
196.         if(key1==0)//key1為功能鍵
     
197.         {
     
198.         delay(2);
     
199.         if(key1==0)
     
200.         {
     
201.         //while(!key1);
     
202.         for(i=0;((i<10)&&(key1==0));i++)          //檢測按鍵釋放
     
203.     {
     
204.     delay(1);
     
205.     }
     
206.         key++;
     
207.         
     
208.         if(key>2)
     
209.         key=0;
     
210.         
     
211.         if(key!=0)
     
212.         {
     
213. 
     
214.         switch(key)
     
215.         {
     
216.         
     
217.         case 1:  
     
218.                  if(key2==0)                         //調時
     
219.                  delay(2);
     
220.                          if(key2==0)
     
221.                          {
     
222.                            
     
223.                                 for(i=0;((i<10)&&(key2==0));i++)           //檢測按鍵釋放
     
224.                                 {
     
225.                                 delay(1);
     
226.                                 }
     
227.                         
     
228.                             hour1=hour;
     
229.                                 hour1++;
     
230.                                 if(hour1>23)
     
231.                                 hour1=0;
     
232.                                  
     
233.                                 temp=Decimal_BCD(hour1);
     
234.                                 //temp=(hour1)/10*16+(hour1)%10;
     
235.                                write_1302(0x8e,0x00);
     
236.                                write_1302(0x84,temp);
     
237.                               write_1302(0x8e,0x80);                                 
     
238.                          }
     
239.         
     
240.                          if(key3==0)                        
     
241.                  delay(2);
     
242.                          if(key3==0)
     
243.                          {
     
244.                            
     
245.                                 for(i=0;((i<10)&&(key3==0));i++)                   //檢測按鍵釋放
     
246.                                 {
     
247.                                 delay(1);
     
248.                                 }
     
249.                 hour1=hour;
     
250.                                 hour1--;
     
251.                                 if(hour1<0)
     
252.                                 hour1=23;
     
253.                            
     
254.                                  //temp=Decimal_BCD(hour1);
     
255.                                 temp=(hour1)/10*16+(hour1)%10;
     
256.                                write_1302(0x8e,0x00);
     
257.                                write_1302(0x84,temp);
     
258.                               write_1302(0x8e,0x80);
     
259.                                                                  
     
260.                          }
     
261.                
     
262.                          break;
     
263. 
     
264.         case 2:  if(key2==0)                         //調分
     
265.                  delay(2);
     
266.                          if(key2==0)
     
267.                          {
     
268.                                    for(i=0;((i<10)&&(key2==0));i++)
     
269.                {
     
270.                 delay(1);
     
271.                }
     
272.                                 if(min<59)
     
273.                                 min++;
     
274.                                 else
     
275.                                 min=0;
     
276.                                 //temp=(min)/10*16+(min)%10;
     
277.                                  temp=Decimal_BCD(min);
     
278.                              write_1302(0x8e,0x00);
     
279.                                write_1302(0x82,temp);
     
280.                     write_1302(0x80,0x00);          //miao復位
     
281.                                write_1302(0x8e,0x80);                                         
     
282.                          }
     
283.                
     
284. 
     
285.                          if(key3==0)                        
     
286.                  delay(2);
     
287.                          if(key3==0)
     
288.                          {
     
289.                             for(i=0;((i<10)&&(key3==0));i++)
     
290.                 {
     
291.                 delay(1);
     
292.                 }
     
293.                                 if(min>0)
     
294.                                 min--;
     
295.                                 else
     
296.                                 min=59;
     
297.                                 temp=(min)/10*16+(min)%10;
     
298.                                  //temp=Decimal_BCD(min);
     
299.                              write_1302(0x8e,0x00);
     
300.                                write_1302(0x82,temp);
     
301.                                 write_1302(0x80,0x00);          //miao復位
     
302.                                write_1302(0x8e,0x80);                                 
     
303.                          }
     
304. 
     
305.                         break;
     
306.         }
     
307.          
     
308.    }
     
309.    }
     
310.    }
     
311. }
     
312.                
     
313.            
     
314.                   
     
315. 
     
316. void main()
     
317. {
     
318. 
     
319.     cmg();//數碼管鎖存 (關閉開發板數碼管)
     
320.         ds1302_init();
     
321.         init();
     
322.         while(1)
     
323.         {
     
324.           keyscan();
     
325.           display();
     
326.     }
     
327. }
     
328. 
     
329. 
     
330. void timer0() interrupt 1
     
331. {
     
332.     TH0=0xfc;     //定時1ms   
     
333.     TL0=0x18;
     
334.     //TL0 = (65536-1932)/256;        //設置定時初值                10ms
     
335.     //TH0 = (65536-1932)%256;
     
336.         //TH0=0xfb;     //定時ms   
     
337.      //TL0=0x74;
     
338.         /*t++;
     
339.         if(t==255)
     
340.         {
     
341.             t=0;
     
342.                 S5=!S5;
     
343.         }
     
344.          */
     
345.         
     
346.         d++;
     
347.         if(d==20)
     
348.         {
     
349.         d=0;
     
350.     write_1302(0x8e,0x00);
     
351.         //sec = BCD_Decimal(read_1302(0x81));
     
352.         min = BCD_Decimal(read_1302(0x83));
     
353.         hour = BCD_Decimal(read_1302(0x85));
     
354.         write_1302(0x8e,0x80);
     
355.         }
     
356.         
     
357.         milsec++;
     
358.         if(milsec==440)
     
359.         {
     
360.                 milsec=0;
     
361.                 S_flag=!S_flag;
     
362.                 S5=!S5;
     
363.         }
     
364.         
     
365.     if(k==4)  
     
366.     k=0;   
     
367.     P0=c[k];     
     
368.     P2=b[k++];      
     
369.     delay(1);     
     
370.     P2=0xff;
     
371. }

復制代碼

---

作者: madell    時間: 2021-9-26 12:29
寫入數據適當加延時或空操作，太快芯片反應不過來錯誤。

---

作者: wdmcp    時間: 2021-9-26 15:10

madell 發表于 2021-9-26 12:29
寫入數據適當加延時或空操作，太快芯片反應不過來錯誤。

其實我也覺得可能是這個節奏上有問題，尤其是顯示刷新的太快。

---

作者: glinfei    時間: 2021-9-26 16:45
能否把寫函數的這三句： IO=ACC0;  SCLK=0; SCLK=1;順序改一下再加個延時，改為：  SCLK=0;  IO=ACC0;SCLK=1;_nop_(); 或者你再看看手冊，按你寫的時序，延時不夠。

---

作者: Y_G_G    時間: 2021-9-26 17:22
樓上已經有人說了,在讀寫時鐘間增加延時
可以在調用函數時先讓時鐘線低電平SCLK=0;
這樣的話,DS1302的SDA就會經歷一個上升沿和一個下降沿,也就不用在乎它是上升沿寫入還是下降沿寫入了

IO=ACC0;
SCLK=1;
_nop_();
SCLK=0;
_nop_();
ACC=ACC>>1;
_nop_();

---

作者: 188610329    時間: 2021-9-26 20:48
那么多人給你分析了代碼，我就不看你的代碼了， 就提幾個關鍵的時序，
RST = 0    =>  RST =1     手冊上要求最少 4us 間隔，實際測試 2us 的間隔是有必要的。
CLK = 0   =>   RST =1     手冊上要求最少2us 間隔  實際測試最少 0.3us 是有必要的。
在STC8系列單片機， 24MHz 下。
IO = 0  =>   IO = 1     如IO有上拉電阻， 可在 IO = 1 后 立刻 CLK = 1
如沒有上拉電阻，  IO = 1 后  最少 3個 NOP 才可以 CLK = 1
IO = 1   =>   IO =0     無論有沒有上拉電阻，  IO =0 后 都可以立刻  CLK = 1

---

作者: wdmcp    時間: 2021-9-26 23:17
感謝各位的指點，我再看下。單片機水平還很菜，不過也在努力吧。

---

作者: wdmcp    時間: 2021-10-5 12:18
找到問題了，不是1302寫不進去時間，是按鍵掃描函數有問題。。按下設置后，再次掃描按鍵函數時，因為檢測不到按鍵按下，所以進不去函數了，因此也無法掃描到加減語句，修改if嵌套就好了。但是現在加減還是有點卡頓，需要慢一點按，偶爾不太靈，不過還能接受吧。

---

作者: wdmcp    時間: 2021-10-5 12:47
按鍵卡頓，把keyscan()函數放中斷里面，設置一個合理的掃描時間，靈敏度提高，有改善。

---

作者: lkc8210    時間: 2021-10-5 15:51

wdmcp 發表于 2021-10-5 12:47
按鍵卡頓，把keyscan()函數放中斷里面，設置一個合理的掃描時間，靈敏度提高，有改善。

中斷里不要放太多東西
不要用太長(>1ms)的delay
貼段代碼讓你參考一下

1. void keyscan()
   
2. {static u8 Delay_XD;//靜態局部變數,離開函數后保持數值
   
3. bit Key_Add, Key_Dec;//局部變數,離開函數后清零
   
4.         if(!key1 || !key2 || !key3)//有鍵按下
   
5.         {
   
6.                 if(Delay_XD<0xFF)Delay_XD++;//消抖延時并限制溢出
   
7.                 if(Delay_XD == 250)//延時250個周期
   
8.                 {
   
9.                         if(!key1)//功能鍵按下
   
10.                         {
    
11.                                 key++;
    
12.                                 if(key>2)key=0;
    
13.                         }
    
14.                         if(!key2)//加鍵按下
    
15.                         {
    
16.                                 Key_Add = 1;//加標志位置1
    
17.                         }
    
18.                         if(!key3)//減鍵按下
    
19.                         {
    
20.                                 Key_Dec = 1;//減標志位置1
    
21.                         }                       
    
22.                 }
    
23.         }else{
    
24.                 Delay_XD = 0;//沒有鍵按下清零
    
25.         }
    
26.         switch(key)
    
27.         {
    
28.                 case 1:
    
29.                         if(Key_Add)
    
30.                         {
    
31.                                 hour1=hour;
    
32.                                 hour1++;
    
33.                                 if(hour1>23)
    
34.                                         hour1=0;
    
35. 
    
36.                                 temp=Decimal_BCD(hour1);
    
37.                                 //temp=(hour1)/10*16+(hour1)%10;
    
38.                                 write_1302(0x8e,0x00);
    
39.                                 write_1302(0x84,temp);
    
40.                                 write_1302(0x8e,0x80);
    
41.                         }
    
42. 
    
43.                         if(Key_Dec)
    
44.                         {
    
45.                                 hour1=hour;
    
46.                                 hour1--;
    
47.                                 if(hour1<0)
    
48.                                         hour1=23;
    
49. 
    
50.                                 //temp=Decimal_BCD(hour1);
    
51.                                 temp=(hour1)/10*16+(hour1)%10;
    
52.                                 write_1302(0x8e,0x00);
    
53.                                 write_1302(0x84,temp);
    
54.                                 write_1302(0x8e,0x80);
    
55.                         }
    
56.                         break;
    
57. 
    
58.                 case 2:
    
59.                         if(Key_Add)
    
60.                         {
    
61.                                 if(min<59)
    
62.                                         min++;
    
63.                                 else
    
64.                                         min=0;
    
65.                                 //temp=(min)/10*16+(min)%10;
    
66.                                 temp=Decimal_BCD(min);
    
67.                                 write_1302(0x8e,0x00);
    
68.                                 write_1302(0x82,temp);
    
69.                                 write_1302(0x80,0x00);          //miao復位
    
70.                                 write_1302(0x8e,0x80);
    
71.                         }
    
72. 
    
73.                         if(Key_Dec)
    
74.                         {
    
75.                                 if(min>0)
    
76.                                         min--;
    
77.                                 else
    
78.                                         min=59;
    
79.                                 temp=(min)/10*16+(min)%10;
    
80.                                 //temp=Decimal_BCD(min);
    
81.                                 write_1302(0x8e,0x00);
    
82.                                 write_1302(0x82,temp);
    
83.                                 write_1302(0x80,0x00);          //miao復位
    
84.                                 write_1302(0x8e,0x80);
    
85.                         }
    
86.                         break;
    
87.                
    
88.                 default:
    
89.                         break;
    
90.         }
    
91. }

復制代碼

---

作者: wdmcp    時間: 2021-10-5 20:10

lkc8210 發表于 2021-10-5 15:51
中斷里不要放太多東西
不要用太長(>1ms)的delay
貼段代碼讓你參考一下

謝謝熱心的回復。

---

作者: 名字不是重點    時間: 2021-10-7 11:57
判斷問題要精準！
1302能走時，說明初始化正常，說明寫入時間正常，說明寫入代碼沒問題。不能設置時間，就去查按鍵代碼了。

什么延時啊、節奏啊、中斷啊、、、都是空的！除非你初始化用的不是與設置時間是2套寫入代碼。。

---

作者: wdmcp    時間: 2021-10-8 18:06

名字不是重點 發表于 2021-10-7 11:57
判斷問題要精準！
1302能走時，說明初始化正常，說明寫入時間正常，說明寫入代碼沒問題。不能設置時間，就 ...

對，排查問題思路要清晰，我就有點糊涂了。開始以為是定時器讀取頻率太快，可能導致寫入時間出問題，直到增加延時還不行，我才看出按鍵函數有大漏洞。。

---

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

Powered by Discuz! X3.1

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

1024手机基地看电影