坛友高手帮忙看看这个数码管程序写入后怎么是黑屏的。

motofanoranw

移植了一个数码管时钟程序，但写入后单片机没有反映，数码管黑屏请坛友给指导指导。

1. /*****************************************************************************************************
   
2. *******************************************头文件与宏定义*********************************************
   
3. *****************************************************************************************************/
   
4. #include <STC15.h>
   
5. #include <intrins.h>
   
6. #define        uchar unsigned char               
   
7. #define        uint unsigned int
   
8. /*****************************************************************************************************
   
9. ***********************************************ADC定义************************************************
   
10. *****************************************************************************************************/
    
11. sfr ADC_LOW2    =   0xBE;           //ADC低2位结果
    
12. #define ADC_POWER   0x80            //ADC电源控制位
    
13. #define ADC_FLAG    0x10            //ADC完成标志
    
14. #define ADC_START   0x08            //ADC起始控制位
    
15. #define ADC_SPEEDLL 0x00            //540个时钟
    
16. #define ADC_SPEEDL  0x20            //360个时钟
    
17. #define ADC_SPEEDH  0x40            //180个时钟
    
18. #define ADC_SPEEDHH 0x60            //90个时钟
    
19. /*****************************************************************************************************
    
20. ********************************************红外遥控定义**********************************************
    
21. *****************************************************************************************************/
    
22. #define Imax 14000
    
23. #define Imin 8000
    
24. #define Inum1 1450
    
25. #define Inum3 3000
    
26. #define Inum2 700
    
27. uchar f;
    
28. uchar IrOK;
    
29. unsigned long m,Tc;
    
30. uchar Im[4]={0x00,0x00,0x00,0x00};
    
31. /*****************************************************************************************************
    
32. **********************************************DS3231定义**********************************************
    
33. *****************************************************************************************************/       
    
34. uchar RTC_Data[7];
    
35. uchar RTC_Data1[7];
    
36. uchar RTC_Set_ID;
    
37. code uchar rtc_address[7]={0x00,0x01,0x02,0x04,0x05,0x03,0x06};
    
38. /*****************************************************************************************************
    
39. **********************************************DS18B20定义**********************************************
    
40. *****************************************************************************************************/       
    
41. #define DS1820_TIMEOUT (750/T0_RUNOUT)    // 12-bit resolution, 750ms MAX
    
42. #define DS_RESOLUTION   11//9,10,11,12
    
43. 
    
44. #if defined(USE_18B20)
    
45. unsigned char DS18B20_GetTemp( void );
    
46. unsigned char DelayXus(unsigned short n);
    
47. unsigned char DS18B20_Reset( void );
    
48. unsigned char DS18B20_ReadByte( void );
    
49. unsigned char DS18B20_WriteByte( unsigned char dat );
    
50. unsigned char DS18B20_InitSet( void );
    
51. #endif
    
52. 
    
53. #define  TEMPH   dstemperature.byte[0]       //存放温度值的高字节
    
54. #define  TEMPL    dstemperature.byte[1]       //存放温度值的低字节
    
55. 
    
56. #define DS_DELAY480US           8
    
57. #define DS_DELAY240US           4
    
58. #define DS_DELAY60US             1
    
59. #define DS_WAIT_PLUSE            100
    
60. 
    
61. #define DS_TH_REG     37
    
62. #define DS_TL_REG      0
    
63.    
    
64. #if(DS_RESOLUTION==9)
    
65.    #define DS_CONFIG_REG      0x1F
    
66. #elif(DS_RESOLUTION==10)
    
67.    #define DS_CONFIG_REG      0x3F
    
68. #elif(DS_RESOLUTION==11)
    
69.    #define DS_CONFIG_REG      0x5F  
    
70. #elif(DS_RESOLUTION==12)
    
71.    #define DS_CONFIG_REG      0x7F   
    
72. #else
    
73.    #error DS_RESOLUTION: 9 , 10 , 11 , 12
    
74. #endif
    
75. /*****************************************************************************************************
    
76. **********************************************标志位定义**********************************************
    
77. *****************************************************************************************************/
    
78. bit T0_Flag;                         //定时器0标志位
    
79. bit laba_flag;           //蜂鸣器标志位
    
80. bit set_flag;                         //设置显示标志位
    
81. bit RTC_Save_Flag;       //设置时间标志位
    
82. bit gk;                                      //光控标志位
    
83. /*****************************************************************************************************
    
84. **********************************************管脚定义************************************************
    
85. *****************************************************************************************************/
    
86. sbit IIC_SCL=P3^4;         //DS3231_SCL
    
87. sbit IIC_SDA=P3^3;         //DS3231_SDA
    
88. sbit hongwai=P3^1;   //红外接收数据输入端
    
89. sbit DQ=P3^5;   //DS18B20的数据口位
    
90. 
    
91. sbit key1=P3^2;                 //设置键
    
92. sbit key2=P5^4;                 //加键
    
93. sbit key3=P5^5;                 //减键
    
94. 
    
95. sbit laba=P2^7;                 //喇叭输出端
    
96. sbit D4=P1^1;                 //数码管位码
    
97. sbit D3=P1^2;                 //数码管位码
    
98. sbit D2=P2^6;                 //数码管位码
    
99. sbit D1=P1^0;                 //数码管位码
    
100. 
     
101. int ld;                                 //光控ADC用
     
102. uint temp[3];                 //光控ADC用
     
103. uchar code table[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e,0xff,0xbf,};       //共阳数码管
     
104.                                        
     
105. uchar code table1[]={0xC0,0xCF,0xA4,0x86,0x8B,0x92,0x90,0xC7,0x80,0x82,0x81,0x98,0xF0,0x8C,0xB0,0xB1};           //共阳数码管倒装
     
106.                                          
     
107. 
     
108. /*****************************************************************************************************
     
109. ******************************************定时器中断函数**********************************************
     
110. *****************************************************************************************************/
     
111. void Time1() interrupt 3
     
112. {
     
113.         static uchar timecount;
     
114.         TF1=0;
     
115.         TH1=0xff;
     
116.         TL1=256-110;
     
117.        
     
118.         timecount++;
     
119.         if(timecount>=5)
     
120.         {
     
121.                 timecount=0;
     
122.                 T0_Flag=1;
     
123.         }               
     
124.         if(laba_flag)
     
125.         {
     
126.                 laba=~laba;
     
127.         }
     
128.         else
     
129.         laba=1;
     
130. }
     
131. /*****************************************************************************************************
     
132. *******************************************ADC初始化函数**********************************************
     
133. *****************************************************************************************************/
     
134. void InitADC()
     
135. {
     
136.           P1ASF = 0x08;                        //Open channels ADC function 0000 1000 p1.3使用AD功能
     
137.         ADC_RES  = 0;                                   
     
138.         ADC_LOW2 = 0;
     
139.           ADC_CONTR = ADC_POWER | ADC_SPEEDLL;
     
140. }
     
141. /*****************************************************************************************************
     
142. *********************************************ADC处理函数**********************************************
     
143. *****************************************************************************************************/
     
144. void GetADCResult(unsigned char ch,unsigned int *value)
     
145. {
     
146.         ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ch | ADC_START;
     
147.     _nop_();                        //Must wait before inquiry
     
148.     _nop_();
     
149.     _nop_();
     
150.     _nop_();
     
151.     _nop_();                        //Must wait before inquiry
     
152.     _nop_();
     
153.     while(!(ADC_CONTR & ADC_FLAG));//Wait complete flag
     
154.     ADC_CONTR &= ~ADC_FLAG;         //Close ADC
     
155. 
     
156.         *value = 0;
     
157.         *value = ADC_RES;
     
158.         *value = ((*value)*4 + ADC_LOW2);               
     
159. }
     
160. /*****************************************************************************************************
     
161. **********************************************延时函数************************************************
     
162. *****************************************************************************************************/       
     
163. void Delayms(uint t)//@11.0592MHz
     
164. {
     
165.         uchar i;
     
166.         i=t;
     
167.         while(--i);
     
168. }
     
169. 
     
170. void Delay_xms(uint x)
     
171. {
     
172.         uchar  i,j;
     
173.         uint   t;
     
174.         for(t=x;t>0;t--)
     
175.          {
     
176.            i = 15;
     
177.              j = 90;
     
178.              do
     
179.              {
     
180.                  while(--j);
     
181.               } while(--i);
     
182.           }   
     
183. }
     
184. /*****************************************************************************************************
     
185. **********************************************显示函数************************************************
     
186. *****************************************************************************************************/       
     
187. void display()
     
188. {
     
189.         D1=0;
     
190.         P0=table[RTC_Data[2]/10];
     
191.         Delayms(4);
     
192.         P0=0xff;
     
193.         D1=1;
     
194. 
     
195.         D2=0;
     
196.         if(RTC_Data[0]/1%2==0) P0=table[RTC_Data[2]%10];
     
197.         else P0=table1[RTC_Data[2]%10];       
     
198.         Delayms(4);
     
199.         P0=0xff;
     
200.         D2=1;
     
201. 
     
202.         D3=0;
     
203.         if(RTC_Data[0]/1%2==0) P0=table1[RTC_Data[1]/10];
     
204.         else P2=table1[RTC_Data[1]/10];       
     
205.         Delayms(4);
     
206.         P0=0xff;
     
207.         D3=1;
     
208. 
     
209. 
     
210.         D4=0;
     
211.         P0=table1[RTC_Data[1]%10];
     
212.         Delayms(4);
     
213.         P0=0xff;
     
214.         D4=1;
     
215. }
     
216. /*****************************************************************************************************
     
217. **************************************显示小时函数*****设置用*****************************************
     
218. *****************************************************************************************************/       
     
219. void display_set_shi()
     
220. {
     
221.         D1=0;
     
222.         P0=0x91;
     
223.         Delayms(2);
     
224.         P0=0xff;
     
225.         D1=1;
     
226. 
     
227.         D2=0;
     
228.         P0=0xff;
     
229.         Delayms(2);
     
230.         P0=0xff;
     
231.         D2=1;
     
232. 
     
233.         D3=0;
     
234.         P0=table1[RTC_Data[2]/10];
     
235.         Delayms(2);
     
236.         P0=0xff;
     
237.         D3=1;
     
238. 
     
239.         D4=0;
     
240.         P0=table1[RTC_Data[2]%10];
     
241.         Delayms(2);
     
242.         P0=0xff;
     
243.         D4=1;
     
244. }
     
245. /*****************************************************************************************************
     
246. **************************************显示分钟函数*****设置用*****************************************
     
247. *****************************************************************************************************/
     
248. void display_set_fen()
     
249. {       
     
250.         D1=0;
     
251.         P0=table[15];
     
252.         Delayms(2);
     
253.         P0=0xff;
     
254.         D1=1;
     
255. 
     
256.         D2=0;
     
257.         P0=0xff;
     
258.         Delayms(2);
     
259.         P0=0xff;
     
260.         D2=1;
     
261. 
     
262.         D3=0;
     
263.         P0=table1[RTC_Data[1]/10];
     
264.         Delayms(2);
     
265.         P0=0xff;
     
266.         D3=1;
     
267. 
     
268.         D4=0;
     
269.         P0=table1[RTC_Data[1]%10];
     
270.         Delayms(2);
     
271.         P0=0xff;
     
272.         D4=1;
     
273. }
     
274. /*****************************************************************************************************
     
275. ***************************************显示秒函数*****设置用******************************************
     
276. *****************************************************************************************************/
     
277. void display_set_miao()
     
278. {       
     
279.         D1=0;
     
280.         P0=0x49;
     
281.         Delayms(2);
     
282.         P0=0xff;
     
283.         D1=1;
     
284. 
     
285.         D2=0;
     
286.         P0=0xff;
     
287.         Delayms(2);
     
288.         P0=0xff;
     
289.         D2=1;
     
290. 
     
291.         D3=0;
     
292.         P0=table1[RTC_Data[0]/10];
     
293.         Delayms(2);
     
294.         P0=0xff;
     
295.         D3=1;
     
296. 
     
297.         D4=0;
     
298.         P0=table1[RTC_Data[0]%10];
     
299.         Delayms(2);
     
300.         P0=0xff;
     
301.         D4=1;
     
302. }
     
303. /*****************************************************************************************************
     
304. ********************************************键值处理函数**********************************************
     
305. *****************************************************************************************************/       
     
306. void KeyDataProcess()
     
307. {
     
308.         if(key1==0)// 设置
     
309.         {
     
310.                 if(key1==0)
     
311.                 {
     
312.                         Delay_xms(20);
     
313.                         while(!key1);
     
314.                         laba_flag=1; //蜂鸣器响一声
     
315.                         set_flag=0;
     
316.                         RTC_Set_ID++;
     
317.                         if(RTC_Set_ID>=4)
     
318.                                 RTC_Set_ID=1;
     
319.                 }
     
320.         }
     
321. 
     
322.         if(key2==0)//+
     
323.         {
     
324.                 if(key2==0)
     
325.                 {
     
326.                         Delay_xms(20);
     
327.                         while(!key2);
     
328.                         laba_flag=1;   //蜂鸣器响一声
     
329.                         set_flag=0;
     
330.                         if(RTC_Set_ID==1)
     
331.                         {
     
332.                                 RTC_Data[2]++;
     
333.                                 if(RTC_Data[2]>23)
     
334.                                 RTC_Data[2]=0;
     
335.                                 display_set_shi();
     
336.                         }
     
337.                         else if(RTC_Set_ID==2)
     
338.                         {
     
339.                                 RTC_Data[1]++;
     
340.                                 if(RTC_Data[1]>59)
     
341.                                 RTC_Data[1]=0;
     
342.                                 display_set_fen();
     
343.                         }
     
344.                         else if(RTC_Set_ID==3)
     
345.                         {
     
346.                                 RTC_Data[0]++;
     
347.                                 if(RTC_Data[0]>59)
     
348.                                 RTC_Data[0]=0;
     
349.                                 display_set_miao();
     
350.                         }
     
351.                 }
     
352.         }
     
353. 
     
354.         if(key3==0)//-
     
355.         {
     
356.                 if(key3==0)
     
357.                 {
     
358.                         Delay_xms(20);
     
359.                         while(!key3);
     
360.                         laba_flag=1;          //蜂鸣器响一声
     
361.                         set_flag=0;
     
362.                         if(RTC_Set_ID==1)
     
363.                         {
     
364.                                 RTC_Data[2]--;
     
365.                                 if(RTC_Data[2]==-1)
     
366.                                 RTC_Data[2]=23;
     
367.                                 display_set_shi();
     
368.                         }
     
369.                         else if(RTC_Set_ID==2)
     
370.                         {
     
371.                                 RTC_Data[1]--;
     
372.                                 if(RTC_Data[1]==-1)
     
373.                                 RTC_Data[1]=59;
     
374.                                 display_set_fen();
     
375.                         }
     
376.                         else if(RTC_Set_ID==3)
     
377.                         {
     
378.                                 RTC_Data[0]--;
     
379.                                 if(RTC_Data[0]==-1)
     
380.                                 RTC_Data[0]=59;
     
381.                                 display_set_miao();
     
382.                         }
     
383.                 }
     
384.         }
     
385. 
     
386.        
     
387.         //以下为红外遥控部分
     
388.         if(IrOK==1)        //设置键
     
389.         {
     
390.                 if(Im[2]==0x0d)
     
391.                 {
     
392.                         laba_flag=1; //蜂鸣器响一声
     
393.                         set_flag=0;
     
394.                         RTC_Set_ID++;
     
395.                         if(RTC_Set_ID>=4)
     
396.                                 RTC_Set_ID=1;
     
397.                 }
     
398. 
     
399.                 else if(Im[2]==0x40)//遥控器+键
     
400.                 {
     
401.                         laba_flag=1;   //蜂鸣器响一声
     
402.                         set_flag=0;
     
403.                         if(RTC_Set_ID==1)
     
404.                         {
     
405.                                 RTC_Data[2]++;
     
406.                                 if(RTC_Data[2]>23)
     
407.                                 RTC_Data[2]=0;
     
408.                                 display_set_shi();
     
409.                         }
     
410.                         else if(RTC_Set_ID==2)
     
411.                         {
     
412.                                 RTC_Data[1]++;
     
413.                                 if(RTC_Data[1]>59)
     
414.                                 RTC_Data[1]=0;
     
415.                                 display_set_fen();
     
416.                         }
     
417.                         else if(RTC_Set_ID==3)
     
418.                         {
     
419.                                 RTC_Data[0]++;
     
420.                                 if(RTC_Data[0]>59)
     
421.                                 RTC_Data[0]=0;
     
422.                                 display_set_miao();
     
423.                         }
     
424.                 }
     
425. 
     
426.                 else if(Im[2]==0x19)//遥控器-键
     
427.                 {
     
428.                         laba_flag=1;          //蜂鸣器响一声
     
429.                         set_flag=0;
     
430.                         if(RTC_Set_ID==1)
     
431.                         {
     
432.                                 RTC_Data[2]--;
     
433.                                 if(RTC_Data[2]==-1)
     
434.                                 RTC_Data[2]=23;
     
435.                                 display_set_shi();
     
436.                         }
     
437.                         else if(RTC_Set_ID==2)
     
438.                         {
     
439.                                 RTC_Data[1]--;
     
440.                                 if(RTC_Data[1]==-1)
     
441.                                 RTC_Data[1]=59;
     
442.                                 display_set_fen();
     
443.                         }
     
444.                         else if(RTC_Set_ID==3)
     
445.                         {
     
446.                                 RTC_Data[0]--;
     
447.                                 if(RTC_Data[0]==-1)
     
448.                                 RTC_Data[0]=59;
     
449.                                 display_set_miao();
     
450.                         }
     
451.                 }
     
452.                 else if(Im[2]==0x15)//遥控器播放键
     
453.                 {
     
454.                         laba_flag=1;          //蜂鸣器响一声
     
455.                         set_flag=1;
     
456.                         RTC_Save_Flag=1;               
     
457.                 }
     
458.                 else if(Im[2]==0x47)//遥控器MENU键
     
459.                 {
     
460.                         laba_flag=1;          //蜂鸣器响一声
     
461.                         set_flag=1;                                       
     
462.                         gk=!gk;       
     
463.                 }
     
464.                 IrOK=0;
     
465.         }
     
466. }
     
467. /*****************************************************************************************************
     
468. *****************************************DS3231时钟函数***********************************************
     
469. *****************************************************************************************************/       
     
470. void delay_IIC()   
     
471. {
     
472.         _nop_();_nop_();_nop_();_nop_();//IIC总线限速延时函数。该函数是空函数，延时4个机器周期。
     
473. }
     
474. void IIC_Init()        //IIC总线初始化函数
     
475. {
     
476.     IIC_SDA=1;//释放IIC总线的数据线。
     
477.     IIC_SCL=1;//释放IIC总线的时钟线。
     
478. }
     
479. void IIC_start()  //IIC总线产生起始信号函数
     
480. {   
     
481.      IIC_SDA=1;//拉高数据线
     
482.      IIC_SCL=1;//拉高时钟线
     
483.      delay_IIC();
     
484.      IIC_SDA=0;//在时钟线为高电平时，拉低数据线，产生起始信号。
     
485.      delay_IIC();
     
486.      IIC_SCL=0;//拉低时钟线
     
487. }
     
488. void IIC_stop()//IIC总线产生停止信号函数
     
489. {
     
490.     IIC_SDA=0;//拉低数据线
     
491.     delay_IIC();
     
492.     IIC_SCL=1;//拉高时钟线。
     
493.     delay_IIC();
     
494.     IIC_SDA=1;//时钟时线为高电平时，拉高数据线，产生停止信号。
     
495.     delay_IIC();
     
496. }
     
497. bit IIC_Tack()         //接收应答信号函数
     
498. {
     
499.     bit ack;//定义一个位变量，来暂存应答状态。
     
500.     IIC_SDA=1;//释放数据总线，准备接收应答信号。
     
501.     delay_IIC();
     
502.     IIC_SCL=1;//拉高时钟线。
     
503.     delay_IIC();
     
504.     ack=IIC_SDA;//读取应答信号的状态。
     
505.     delay_IIC();
     
506.     IIC_SCL=0;//拉低时钟线。
     
507.     delay_IIC();
     
508.     return ack;//返回应答信号的状态，0表示应答，1表示非应答。
     
509. }
     
510. void IIC_write_byte(uchar Data)//向IIC总线写入一个字节的数据函数
     
511. {
     
512.         uchar i;
     
513.         for(i=0;i<8;i++)//有8位数据
     
514.         {
     
515.                 if(Data&0x80)
     
516.                 IIC_SDA=1;//写最高位的数据
     
517.                 else
     
518.                 IIC_SDA = 0;
     
519.                 delay_IIC();
     
520.                 IIC_SCL=1; //拉高时钟线，将数写入到设备中。
     
521.                 delay_IIC();
     
522.                 IIC_SCL=0;//拉低时钟线，允许改变数据线的状态
     
523.                 delay_IIC();
     
524.                 Data=Data<<1;//数据左移一位，把次高位放在最高位,为写入次高位做准备
     
525.         }
     
526. }
     
527. uchar IIC_read_byte()//从IIC总线读取一个字节的数据函数
     
528. {
     
529.     uchar i;
     
530.     uchar Data;       //定义一个缓冲寄存器。
     
531.     for(i=0;i<8;i++)//有8位数据
     
532.     {
     
533.         IIC_SCL=1;//拉高时钟线，为读取下一位数据做准备。
     
534.         delay_IIC();
     
535.         Data=Data<<1;//将缓冲字节的数据左移一位，准备读取数据。
     
536.         delay_IIC();
     
537.       
     
538.         if(IIC_SDA)//如果数据线为高平电平。
     
539.         Data=Data|0x01;//则给缓冲字节的最低位写1。
     
540.         IIC_SCL=0;//拉低时钟线，为读取下一位数据做准备。
     
541.         delay_IIC();
     
542.     }
     
543.     return Data;//返回读取的一个字节数据。
     
544. }
     
545. void IIC_single_byte_write(uchar Waddr,uchar Data)         //向任意地址写入一个字节数据函数
     
546. {
     
547.     IIC_start();//产生起始信号
     
548.     IIC_write_byte(0xd0);//写入设备地址（写）
     
549.     IIC_Tack();//等待设备的应答
     
550.     IIC_write_byte(Waddr);//写入要操作的单元地址。
     
551.     IIC_Tack();//等待设备的应答。
     
552.     IIC_write_byte(Data);//写入数据。
     
553.     IIC_Tack();//等待设备的应答。
     
554.     IIC_stop();//产生停止符号。
     
555. }
     
556. uchar IIC_single_byte_read(uchar Waddr)        //从任意地址读取一个字节数据函数
     
557. {
     
558.     uchar Data;//定义一个缓冲寄存器。
     
559.     IIC_start();//产生起始信号
     
560.     IIC_write_byte(0xd0);//写入设备地址（写）
     
561.     IIC_Tack();//等待设备的应答
     
562.     IIC_write_byte(Waddr);//写入要操作的单元地址。
     
563.     IIC_Tack();//等待设备的应答。
     
564.     IIC_stop();//产生停止符号。
     
565.     IIC_start();//产生起始信号
     
566.     IIC_write_byte(0xd1);//写入设备地址（写）
     
567.     IIC_Tack();//等待设备的应答
     
568.     Data=IIC_read_byte();//写入数据。
     
569.     delay_IIC();
     
570.     IIC_stop();//产生停止符号。
     
571.     return Data;//返回读取的一个字节数据。
     
572. }
     
573. /*****************************************************************************************************
     
574. *******************************************时钟初始化函数*********************************************
     
575. *****************************************************************************************************/
     
576. void DS3231_Init()
     
577. {
     
578.     IIC_SDA=1;
     
579.     IIC_SCL=1;
     
580.     IIC_single_byte_write(0x0e,0x0c);
     
581. }
     
582. /*****************************************************************************************************
     
583. ********************************************时钟写入函数**********************************************
     
584. *****************************************************************************************************/
     
585. void Set_RTC()
     
586. {
     
587.     uchar i,tmp;
     
588.     for(i=0;i<7;i++)
     
589.     {      
     
590.         tmp=RTC_Data[i]/10;       
     
591.         RTC_Data1[i]=RTC_Data[i]%10;
     
592.         RTC_Data1[i]=RTC_Data1[i]+tmp*16;
     
593.     }
     
594.     for(i=0;i<7;i++)        
     
595.     {
     
596.         IIC_single_byte_write(rtc_address[i],RTC_Data1[i]);
     
597.     }
     
598.     IIC_single_byte_write(0x0e,0x0c);
     
599. }
     
600. /*****************************************************************************************************
     
601. ********************************************时钟读取函数**********************************************
     
602. *****************************************************************************************************/       
     
603. void Read_RTC()
     
604. {
     
605.     uchar i,tmp,tmp1,tmp2;         
     
606.     for(i=0;i<7;i++)         
     
607.     {
     
608.             tmp = IIC_single_byte_read(rtc_address[i]);
     
609.             tmp1 = tmp/16;
     
610.             tmp2 = tmp%16;
     
611.                 RTC_Data[i]=tmp1*10+tmp2;
     
612.     }   
     
613. }
     
614. void Ram_init()
     
615. {
     
616.         Read_RTC();                               //读取 秒分时日月周年
     
617.         if((!RTC_Data[6])&&(!RTC_Data[4])&&(!RTC_Data[3])&&(!RTC_Data[2])&&(!RTC_Data[1])&&(!RTC_Data[0]))
     
618.         {
     
619.                 RTC_Data[0]=0;       //秒      //秒分时日月周年 最低位读写位
     
620.                 RTC_Data[1]=0;                 //分
     
621.                 RTC_Data[2]=12;                 //时
     
622.                 RTC_Data[3]=3;                 //日
     
623.                 RTC_Data[4]=11;                 //月
     
624.                 RTC_Data[5]=2;                 //周
     
625.                 RTC_Data[6]=15;                 //年
     
626.                 Set_RTC();                     //写入 秒分时日月周年
     
627.         }
     
628.         RTC_Set_ID=0;       
     
629. }
     
630. 
     
631. /*****************************************************************************************************
     
632. **********************************************走时函数************************************************
     
633. *****************************************************************************************************/       
     
634. void Time_Fun()
     
635. {
     
636.         static        uchar T10Ms_Cnt=0,T200Ms_Cnt=0;
     
637.         static uchar Buzz_On_Cnt=0,RTC_Save_Cnt=0;       
     
638.        
     
639.         T10Ms_Cnt++;       
     
640.         if(T10Ms_Cnt>=5)
     
641.         {
     
642.                 T10Ms_Cnt=0;
     
643.                 KeyDataProcess();
     
644.                 if(laba_flag)
     
645.                 {
     
646.                         Buzz_On_Cnt++;
     
647.                         if(Buzz_On_Cnt>=10)
     
648.                         {
     
649.                                 laba_flag=0;
     
650.                                 Buzz_On_Cnt=0;
     
651.                         }
     
652.                 }       
     
653.                 if(RTC_Save_Flag)                         //按确定键RTC_Save_Flag=1,保存数据
     
654.                 {
     
655.                         RTC_Save_Cnt++;
     
656.                         if(RTC_Save_Cnt>=50)
     
657.                         {
     
658.                                 RTC_Save_Cnt=0;
     
659.                                 RTC_Save_Flag=0;
     
660.                                 RTC_Set_ID=0;
     
661.                                 Set_RTC();
     
662.                         }
     
663.                 }
     
664.         }
     
665.         T200Ms_Cnt++;
     
666.         if(T200Ms_Cnt>=5)                          
     
667.         {
     
668.                 T200Ms_Cnt=0;               
     
669.                 if(!RTC_Set_ID)
     
670.                 Read_RTC();
     
671.                 GetADCResult(7,&temp[2]);
     
672.                 if(gk==1)                    //开光控
     
673.                 {
     
674.                         if( temp[2]<100)ld=5;
     
675.                         if( temp[2]>100 && temp[2]<300)ld=10;
     
676.                         if( temp[2]>300 && temp[2]<500)ld=50;
     
677.                         if( temp[2]>500 && temp[2]<600)ld=80;
     
678.                         if( temp[2]>600 && temp[2]<700)ld=100;
     
679.                         if( temp[2]>700 && temp[2]<800)ld=120;
     
680.                         if( temp[2]>900 && temp[2]<1000)ld=130;
     
681.                         if( temp[2]>1000)ld=150;                                       
     
682.                 }
     
683.                 else ld=5;       
     
684.                 if(set_flag==1)
     
685.                 {
     
686.                         display();
     
687.                 }
     
688.                 if(RTC_Set_ID==1)
     
689.                 {
     
690.                         display_set_shi();
     
691.                 }
     
692.                 else if(RTC_Set_ID==2)
     
693.                 {
     
694.                         display_set_fen();
     
695.                 }
     
696.                 else if(RTC_Set_ID==3)
     
697.                 {
     
698.                         display_set_miao();
     
699.                 }
     
700.                 Delayms(ld);
     
701.         }
     
702. }
     
703. 
     
704. /*****************************************************************************************************
     
705. ****************************************DS18B20函数******************************************
     
706. *****************************************************************************************************/
     
707. #if defined(USE_18B20)
     
708. unsigned char DS18B20_GetTemp( void )
     
709. {
     
710.    switch ( ds1820state )
     
711.    {
     
712.       case 0://设备复位
     
713.          if ( 0==DS18B20_Reset(  ) )
     
714.          {
     
715.             ds1820state = 1;
     
716.             ds1820substate =0;  
     
717.          }
     
718.       break;
     
719.       case 1:
     
720.          if ( 0==DS18B20_WriteByte( 0xCC ) )
     
721.          {   //跳过ROM命令
     
722.             ds1820state = 2;
     
723.             ds1820substate =0;                 
     
724.          }               
     
725.       break;
     
726.       case 2:
     
727.          if ( 0==DS18B20_WriteByte( 0x44 ) )
     
728.          {   //开始转换命令
     
729.             ds1820state = 3;
     
730.             ds1820substate =0;
     
731.             uscnt = 0;
     
732.          }
     
733.       break;
     
734.       case 3://等待转换完成
     
735.          if ( flag_ms_ds )
     
736.          {
     
737.             flag_ms_ds = 0;
     
738.             uscnt++;
     
739.          }
     
740.          if ( uscnt>DS1820_TIMEOUT )
     
741.          {
     
742.             ds1820state = 0;
     
743.          }
     
744.          if ( DQ )
     
745.          {
     
746.             ds1820state = 4;
     
747.             ds1820substate =0;
     
748.          }               
     
749.       break;
     
750.       case 4:
     
751.          if ( 0==DS18B20_Reset(  ) )
     
752.          {
     
753.             ds1820state = 5;
     
754.             ds1820substate =0;
     
755.          }
     
756.       break;
     
757.       case 5:
     
758.          if ( 0==DS18B20_WriteByte( 0xCC ) )
     
759.          {   //跳过ROM命令
     
760.             ds1820state = 6;
     
761.             ds1820substate =0;               
     
762.          }               
     
763.       break;
     
764.       case 6:
     
765.          if ( 0==DS18B20_WriteByte( 0xBE ) )
     
766.          {   //读暂存存储器命令
     
767.             ds1820state = 7;
     
768.             ds1820substate =0;               
     
769.          }
     
770.       break;
     
771.       case 7:
     
772.          if ( 0==DS18B20_ReadByte(  ) )
     
773.          {   //读温度低字节
     
774.             TEMPL = ds1820data;
     
775.             ds1820state = 8;
     
776.             ds1820substate =0;
     
777.          }   
     
778.       break;
     
779.       case 8:
     
780.          if ( 0==DS18B20_ReadByte(  ) )
     
781.          {   //读温度高字节
     
782.             TEMPH = ds1820data;
     
783.             ds1820state = 0;
     
784.             ds1820substate =0;
     
785.             return 0;
     
786.          }
     
787.       break;
     
788.       default:ds1820state=0;break;
     
789.    }
     
790. 
     
791.    return 1;
     
792. }
     
793. 
     
794. unsigned char DelayXus(unsigned short n)
     
795. {
     
796.    if ( uscnt < n )
     
797.    {
     
798.       uscnt++;
     
799.       return 1;
     
800.    }
     
801.    else
     
802.    {
     
803.       uscnt = 0;
     
804.       return 0;
     
805.    }   
     
806. }
     
807. 
     
808. unsigned char DS18B20_Reset( void)
     
809. {
     
810.    switch ( ds1820substate )
     
811.    {
     
812.       case 0:
     
813.          DQ = 0;                     //送出低电平复位信号
     
814.          ds1820substate = 1;
     
815.          uscnt = 0;
     
816.       break;
     
817.       case 1: //延时至少480us
     
818.          if ( 0==DelayXus(DS_DELAY480US) )
     
819.          {
     
820.             DQ = 1;    //释放数据线
     
821.             ds1820substate = 2;
     
822.             uscnt = 0;   
     
823.          }        
     
824.       break;
     
825.       case 2: //检测存在脉冲
     
826.          if ( 0==DQ )
     
827.          {
     
828.             ds1820substate = 3;
     
829.             uscnt = 0;
     
830.          }
     
831.          else if ( uscnt++ > DS_WAIT_PLUSE )
     
832.          {
     
833.             ds1820substate = 0;
     
834.          }         
     
835.       break;
     
836.       case 3: //等待设备释放数据线
     
837.          if ( 0==DelayXus(DS_DELAY240US) )
     
838.          {
     
839.             ds1820substate = 0;
     
840.             return 0;
     
841.          }
     
842.       break;
     
843.       default:ds1820substate=0;break;
     
844.    }
     
845.    return 1;
     
846. }
     
847. 
     
848. /**************************************
     
849. 从DS18B20读1字节数据
     
850. **************************************/
     
851. unsigned char DS18B20_ReadByte( void )
     
852. {
     
853.    switch ( ds1820substate )
     
854.    {
     
855.       case 0:
     
856.          loopcnt =0;
     
857.       case 1:
     
858.          ds1820data >>= 1;
     
859.          DQ = 0;    //开始时间片
     
860.          _nop_();_nop_();_nop_();            //延时等待
     
861.          DQ = 1;    //准备接收
     
862.          _nop_();_nop_();_nop_();            //接收延时
     
863.          if ( DQ ) ds1820data |= 0x80;     //读取数据
     
864.          uscnt = 0;
     
865.          ds1820substate = 2;
     
866.       break;
     
867.       case 2:
     
868.          if ( 0==DelayXus(DS_DELAY60US) )
     
869.          {
     
870.             loopcnt++;
     
871.             ds1820substate = 1;
     
872.          }
     
873.          if ( loopcnt>7 )
     
874.          {
     
875.             ds1820substate = 0;
     
876.             return 0;
     
877.          }
     
878.          break;
     
879.       default: ds1820substate=0;break;
     
880.    }
     
881. 
     
882.    return 1;
     
883. }
     
884. 
     
885. /**************************************
     
886. 向DS18B20写1字节数据
     
887. **************************************/
     
888. unsigned char DS18B20_WriteByte( unsigned char dat)
     
889. {
     
890.    switch ( ds1820substate )
     
891.    {
     
892.       case 0:
     
893.          loopcnt = 0;
     
894.          ds1820data = dat;
     
895.       case 1:
     
896.          DQ = 0;   //开始时间片
     
897.          _nop_();_nop_();_nop_();             //延时等待
     
898.          if ( ds1820data&0x01 )DQ=1;
     
899.          else DQ = 0;
     
900.          ds1820data >>= 1;     //送出数据
     
901.          uscnt = 0;
     
902.          ds1820substate = 2;
     
903.       break;
     
904.       case 2:
     
905.          if ( 0==DelayXus(DS_DELAY60US) )
     
906.          {
     
907.             loopcnt++;
     
908.             DQ = 1;                     //恢复数据线
     
909.             //_nop_();                     //恢复延时
     
910.             ds1820substate = 1;
     
911.          }
     
912.          if ( loopcnt>7 )
     
913.          {
     
914.             ds1820substate = 0;
     
915.             return 0;
     
916.          }
     
917.       break;
     
918.       default: ds1820substate=0;break;
     
919.    }
     
920. 
     
921.    return 1;
     
922. }
     
923. 
     
924. unsigned char DS18B20_InitSet( void )
     
925. {
     
926.    switch ( ds1820state )
     
927.    {
     
928.       case 0://设备复位
     
929.          if ( 0==DS18B20_Reset(  ) )
     
930.          {
     
931.             ds1820state = 1;
     
932.             ds1820substate =0;  
     
933.          }
     
934.       break;
     
935.       case 1:
     
936.          if ( 0==DS18B20_WriteByte( 0xCC ) )
     
937.          {   //跳过ROM命令
     
938.             ds1820state = 2;
     
939.             ds1820substate =0;                 
     
940.          }               
     
941.       break;
     
942.       case 2:
     
943.          if ( 0==DS18B20_WriteByte( 0x4E ) )
     
944.          {   //写粘贴板
     
945.             ds1820state = 3;
     
946.             ds1820substate =0;
     
947.          }
     
948.       break;
     
949.       case 3://
     
950.          if ( 0==DS18B20_WriteByte( DS_TH_REG ) )
     
951.          {   //写TH
     
952.             ds1820state = 4;
     
953.             ds1820substate =0;
     
954.          }         
     
955.       break;
     
956.       case 4://
     
957.          if ( 0==DS18B20_WriteByte( DS_TL_REG ) )
     
958.          {   //写TL
     
959.             ds1820state = 5;
     
960.             ds1820substate =0;
     
961.          }         
     
962.       break;
     
963.       case 5://
     
964.          if ( 0==DS18B20_WriteByte( DS_CONFIG_REG ) )
     
965.          {   //写设置
     
966.             ds1820state = 0;
     
967.             ds1820substate =0;
     
968.             return 0;
     
969.          }         
     
970.       break;
     
971.       default:ds1820state=0;break;
     
972.    }
     
973. 
     
974.    return 1;
     
975. }
     
976. #endif
     
977. /*****************************************************************************************************
     
978. ***********************************************主函数*************************************************
     
979. *****************************************************************************************************/
     
980. void main()
     
981. {  
     
982.         EA=1;                 //开总中断
     
983.         IT1=1;                                  //下降沿有效
     
984.         EX1=1;                                  //外部中断1开
     
985.         ET1=1;                                  //打开允许开关
     
986. 
     
987.         hongwai=1;            
     
988. 
     
989.         TMOD=0x11;   
     
990.         TH1=0xff;
     
991.         TL1=256-110;
     
992.         TR1=1;                //启动定时/计数器1 中断
     
993. 
     
994.         TH0=0;                                  //T0赋初值
     
995.         TL0=0;
     
996.         TR0=1;
     
997.         InitADC();                          //ADC初始化               
     
998.         Ram_init();                          
     
999.         IIC_Init();
     
1000.         DS3231_Init();       
      
1001.         laba=1;
      
1002.         set_flag=1;
      
1003.         gk=1;                          //光控默认开
      
1004.         laba_flag=0;
      
1005.         while(1)
      
1006.         {
      
1007.                 if(T0_Flag)
      
1008.                 {
      
1009.                         T0_Flag=0;
      
1010.                         Time_Fun();
      
1011.                 }
      
1012.         }
      
1013. }
      
1014. /*****************************************************************************************************
      
1015. ****************************************外部中断红外解码函数******************************************
      
1016. *****************************************************************************************************/
      
1017. void intersvr1(void) interrupt 2 using 1   //外部中断解码程序_外部中断1          P3.1口
      
1018. {
      
1019.         Tc=TH0*256+TL0;//提取中断时间间隔时长
      
1020.         TH0=0;
      
1021.         TL0=0;         //定时中断重新置零
      
1022. 
      
1023.         if((Tc>Imin)&&(Tc<Imax))
      
1024.         {
      
1025.                 m=0;
      
1026.                 f=1;
      
1027.                 return;
      
1028.         }              //找到启始码
      
1029.         if(f==1)
      
1030.         {
      
1031.                 if(Tc>Inum1&&Tc<Inum3)
      
1032.                 {
      
1033.                         Im[m/8]=Im[m/8]>>1|0x80; m++;
      
1034.                 }
      
1035.                 if(Tc>Inum2&&Tc<Inum1)
      
1036.                 {
      
1037.                         Im[m/8]=Im[m/8]>>1; m++; //取码
      
1038.                 }
      
1039.                 if(m==32)
      
1040.                 {
      
1041.                         m=0;  
      
1042.                         f=0;
      
1043.                         if(Im[2]==~Im[3])
      
1044.                         {
      
1045.                                 IrOK=1;
      
1046.                         }
      
1047.                         else IrOK=0;   //取码完成后判断读码是否正确
      
1048.                 }
      
1049.         }
      
1050. }
      

复制代码

xiaoyao_mdj

先看数码管是共阴还是共阳,电路是否有问题?如果都没有问题,先编个程序点亮一下数码管,如果也都没有问题,那就看代码了,一步一步找问题吧!

guetcw

这么长的代码没耐心看，先写几句简单的代码点亮一段看看电路和驱动方式是否正确，然后再点亮整个。

慕名而来

这么长的代码调试真的不是三言两语能说清的，分享一点建议，有兴趣的可以试试，但只是一点儿我调试程序的方法、有问题也还是要自己琢磨解决的。涉及显示的程序总是要从显示函数开始调试，方法很简单，就是先删除主循环中的所有代码，只加入显示函数看看显示现象，例如：

void main()
{
***//这里原来的内容不变
while(1)
{

display();

}
}
编译后会出现L16****的警告，只要没有错误就可以下载来看显示，如果无显示则查找这个函数的毛病，如果显示4个0是正常的，此时只需要修改第34行的数组，RTC_Data[7]={0,1,2,3,4,5,6}; 此时如果显示正常就说明显示函数可以使用了，而后改回原来的RTC_Data[7];
再次修改主循环的代码：
while(1)
{
Read_RTC();
display();

}
}

再次下载看显示，正常情况下应该能看到时钟走时的显示，一旦显示正常了就说明显示函数、3231的驱动都没问题了，可以继续其他的调试了。
另外，你的18b20代码貌似没有被利用到。

motofanoranw

感谢@慕名而来 的指导，这没有C语言功底，搞代码确实缓慢，要一点点验证。18b20代码确实是我整合进来的。

mengfc

二楼、三楼说的对，这么长的代码很少会有人看的。首先用最短的代码确认一下硬件电路是否正确，甚至可以用静态显示的方式驱动一个数码管试一下，然后再从最简单的功能调试程序

深寒刺骨

一般都是自已写了BUG,自已慢慢查！

慕名而来

motofanoranw 发表于 2022-3-25 21:38
感谢@慕名而来 的指导，这没有C语言功底，搞代码确实缓慢，要一点点验证。18b20代码确实是我整合进来的。 ...

只是一点而经验分享而已，如果不是准备入行从事专业，注定不会按部就班的学习，用到啥学啥就好，我就是从几行数码管驱动代码开始玩单片机的，虽然一直用“外行”的思路对付编程问题，但是身边常见的单片机的简单应用我照葫芦画瓢的也都能浅显的玩一下，非专业学单片机编程我建议从读懂程序开始，读代码就要学习相关的特征字、语句、算法、调试的代码多了以上这些学习的内容的深度、广度也就多了，就你贴的代码而言涉及很多东西，如果能每一句都明白也就差不多入门了一边百度一边琢磨也不难的。