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

<kbd id="yai8i"></kbd>

<input id="yai8i"><samp id="yai8i"></samp></input><bdo id="yai8i"><del id="yai8i"></del></bdo>

<code id="yai8i"></code>

<tfoot id="yai8i"><abbr id="yai8i"></abbr></tfoot>

<optgroup id="yai8i"><tfoot id="yai8i"></tfoot></optgroup>

標題: 單片機學習：時鐘功能加計數(shù)功能顯示源碼 [打印本頁]

---

作者: 冇妖氣    時間: 2019-11-27 08:33
標題: 單片機學習：時鐘功能加計數(shù)功能顯示源碼


初學單片機，用的是慧凈電子的HL-1開發(fā)板，七拼八湊的組成了通過LCD1602顯示時間及工作計數(shù)功能，按鍵可以實現(xiàn)屏幕內(nèi)容切換。源碼分享給大家一起討論優(yōu)化。界面顯示注釋： JS： 累計工作次數(shù)； CS ：單次排量常數(shù)（可以通過按鍵設置）；PL：累計排量總數(shù)(等于JS*CS)。
按鍵注釋： S1：設置按鍵，時間顯示界面可以設置時分秒，年月日，計數(shù)功能界面可以設置單次排量常數(shù)CS；
                 S2：數(shù)值加鍵，設置界面可以對對應位置數(shù)值進行加操作；
                 S3：數(shù)值減鍵，設置界面可以對對應位置數(shù)值進行減操作；
                 S4:顯示界面切換按鍵，在時間顯示和工作計數(shù)界面來回切換；
                 S5：模擬工作狀態(tài)下的閥門開關信號。接收一次低電平信號，計數(shù)一次。
代碼如下：

1. #include<reg52.h>
   
2. #include<intrins.h>
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. 
   
6. // 定義4個鍵盤按鍵
   
7. sbit s1=P3^0; //功能鍵
   
8. sbit s2=P3^1; //加鍵
   
9. sbit s3=P3^2; //減鍵
   
10. sbit s4=P3^3; //顯示切換鍵
    
11. sbit s5=P3^6; //模擬信號鍵
    
12. sbit rd=P3^7;
    
13. 
    
14. sbit dula=P2^6;
    
15. sbit wela=P2^7;
    
16. 
    
17. sbit lcden=P2^2;
    
18. sbit rs=P2^0;
    
19. sbit rw=P2^1;
    
20. 
    
21. 
    
22. 
    
23. 
    
24. // DS1302操作
    
25. sbit sclk=P1^1;          //串行時鐘
    
26. sbit IO=P1^0;  //數(shù)據(jù)輸入輸出
    
27. sbit rst=P1^2;         //復位腳
    
28. 
    
29. uchar s1num,s2num,s3num;           //s1num時鐘功能調(diào)整，flag1時鐘調(diào)整狀態(tài)標志，count工作次數(shù)，counts排水量，s2num設置切換屏幕，s3num設置常數(shù)
    
30. int miao,shi,fen,nian,yue,ri,week;
    
31. int x1,x2,x3;
    
32. unsigned long count;
    
33. unsigned long counts;
    
34. x3=0;
    
35. /*//星期字表
    
36. uchar code table1[]="SUN";
    
37. uchar code table2[]="MON";
    
38. uchar code table3[]="TUE";
    
39. uchar code table4[]="WED";
    
40. uchar code table5[]="THU";
    
41. uchar code table6[]="FRI";
    
42. uchar code table7[]="SAT";
    
43. */
    
44. //延時函數(shù)
    
45. void delayms(uint z)
    
46. {
    
47.         uint x,y;
    
48.         for(x=z;x>0;x--)
    
49.                 for(y=110;y>0;y--);
    
50. }
    
51. //關閉數(shù)碼管函數(shù)
    
52. void cmg88()
    
53. {
    
54.         dula=1;
    
55.         P0=0x00;
    
56.         dula=0;
    
57. }
    
58. 
    
59. //液晶寫命令函數(shù)
    
60. void write_com(uchar com)
    
61. {
    
62.         rs=0;
    
63.         lcden=0;
    
64.         P0=com;
    
65.         delayms(5);
    
66.         lcden=1;
    
67.         delayms(5);
    
68.         lcden=0;
    
69. }
    
70. 
    
71. //液晶寫數(shù)據(jù)函數(shù)
    
72. void write_date(uchar date)
    
73. {
    
74.         rs=1;
    
75.         lcden=0;
    
76.         P0=date;
    
77.         delayms(5);
    
78.         lcden=1;
    
79.         delayms(5);
    
80.         lcden=0;
    
81. }
    
82. 
    
83. //向1302寫一個字節(jié)數(shù)據(jù)
    
84. void write1302(uchar dat)
    
85. {
    
86.         uchar i;
    
87.         for(i=0;i<8;i++)
    
88.                 {       
    
89.                         sclk=0;
    
90.                         IO=dat&0x01;
    
91.                         dat=dat>>1;
    
92.                         sclk=1;
    
93.                 }
    
94. }
    
95. 
    
96. //根據(jù)命令，向1302寫一個字節(jié)數(shù)據(jù)
    
97. void writeset1302(uchar cmd,uchar dat)
    
98. {
    
99.         rst=0;
    
100.         _nop_();
     
101.         sclk=0;
     
102.         _nop_();
     
103.         rst=1;
     
104.         _nop_();
     
105.         write1302(cmd);
     
106.         write1302(dat);
     
107.         sclk=1;
     
108.         rst=0;
     
109.         IO=1;
     
110. }
     
111. 
     
112. //向1302讀一個字節(jié)數(shù)據(jù)
     
113. uchar read1302(uchar cmd)
     
114. {
     
115.         uchar i,value;
     
116.        
     
117.         rst=0;
     
118.         _nop_();
     
119.         sclk=0;
     
120.         _nop_();
     
121.         rst=1;
     
122.         _nop_();
     
123.         write1302(cmd);
     
124.         for(i=0;i<8;i++)
     
125.         {
     
126.                 value=value>>1;
     
127.                 sclk=0;
     
128.                 if(IO)
     
129.                 value=value|0x80;
     
130.                 sclk=1;
     
131.                 }
     
132.                 rst=0;
     
133.                 sclk=0;
     
134.                 _nop_();
     
135.                 sclk=1;
     
136.                 IO=1;
     
137.        
     
138.         return value;
     
139. }
     
140. 
     
141. //根據(jù)命令向1302讀一個字節(jié)數(shù)據(jù)
     
142. uchar readset1302(uchar cmd)
     
143. {
     
144.         uchar dat;
     
145.         rst=0;
     
146.         sclk=0;
     
147.         rst=1;
     
148.         write1302(cmd);
     
149.         dat=read1302(cmd);
     
150.         sclk=1;
     
151.         rst=0;
     
152.         return(dat);
     
153. }
     
154. 
     
155. // 初始化1302
     
156. void init1302()
     
157. {
     
158. //        unsigned char flag;
     
159.    
     
160. //   flag= readset1302(0x81);
     
161. //        if(flag&0x80)       
     
162. //        {      //判斷時鐘芯片是否關閉
     
163.      writeset1302(0x8E,0x00);                 //根據(jù)寫狀態(tài)寄存器命令字，寫入不保護指令
     
164.            writeset1302(0x80,0x56);   //根據(jù)寫秒寄存器命令字，寫入秒的初始值
     
165.         writeset1302(0x82,0x59);   //根據(jù)寫分寄存器命令字，寫入分的初始值
     
166.         writeset1302(0x84,0x23); //根據(jù)寫小時寄存器命令字，寫入小時的初始值
     
167.         writeset1302(0x86,0x31); //根據(jù)寫日寄存器命令字，寫入日的初始值
     
168.         writeset1302(0x88,0x12); //根據(jù)寫月寄存器命令字，寫入月的初始值
     
169.         writeset1302(0x8c,0x18);  //根據(jù)寫年寄存器命令字，寫入年的初始值
     
170.         writeset1302(0x90,0xa5);                //打開充電功能 選擇2K電阻充電方式
     
171.         writeset1302(0x8E,0x80);                           //根據(jù)寫狀態(tài)寄存器命令字，寫入保護指令
     
172. //        }
     
173. }         
     
174. //時分秒函數(shù)
     
175. void write_sfm(uchar add,uchar dat)
     
176. {
     
177.         uchar gw,sw;
     
178.         gw=dat%16;
     
179.         sw=dat/16;
     
180.         write_com(0x80+0x40+add);
     
181.         write_date(0x30+sw);
     
182.         write_date(0x30+gw);
     
183. }
     
184. 
     
185. //年月日函數(shù)
     
186. void write_nyr(uchar add,uchar dat)
     
187. {
     
188.         uchar gw,sw;
     
189.         gw=dat%16;
     
190.         sw=dat/16;
     
191.         write_com(0x80+add);
     
192.         write_date(0x30+sw);
     
193.         write_date(0x30+gw);
     
194. }
     
195. 
     
196. //星期函數(shù)
     
197. /*void write_week(uchar xq)
     
198. {
     
199.         uchar x;
     
200.         write_com(0x80+12);
     
201.         switch(xq)
     
202.         {
     
203.                 case 1:
     
204.                         for(x=0;x<3;x++)
     
205.                         {
     
206.                                 write_date(table1[x]);
     
207.                         }
     
208.                         break;
     
209.                 case 2:
     
210.                         for(x=0;x<3;x++)
     
211.                         {
     
212.                                 write_date(table2[x]);
     
213.                         }
     
214.                         break;
     
215.                 case 3:
     
216.                         for(x=0;x<3;x++)
     
217.                         {
     
218.                                 write_date(table3[x]);
     
219.                         }
     
220.                         break;
     
221.                 case 4:
     
222.                         for(x=0;x<3;x++)
     
223.                         {
     
224.                                 write_date(table4[x]);
     
225.                         }
     
226.                         break;
     
227.                 case 5:
     
228.                         for(x=0;x<3;x++)
     
229.                         {
     
230.                                 write_date(table5[x]);
     
231.                         }
     
232.                         break;
     
233.                 case 6:
     
234.                         for(x=0;x<3;x++)
     
235.                         {
     
236.                                 write_date(table6[x]);
     
237.                         }
     
238.                         break;
     
239.                 case 7:
     
240.                         for(x=0;x<3;x++)
     
241.                         {
     
242.                                 write_date(table7[x]);
     
243.                         }
     
244.                         break;
     
245.         }
     
246.                 write_com(0x80+12);
     
247. } */
     
248. //寫計工作次數(shù)函數(shù)
     
249. void write_JS(uchar add,unsigned long dat)
     
250. {
     
251.         uchar x,y,z,j,k;
     
252.         x=dat/10000;
     
253.         y=(dat%10000)/1000;
     
254.         z=(dat%1000)/100;
     
255.         j=(dat%100)/10;
     
256.         k=dat%10;
     
257.         write_com(0x80+add);
     
258.         write_date(0x30+x);
     
259.         write_date(0x30+y);
     
260.         write_date(0x30+z);
     
261.         write_date(0x30+j);
     
262.         write_date(0x30+k);       
     
263. }
     
264. //寫單次排量函數(shù)
     
265. void write_CS(uchar add,uchar dat)
     
266. {
     
267.         uchar gw,sw;
     
268.         gw=dat%10;
     
269.         sw=dat/10;
     
270.         write_com(0x80+add);
     
271.         write_date(0x30+sw);
     
272.         write_date(0x30+gw);       
     
273. }
     
274. //寫總排量函數(shù)
     
275. void write_PL(uchar add,unsigned long dat)
     
276. {
     
277.         uchar x,y,z,j,k;
     
278. //        a=dat/1000000;
     
279. //        b=(dat%1000000)/100000;
     
280.         x=(dat%100000)/10000;
     
281.         y=(dat%10000)/1000;
     
282.         z=(dat%1000)/100;
     
283.         j=(dat%100)/10;
     
284.         k=dat%10;
     
285.         write_com(0x80+0x40+add);
     
286. //        write_date(0x30+a);
     
287. //        write_date(0x30+b);
     
288.         write_date(0x30+x);
     
289.         write_date(0x30+y);
     
290.         write_date(0x30+z);
     
291.         write_date(0x30+j);
     
292.         write_date(0x30+k);       
     
293. }
     
294. //液晶初始化
     
295. void init()
     
296. {
     
297.        
     
298.         rd=0;
     
299.         dula=0;
     
300.         wela=0;
     
301.         rw=0;
     
302.         lcden=0;
     
303.         miao=0;
     
304.         fen=0;
     
305.         shi=0;
     
306.         week=1;
     
307.         nian=0;
     
308.         yue=0;
     
309.         ri=0;
     
310.         s1num=0;
     
311.         s2num=0;
     
312. 
     
313.         write_com(0x38);
     
314.         write_com(0x0c);
     
315.         write_com(0x06);
     
316.         write_com(0x01);
     
317. 
     
318.         write_com(0x80+1);//年份前兩位固定顯示20
     
319.         write_date('2');
     
320.         write_date('0');
     
321.         delayms(5);
     
322. 
     
323.         write_com(0x80+5);
     
324.         write_date('-');
     
325.         delayms(5);
     
326.         write_com(0x80+8);
     
327.         write_date('-');
     
328.         delayms(5);
     
329. 
     
330.         write_com(0x80+0x40+4);
     
331.         write_date(':');
     
332.         delayms(5);
     
333.         write_com(0x80+0x40+7);
     
334.         write_date(':');
     
335.         delayms(5);
     
336. }
     
337. 
     
338. //鍵盤設置操作
     
339. void keyscan()
     
340. {
     
341.         if(s1==0&&s2num==0) //時鐘調(diào)整功能鍵,并且不處于計數(shù)界面
     
342.         {
     
343.         delayms(5);
     
344.         if(s1==0&&s2num==0)
     
345.         {
     
346.                 s1num++;
     
347.                
     
348.                 while(!s1);
     
349.                 switch(s1num)
     
350.                 {
     
351.                         case 1:
     
352.                         write_com(0x80+0x40+9);
     
353.                         write_com(0x0f);
     
354.                         break;
     
355.                        
     
356.                         case 2:
     
357.                         write_com(0x80+0x40+6);
     
358.                         break;
     
359. 
     
360.                         case 3:
     
361.                         write_com(0x80+0x40+3);
     
362.                         break;
     
363. 
     
364.                         case 4:
     
365.                         write_com(0x80+14);
     
366.                         break;
     
367. 
     
368.                         case 5:
     
369.                         write_com(0x80+10);
     
370.                         break;
     
371. 
     
372.                         case 6:
     
373.                         write_com(0x80+7);
     
374.                         break;
     
375. 
     
376.                         case 7:
     
377.                         write_com(0x80+4);
     
378.                         break;
     
379. 
     
380.                         case 8:                       
     
381.                         s1num=0;
     
382.                         writeset1302(0x8e,0x00);//功能鍵停止后，將設置的當前值存入1302
     
383.                         writeset1302(0x80,miao);
     
384.                         writeset1302(0x82,fen);
     
385.                         writeset1302(0x84,shi);
     
386.                 //        writeset1302(0x8a,week);
     
387.                         writeset1302(0x86,ri);
     
388.                         writeset1302(0x88,yue);
     
389.                         writeset1302(0x8c,nian);
     
390.                         writeset1302(0x8e,0x80);
     
391.                         write_com(0x0c);
     
392.                         break;
     
393.                 }
     
394.         }
     
395.         }       
     
396.         if(s1num!=0&&s2num==0)  
     
397.         {
     
398.                 if(s2==0)        //設置加鍵
     
399.                 {
     
400.                 delayms(5);
     
401.                 if(s2==0)
     
402.                 {
     
403.                         while(!s2);
     
404.                         switch(s1num)
     
405.                         {
     
406.                                 case 1:
     
407.                                 x1=miao%16;
     
408.                                 x2=miao/16;
     
409.                                 x1++;
     
410.                                 if(x1==10)
     
411.                                 {
     
412.                                         x1=0;
     
413.                                         x2++;
     
414.                                         if(x2>=6)
     
415.                                         x2=0;
     
416.                                 }
     
417.                                 miao=x1+x2*16;
     
418.                                 write_sfm(8,miao);
     
419.                                 write_com(0x80+0x40+9);
     
420.                                 break;
     
421. 
     
422.                                 case 2:
     
423.                                 x1=fen%16;
     
424.                                 x2=fen/16;
     
425.                                 x1++;
     
426.                                 if(x1==10)
     
427.                                 {
     
428.                                         x1=0;
     
429.                                         x2++;
     
430.                                         if(x2>=6)
     
431.                                         x2=0;
     
432.                                 }
     
433.                                 fen=x1+x2*16;
     
434.                                 write_sfm(5,fen);
     
435.                                 write_com(0x80+0x40+6);
     
436.                                 break;
     
437. 
     
438.                                 case 3:
     
439.                                 x1=shi%16;
     
440.                                 x2=shi/16;
     
441.                                 x1++;
     
442.                                 if(x1==10)
     
443.                                 {
     
444.                                         x1=0;
     
445.                                         x2++;
     
446.                                 }
     
447.                                         if(x2>=2&&x1>=4)
     
448.                                         {
     
449.                                         x1=0;
     
450.                                         x2=0;
     
451.                                         }
     
452.                                 shi=x1+x2*16;
     
453.                                 write_sfm(2,shi);
     
454.                                 write_com(0x80+0x40+3);
     
455.                                 break;
     
456. 
     
457.                                 case 4:
     
458.                                 x1=week%10;
     
459.                                 x2=week/10;
     
460.                                 x1++;
     
461.                                 if(x1==8)
     
462.                                 x1=1;
     
463.                                 week=x2*10+x1;
     
464.                         //        write_week(week);
     
465.                         //        write_com(0x80+14);
     
466.                                 break;               
     
467. 
     
468.                                 case 5:
     
469.                                 x1=ri%16;
     
470.                                 x2=ri/16;
     
471.                                 x1++;
     
472.                                 if(x1==10)
     
473.                                 {
     
474.                                         x1=0;
     
475.                                         x2++;
     
476.                                 }
     
477.                                         if(x2==3&&x1==2)
     
478.                                          {
     
479.                                         x2=0;
     
480.                                         x1=0;
     
481.                                         }
     
482.                                 ri=x1+x2*16;
     
483.                                 write_nyr(9,ri);
     
484.                                 write_com(0x80+10);
     
485.                                 break;
     
486. 
     
487.                                 case 6:
     
488.                                 x1=yue%16;
     
489.                                 x2=yue/16;
     
490.                                 x1++;
     
491.                                 if(x2==1&&x1==3)
     
492.                                 {
     
493.                                         x1=1;
     
494.                                         x2=0;
     
495.                                 }
     
496.                                 if(x1==10)
     
497.                                 {
     
498.                                         x1=0;
     
499.                                         x2++;
     
500.                                 }
     
501.                                 yue=x1+x2*16;
     
502.                                 write_nyr(6,yue);
     
503.                                 write_com(0x80+7);
     
504.                                 break;
     
505. 
     
506.                                 case 7:
     
507.                                 x1=nian%16;
     
508.                                 x2=nian/16;
     
509.                                 x1++;
     
510.                                 if((x2==9)&&(x1==10))
     
511.                                 {
     
512.                                         x1=0;
     
513.                                         x2=0;
     
514.                                 }
     
515.                                 if(x1==10)
     
516.                                 {
     
517.                                         x2++;
     
518.                                         x1=0;
     
519.                                 }
     
520.                                 nian=x1+x2*16;
     
521.                                 write_nyr(3,nian);
     
522.                                 write_com(0x80+4);
     
523.                                 break;
     
524.                         }
     
525.                 }
     
526.                 }
     
527. 
     
528.                 if(s3==0&&s2num==0)
     
529.                 {                                                                                                                                                                                                                                                                                                         
     
530.                 delayms(5);
     
531.                 if(s3==0&&s2num==0)
     
532.                 {
     
533.                         while(!s3);
     
534.                         switch(s1num)
     
535.                         {
     
536.                                 case 1:
     
537.                                 x1=miao%16;
     
538.                                 x2=miao/16;
     
539.                                 x1--;
     
540.                                 if(x1==-1)
     
541.                                 {
     
542.                                 x1=9;
     
543.                                 x2--;
     
544.                                 if(x2==-1)
     
545.                                 x2=5;
     
546.                                 }
     
547.                                 miao=x1+x2*16;
     
548.                                 write_sfm(8,miao);
     
549.                                 write_com(0x80+0x40+9);
     
550.                                 break;
     
551. 
     
552.                                 case 2:
     
553.                                 x1=fen%16;
     
554.                                 x2=fen/16;
     
555.                                 x1--;
     
556.                                 if(x1==-1)
     
557.                                 {
     
558.                                 x1=9;
     
559.                                 x2--;
     
560.                                 if(x2==-1)
     
561.                                 x2=5;
     
562.                                 }
     
563.                                 fen=x1+x2*16;
     
564.                                 write_sfm(5,fen);
     
565.                                 write_com(0x80+0x40+6);
     
566.                                 break;
     
567. 
     
568.                                 case 3:
     
569.                                 x1=shi%16;
     
570.                                 x2=shi/16;
     
571.                                 x1--;
     
572.                                 if(x1==-1)
     
573.                                 {
     
574.                                 x1=9;
     
575.                                 x2--;
     
576.                                 if(x2==-1)
     
577.                                 {
     
578.                                 x2=2;
     
579.                                 x1=3;
     
580.                                 }
     
581.                                 }
     
582.                                 shi=x1+x2*16;
     
583.                                 write_sfm(2,shi);
     
584.                                 write_com(0x80+0x40+3);
     
585.                                 break;
     
586. 
     
587.                                 case 4:
     
588.                                 x1=(week)%16;
     
589.                                 x2=(week)/16;
     
590.                                 x1--;
     
591.                                 if(x1==0)
     
592.                                 x1=7;
     
593.                                 week=x1+x2*16;
     
594.                         //        write_week(week);
     
595.                         //        write_com(0x80+14);
     
596.                                 break;         
     
597. 
     
598.                                 case 5:
     
599.                                 x1=ri%16;
     
600.                                 x2=ri/16;
     
601.                                 x1--;
     
602.                                 if(x1==-1)
     
603.                                 {
     
604.                                         x1=9;
     
605.                                         x2--;
     
606.                                         if(x2==-1)
     
607.                                         {
     
608.                                         x1=1;
     
609.                                         x2=3;
     
610.                                         }
     
611.                                 }
     
612.                                 ri=x1+x2*16;
     
613.                                 write_nyr(9,ri);
     
614.                                 write_com(0x80+10);
     
615.                                 break;
     
616. 
     
617.                                 case 6:
     
618.                                 x1=yue%16;
     
619.                                 x2=yue/16;
     
620.                                 x1--;
     
621.                                 if((x2==1)&&(x1==-1))
     
622.                                 {
     
623.                                         x1=9;
     
624.                                         x2--;
     
625.                                 }
     
626.                                 if((x2==0)&&(x1==0))
     
627.                                 {
     
628.                                         x1=2;
     
629.                                         x2=1;
     
630.                                 }
     
631.                                 yue=x1+x2*16;
     
632.                                 write_nyr(6,yue);
     
633.                                 write_com(0x80+7);
     
634.                                 break;
     
635. 
     
636.                                 case 7:
     
637.                                 x1=nian%16;
     
638.                                 x2=nian/16;
     
639.                                 x1--;
     
640.                                 if(x1==-1)
     
641.                                 {
     
642.                                         x1=9;
     
643.                                         x2--;
     
644.                                         if(x2==-1)
     
645.                                         {
     
646.                                                 x1=9;
     
647.                                                 x2=9;
     
648.                                         }
     
649.                                 }
     
650.                                 nian=x1+x2*16;
     
651.                                 write_nyr(3,nian);
     
652.                                 write_com(0x80+4);
     
653.                                 break;
     
654.                         }
     
655.                 }
     
656.                 }
     
657.         }         
     
658. 
     
659.                 if(s3num==0&&s1num==0)        //切換屏幕
     
660.                 {
     
661.                 if(s4==0)
     
662.                 {
     
663.                 delayms(5);
     
664.                 if(s4==0)
     
665.                 {  
     
666.                 s2num++;
     
667.                 while(!s4)                               
     
668.                 {                       
     
669.                 if(s2num==1)
     
670.                 {
     
671.                 write_com(0x01);
     
672.                 write_com(0x80);
     
673.                 write_date('J');
     
674.                 write_com(0x80+1);
     
675.                 write_date('S');
     
676.                 write_com(0x80+2);
     
677.                 write_date(':');
     
678.                 write_com(0x80+4);
     
679.                 write_JS(3,count);
     
680.                
     
681.                
     
682.                
     
683.                 write_com(0x80+11);
     
684.                 write_date('C');
     
685.                 write_com(0x80+12);
     
686.                  write_date('S');
     
687.                 write_com(0x80+13);
     
688.                 write_date(':');
     
689.                 write_CS(14,x3);
     
690. 
     
691.                 write_com(0x80+0x40);
     
692.                 write_date('P');
     
693.                 write_com(0x80+0x40+1);
     
694.                 write_date('L');
     
695.                 write_com(0x80+0x40+2);
     
696.                 write_date(':');
     
697.                 counts=count*x3;
     
698.                 write_PL(3,counts);               
     
699.                 }
     
700.                 if(s2num==2)
     
701.                 {
     
702.                         s2num=0;
     
703.                         write_com(0x01);
     
704.                         write_com(0x80+1);//年份前兩位固定顯示20
     
705.                         write_date('2');
     
706.                         write_date('0');
     
707.                         delayms(5);
     
708.                
     
709.                         write_com(0x80+5);
     
710.                         write_date('-');
     
711.                         delayms(5);
     
712.                         write_com(0x80+8);
     
713.                         write_date('-');
     
714.                         delayms(5);
     
715.                
     
716.                         write_com(0x80+0x40+4);
     
717.                         write_date(':');
     
718.                         delayms(5);
     
719.                         write_com(0x80+0x40+7);
     
720.                         write_date(':');
     
721.                         delayms(5);
     
722.                 }
     
723.                 }
     
724.                 }
     
725.                 }
     
726.                 }
     
727.                 if(s2num==1&&s1num==0)
     
728.                 {
     
729.                         if(s1==0)
     
730.                         {
     
731.                                 delayms(5);
     
732.                                 if(s1==0)
     
733.                                 {
     
734.                                         s3num++;
     
735.                                         while(!s1)
     
736.                                         switch(s3num)
     
737.                                         {
     
738.                                                 case 1: write_com(0x80+15);
     
739.                                                                 write_com(0x0f);
     
740.                                                                 break;
     
741.                                                 case 2: s3num=0;
     
742.                                                                 write_com(0x0c);
     
743.                                                                 writeset1302(0x8e,0x00);
     
744.                                                                 writeset1302(0xc0,x3);
     
745.                                                                 writeset1302(0x8e,0x80);
     
746.                                                                 break;                                                                               
     
747.                                                 }
     
748.                                          }
     
749.                         }
     
750.                                
     
751.                         if(s3num!=0)
     
752.                         {
     
753.                                 if(s2==0)
     
754.                                 {
     
755.                                         delayms(100);
     
756.                                         if(s2==0)
     
757.                                         {       
     
758.                                
     
759.                                                 x3++;
     
760.                                                 _nop_();
     
761.                                                 if(x3==99)
     
762.                                                 x3=0;
     
763.                                        
     
764.                                         }
     
765.                                                 write_CS(14,x3);
     
766.                                         write_com(0x80+15);
     
767.                                         }
     
768.                                 if(s3==0)
     
769.                                 {
     
770.                                         delayms(100);
     
771.                                         if(s3==0)
     
772.                                         {
     
773.                                                 x3--;
     
774.                                                 _nop_();
     
775.                                                 if(x3==-1)
     
776.                                                 x3=99;
     
777.                                         }
     
778.                                                 write_CS(14,x3);
     
779.                                                 write_com(0x80+15);
     
780.                                         }
     
781.                                 }
     
782.                                 }
     
783.                 /*                if(s3num==0)
     
784.                                 {               
     
785.                                 if(s5==0)
     
786.                                 {
     
787.                                 delayms(100);
     
788.                                 if(s5==0)
     
789.                                 {
     
790.                                 while(!s5)
     
791.                                 {
     
792.                                 count=count+1;
     
793.                             counts=count*x3;
     
794.                                  if(s2num==1&&s3num==0)
     
795.                                  {
     
796.                                 write_JS(3,count);
     
797.                                 write_PL(3,counts);
     
798.                                 }
     
799.                                 }
     
800.                         }
     
801.                         }
     
802.                         }*/
     
803.                
     
804.                    if(s5==0)
     
805.                         {
     
806.                         delayms(100);
     
807.                         if(s5==0)
     
808.                         {
     
809.                                 while(!s5)
     
810.                                 {
     
811.                                 count=count+1;
     
812.                                 counts=count*x3;
     
813.                                          if(s2num==1&&s3num==0)
     
814.                                  {
     
815.                                 write_JS(3,count);
     
816.                                 write_PL(3,counts);
     
817.                                 }
     
818.                                 }
     
819.                                    }
     
820.                         }
     
821.         }
     
822.        
     
823. 
     
824. void main()
     
825. {
     
826.        
     
827.         cmg88();
     
828.         init();       
     
829.         init1302();
     
830.         while(1)
     
831.         {
     
832.                 keyscan();
     
833.                 if(s1num==0&&s2num==0)
     
834.                 {
     
835.                         miao=readset1302(0x81);
     
836.                         fen=readset1302(0x83);
     
837.                         shi=readset1302(0x85);
     
838.                         ri=readset1302(0x87);
     
839.                         yue=readset1302(0x89);
     
840.                         nian=readset1302(0x8d);
     
841.                         week=readset1302(0x8b);
     
842.                         write_sfm(8,miao);
     
843.                         write_sfm(5,fen);
     
844.                         write_sfm(2,shi);
     
845.                         write_nyr(9,ri);
     
846.                         write_nyr(6,yue);
     
847.                         write_nyr(3,nian);
     
848. //                        write_week(week);
     
849.                 }
     
850.         }
     
851. }

復制代碼

1302時鐘+1602+鍵盤.rar

2019-12-23 10:33 上傳

點擊文件名下載附件

下載積分: 黑幣 -5

101.51 KB, 下載次數(shù): 2, 下載積分: 黑幣 -5

---

作者: admin    時間: 2019-11-27 12:23
本帖需要重新編輯補全電路原理圖,源碼,詳細說明與圖片即可獲得100+黑幣(帖子下方有編輯按鈕)

---

作者: 冇妖氣    時間: 2019-11-29 14:03

admin 發(fā)表于 2019-11-27 12:23
本帖需要重新編輯補全電路原理圖,源碼,詳細說明與圖片即可獲得100+黑幣(帖子下方有編輯按鈕)

新手學習，用的HL-1的開發(fā)板，沒有電路原理圖

---

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

Powered by Discuz! X3.1

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

1024手机基地看电影

<dd id="ayumi"><noscript id="ayumi"></noscript></dd>

<strong id="ayumi"></strong>

<optgroup id="ayumi"><rt id="ayumi"></rt></optgroup>