标题: 求助，单片机数码管显示出错 [打印本页]

---

作者: 华夏哈哈哈    时间: 2020-3-22 13:07
标题: 求助，单片机数码管显示出错

1. //问题是：当key1,key2按下时，数码管显0000（key1按下）/0100(key2按下)，可是目前正常显示没问题，但是摁下key1,key2数码管没有如期的运行，我想请教各位大神，我应该怎么在现有基础上实现  按下key1时，数码管显示0000，按下key2时，数码管显示0100，且对现有程序不产生干扰，谢谢，感激不尽
   
2. 
   
3. //线性区间标度变换公式：    y=(115-15)/(243-13)*X+15kpa   
   
4. 
   
5. 
   
6. #include <AT89X52.h>
   
7. #include <intrins.h>
   
8. #include <stdio.h>
   
9. 
   
10. 
    
11. #define R24C04ADD 0xA1
    
12. #define W24C04ADD 0xA0
    
13. 
    
14. //ADC0832的引脚
    
15. sbit ADCS =P2^2;  //ADC0832 chip seclect
    
16. sbit ADDI =P2^4;  //ADC0832 k in
    
17. sbit ADDO =P2^4;  //ADC0832 k out
    
18. sbit ADCLK =P2^3;  //ADC0832 clock signal
    
19. 
    
20. sbit led=P3^7;//led报警灯
    
21. sbit beep=P1^7;//报警蜂鸣
    
22. sbit a1=P1^0;
    
23. sbit a2=P1^1;
    
24. sbit a3=P1^2;
    
25. sbit a4=P1^3;
    
26. sbit key1=P3^0;
    
27. sbit key2=P3^1;
    
28. sbit c1=P0^0;
    
29. sbit c2=P0^1;
    
30. sbit c3=P0^2;
    
31. sbit c4=P0^3;
    
32. sbit c5=P0^4;
    
33. sbit c6=P0^5;
    
34. sbit c7=P0^6;
    
35. sbit c8=P0^7;
    
36. 
    
37. 
    
38. 
    
39. 
    
40. sbit SDA = P2 ^ 1;                                //数据线
    
41. sbit SCL = P2 ^ 0;                                //时钟线
    
42. bit bAck;                                          //应答标志 当bbAck=1是为正确的应答
    
43. 
    
44. unsigned char dispbitcode[8]={0xf7,0xfb,0xfd,0xfe,0xef,0xdf,0xbf,0x7f};  //位扫描
    
45. unsigned char dispcode[11]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xff};  //共阳数码管字段码
    
46. unsigned char dispbuf[4];
    
47. unsigned int temp;
    
48. unsigned char getdata; //获取ADC转换回来的值
    
49. unsigned char H_count,L_count;
    
50. 
    
51. 
    
52. void delay_0us(void)  //12mhz delay 1.01ms
    
53. {
    
54.    unsigned char x,y,i;
    
55.            for(i=0;i<3;i++)  
    
56.    x=4;
    
57.    while(x--)
    
58.   {
    
59.        y=30;
    
60.        while(y--);
    
61.     }
    
62. }
    
63. void display(void)  //数码管显示函数
    
64. {
    
65. 
    
66.   char k;
    
67.   for(k=0;k<4;k++)
    
68.   {
    
69. 
    
70.   P1 = dispbitcode[k];
    
71.   P0 = dispcode[dispbuf[k]];
    
72.     if(k==1)          //加上数码管的dp小数点
    
73.           P0&=0x7f;
    
74.   delay_0us();
    
75.   if(key1==0,key2==0)
    
76.   P0=0xff;
    
77. 
    
78.             {
    
79.                   if(key1==0)
    
80.             {
    
81.          
    
82. P1=0xfe;//P1.0引脚输出低电平数字1的段码
    
83. P0=0xC0;//数字0的段码
    
84.   delay_0us() ;
    
85. P1=0xfd;//P1.1引脚输出低电平，DS1点亮
    
86. P0=0xC0;//数字0的段码
    
87.      delay_0us() ;
    
88. P1=0xfb;//P1.2引脚输出低电平，DS2点亮
    
89. P0=0xC0;//数字0的段码?
    
90.      delay_0us() ;
    
91.   P1=0xf7;//P1.3引脚输出低电平，DS3点亮
    
92.   P0=0xC0;//数字0的段码
    
93.               delay_0us();
    
94.           P1=0xff;
    
95. }
    
96.                   if(key2==0)
    
97.             {
    
98.                
    
99. P1=0xfe;//P1.0引脚输出低电平数字1的段码
    
100. P0=0xc0;//数字1的段码
     
101.     delay_0us() ;
     
102. P1=0xfd;//P1.1引脚输出低电平，DS1点亮
     
103. P0=0xf9;//数字0的段码
     
104.           delay_0us() ;
     
105. P1=0xfb;//P1.2引脚输出低电平，DS2点亮
     
106. P0=0xc0;//数字0的段码?
     
107.             delay_0us() ;
     
108.   P1=0xf7;//P1.3引脚输出低电平，DS3点亮
     
109.   P0=0xc0;//数字0的段码
     
110.                delay_0us() ;
     
111.           P1=0xff;
     
112.            }
     
113.          
     
114. }
     
115. }
     
116. }           
     
117. 
     
118. /************
     
119. 读ADC0832函数
     
120. ************/
     
121. 
     
122. //采集并返回
     
123. unsigned int Adc0832(unsigned char channel)     //AD转换，返回结果
     
124. {
     
125.     unsigned char i=0;
     
126.     unsigned char j;
     
127.     unsigned int dat=0;
     
128.     unsigned char ndat=0;
     
129. 
     
130.     if(channel==0)channel=2;
     
131.     if(channel==1)channel=3;
     
132.     ADDI=1;
     
133.     _nop_();
     
134.     _nop_();
     
135.     ADCS=0;//拉低CS端
     
136.     _nop_();
     
137.     _nop_();
     
138.     ADCLK=1;//拉高CLK端
     
139.     _nop_();
     
140.     _nop_();
     
141.     ADCLK=0;//拉低CLK端,形成下降沿1
     
142.     _nop_();
     
143.     _nop_();
     
144.     ADCLK=1;//拉高CLK端
     
145.     ADDI=channel&0x1;
     
146.     _nop_();
     
147.     _nop_();
     
148.     ADCLK=0;//拉低CLK端,形成下降沿2
     
149.     _nop_();
     
150.     _nop_();
     
151.     ADCLK=1;//拉高CLK端
     
152.     ADDI=(channel>>1)&0x1;
     
153.     _nop_();
     
154.     _nop_();
     
155.     ADCLK=0;//拉低CLK端,形成下降沿3
     
156.     ADDI=1;//控制命令结束
     
157.     _nop_();
     
158.     _nop_();
     
159.     dat=0;
     
160.     for(i=0;i<8;i++)
     
161.     {
     
162.         dat|=ADDO;//收数据
     
163.         ADCLK=1;
     
164.         _nop_();
     
165.         _nop_();
     
166.         ADCLK=0;//形成一次时钟脉冲
     
167.         _nop_();
     
168.         _nop_();
     
169.         dat<<=1;
     
170.         if(i==7)dat|=ADDO;
     
171.     }  
     
172.     for(i=0;i<8;i++)
     
173.     {
     
174.         j=0;
     
175.         j=j|ADDO;//收数据
     
176.         ADCLK=1;
     
177.         _nop_();
     
178.         _nop_();
     
179.         ADCLK=0;//形成一次时钟脉冲
     
180.         _nop_();
     
181.         _nop_();
     
182.         j=j<<7;
     
183.         ndat=ndat|j;
     
184.         if(i<7)ndat>>=1;
     
185.     }
     
186.     ADCS=1;//拉低CS端
     
187.     ADCLK=0;//拉低CLK端
     
188.     ADDO=1;//拉高数据端,回到初始状态
     
189.     dat<<=8;
     
190.     dat|=ndat;
     
191.     return(dat);            //return ad k
     
192. }
     
193. 
     
194. 
     
195. //启动I2C总线，即发送起始条件
     
196. void StartI2C()
     
197. {
     
198.         SDA = 1;                              //发送起始条件数据信号
     
199.         _nop_();
     
200.         SCL = 1;
     
201.         _nop_();                                    //起始建立时间大于4.7us
     
202.         _nop_();
     
203.         _nop_();
     
204.         _nop_();
     
205.         _nop_();
     
206.         SDA = 0;                              //发送起始信号
     
207.         _nop_();
     
208.         _nop_();
     
209.         _nop_();
     
210.         _nop_();
     
211.         _nop_();
     
212.         SCL = 0;                                //时钟操作
     
213.         _nop_();
     
214.         _nop_();
     
215. }
     
216. //结束I2C总线，即发送I2C结束条件
     
217. void StopI2C()
     
218. {
     
219.         SDA = 0;                                //发送结束条件的数据信号
     
220.         _nop_();                                      //发送结束条件的时钟信号
     
221.         SCL = 1;                                //结束条件建立时间大于4us
     
222.         _nop_();
     
223.         _nop_();
     
224.         _nop_();
     
225.         _nop_();
     
226.         _nop_();
     
227.         SDA = 1;                                //发送I2C总线结束命令
     
228.         _nop_();
     
229.         _nop_();
     
230.         _nop_();
     
231.         _nop_();
     
232.         _nop_();        
     
233. }
     
234. //发送一个字节的数据
     
235. void        SendByte(unsigned char c)
     
236. {
     
237.         unsigned char BitCnt;
     
238.         for(BitCnt = 0;BitCnt < 8;BitCnt++)                                  //一个字节
     
239.                 {
     
240.                         if((c << BitCnt)& 0x80) SDA = 1;                   //判断发送位
     
241.                         else        SDA = 0;
     
242.                         _nop_();
     
243.                         SCL = 1;                              //时钟线为高，通知从机开始接收数据
     
244.                         _nop_();
     
245.                         _nop_();
     
246.                         _nop_();
     
247.                         _nop_();
     
248.                         _nop_();
     
249.                         SCL = 0;
     
250.                 }
     
251.         _nop_();
     
252.         _nop_();
     
253.         SDA = 1;                                                //释放数据线，准备接受应答位
     
254.         _nop_();
     
255.         _nop_();
     
256.         SCL = 1;
     
257.         _nop_();
     
258.         _nop_();
     
259.         _nop_();
     
260.         if(SDA == 1) bAck =0;
     
261.         else bAck = 1;                                                //判断是否收到应答信号
     
262.         SCL = 0;
     
263.         _nop_();
     
264.         _nop_();
     
265. }
     
266. //接收一个字节的数据
     
267. unsigned char RevByte()
     
268. {
     
269.         unsigned char retc;
     
270.         unsigned char BitCnt;
     
271.         retc = 0;
     
272.         SDA = 1;
     
273.         for(BitCnt=0;BitCnt<8;BitCnt++)
     
274.         {
     
275.                 _nop_();
     
276.                 SCL = 0;                                            //置时钟线为低，准备接收
     
277.                 _nop_();
     
278.                 _nop_();
     
279.                 _nop_();
     
280.                 _nop_();
     
281.                 _nop_();
     
282.                 SCL = 1;                                            //置时钟线为高使得数据有效
     
283.                 _nop_();
     
284.                 _nop_();
     
285.                 retc = retc << 1;                                    //左移补零
     
286.                 if (SDA == 1)
     
287.                 retc = retc + 1;                                     //当数据为1则收到的数据+1
     
288.                 _nop_();
     
289.                 _nop_();
     
290.         }
     
291.         SCL = 0;
     
292.         _nop_();
     
293.         _nop_();
     
294.         return(retc);                                   //返回收到的数据
     
295. }
     
296. 
     
297. //WChipAdd:写器件地址;RChipAdd:读器件地址;InterAdd:内部地址;如写正确则返回数据，
     
298. //否则返回对应错误步骤序号
     
299. //向指定器件的内部指定地址发送一个指定字节
     
300. unsigned char WIICByte(unsigned char WChipAdd,unsigned char InterAdd,unsigned char WIICData)
     
301. {
     
302.         StartI2C();                                                                                      //启动总线
     
303.         SendByte(WChipAdd);                                                        //发送器件地址以及命令
     
304.         if (bAck==1)                                                                                          //收到应答
     
305.         {
     
306.                 SendByte(InterAdd);                                                                //发送内部子地址
     
307.                 if (bAck ==1)
     
308.                 {
     
309.                         SendByte(WIICData);                                                        //发送数据
     
310.                         if(bAck == 1)
     
311.                         {
     
312.                                 StopI2C();                    //停止总线
     
313.                                 return(0xff);
     
314.                         }
     
315.                         else
     
316.                         {
     
317.                                 return(0x03);
     
318.                         }                        
     
319.                 }
     
320.                 else
     
321.                 {
     
322.                         return(0x02);
     
323.                 }
     
324.         }
     
325.         return(0x01);
     
326. }
     
327. //读取指定器件的内部指定地址一个字节数据
     
328. unsigned char RIICByte(unsigned char WChipAdd,unsigned char RChipAdd,unsigned char InterDataAdd)
     
329. {
     
330.         unsigned char TempData;        
     
331.         TempData = 0;
     
332.         StartI2C();                                                                        //启动
     
333.         SendByte(WChipAdd);                                                    //发送器件地址以及读命令
     
334.         if (bAck==1)                                                                            //收到应答
     
335.         {
     
336.                 SendByte(InterDataAdd);                                        //发送内部子地址
     
337.                 if (bAck ==1)
     
338.                 {
     
339.                         StartI2C();
     
340.                         SendByte(RChipAdd);        
     
341.                         if(bAck == 1)
     
342.                         {
     
343.                                 TempData = RevByte();       //接收数据
     
344.                                 StopI2C();                  //停止I2C总线
     
345.                                 return(TempData);           //返回数据
     
346.                         }
     
347.                         else
     
348.                         {
     
349.                                 return(0x03);
     
350.                         }        
     
351.                 }
     
352.                 else
     
353.                 {
     
354.                         return(0x02);
     
355.                 }
     
356.         }
     
357.         else
     
358.         {
     
359.                 return(0x01);
     
360.         }
     
361. }
     
362. //报警子函数
     
363. void alarm(void)
     
364. {
     
365.          
     
366.          if(getdata>=208.611252)                 //如果当前压力值大于100kpa，
     
367.          {
     
368.           led=0;
     
369.           beep=0;                                                   //则启动报警
     
370.          }                          
     
371.                         
     
372.                
     
373.           else
     
374.          {
     
375.                  led=1;
     
376.                  beep=1;
     
377.                   
     
378.                  }                        //关闭报警
     
379.                  
     
380.                  
     
381.       
     
382. }
     
383. 
     
384. 
     
385. 
     
386. void main(void)
     
387. {
     
388.   unsigned int OverCounter = 0;
     
389.   unsigned char i;
     
390.   bit OverFlg = 0;
     
391.   unsigned int temp,ppress = 0;
     
392.   float  press;
     
393. 
     
394.   while(1)
     
395.          
     
396.   {
     
397.            display( );
     
398.             if(getdata>=208.611252);
     
399.        TR0=1;         
     
400.           getdata=Adc0832(0);
     
401.           alarm();
     
402.           for(i=0;i<25;i++)
     
403.           if(14<getdata<243)                                       //当压力值介于15kpa到115kpa之间时，遵循线性变换
     
404.                  {                           
     
405.                   int vary=getdata;                                                //y=(115-15)/(243-13)*X+15kpa                        
     
406.                         press=((10.0/23.0)*vary)+9.5;                        //测试时补偿值为9.3                                                                                                         
     
407.                         temp=(int)(press*10);                  //放大10倍，便于后面的计算
     
408.       if(temp != ppress)
     
409.       {
     
410.         ppress = temp;
     
411.         OverFlg = 1;
     
412.       }                                                                                            
     
413.                         dispbuf[3]=temp/1000;                                     //取压力值百位
     
414.                         dispbuf[2]=(temp%1000)/100;                            //取压力值十位
     
415.                         dispbuf[1]=((temp%1000)%100)/10;                    //取压力值个位
     
416.                         dispbuf[0]=((temp%1000)%100)%10;                        //取压力值十分位
     
417.                         display();
     
418.       
     
419.           }
     
420.       }
     
421. 
     
422.          }
     
423.          
     
424.          
     
425.          
     
426.          
     
427.          
     
428.          
     
429.          
     
430.          
     
431.                   
     
432.   void Time0(void) interrupt 1 using 0
     
433. {
     
434.                  if(getdata>=208.611252);
     
435.         beep=~beep;           //蜂鸣器状态改变
     
436.         if( L_count!=0x00 )
     
437.         {
     
438.            L_count--;           //初值减小
     
439.            TH0=H_count;    //高位赋初值
     
440.        TL0=L_count;           //低位赋初值
     
441.        return;                   //返回主函数
     
442.      }else  H_count--;
     
443.                
     
444.         if( H_count!=0xfc )           //H_count从0xff降到0Xfc,周期结束
     
445.         {
     
446.            L_count--;
     
447.            TH0=H_count;
     
448.        TL0=L_count;
     
449.        return;
     
450.         }
     
451.         else
     
452.      {
     
453.          if(led==0);
     
454.         H_count=0xff;
     
455.         L_count=0xa0;
     
456.         TH0=H_count;
     
457.         TL0=L_count;
     
458.         beep=1;                          //关闭蜂鸣器
     
459.         TR0=0;                         //关闭定时器
     
460.      }   
     
461. }            
     
462.   
     
463. 
     
464. 
     
465. 
     

复制代码

51hei图片20200323123117.png (38.78 KB, 下载次数: 125)

下载附件

2020-3-23 14:47 上传

51hei图片20200323123149.png (40.83 KB, 下载次数: 116)

下载附件

2020-3-23 14:47 上传

---

作者: pql2438547    时间: 2020-3-22 21:05
你们写程序能不能搞成模块化设计呢？这么长一段你让人怎么看？

---

作者: zhouchuantao    时间: 2020-3-23 00:22
思路：按下后跳转独立程序，在这个程序中循环显示。

---

作者: tyu1    时间: 2020-3-23 09:01
你最好放一张原理图，别人看起来也方便

---

作者: 华夏哈哈哈    时间: 2020-3-23 12:30

zhouchuantao 发表于 2020-3-23 00:22
思路：按下后跳转独立程序，在这个程序中循环显示。

具体的应该怎么写呀？我目前就是困在这一步，c语言学的不扎实，需要一个师傅点拨一下

---

作者: 华夏哈哈哈    时间: 2020-3-23 12:33


目前的代码已修改如下，但是没有按键按下去以后执行的程序，只有打断，我目前想让key1按键按下时数码管显示0000，key2按下时数码管显示0100,希望各位大神给点拨一下

1. 
   
2. 
   
3. //线性区间标度变换公式：    y=(115-15)/(243-13)*X+15kpa   
   
4. 
   
5. 
   
6. #include <AT89X52.h>
   
7. #include <intrins.h>
   
8. #include <stdio.h>
   
9. 
   
10. 
    
11. #define R24C04ADD 0xA1
    
12. #define W24C04ADD 0xA0
    
13. 
    
14. //ADC0832的引脚
    
15. sbit ADCS =P2^2;  //ADC0832 chip seclect
    
16. sbit ADDI =P2^4;  //ADC0832 k in
    
17. sbit ADDO =P2^4;  //ADC0832 k out
    
18. sbit ADCLK =P2^3;  //ADC0832 clock signal
    
19. 
    
20. sbit led=P3^7;//led报警灯
    
21. sbit beep=P1^7;//报警蜂鸣
    
22. sbit a1=P1^0;
    
23. sbit a2=P1^1;
    
24. sbit a3=P1^2;
    
25. sbit a4=P1^3;
    
26. sbit key1=P3^0;
    
27. sbit key2=P3^1;
    
28. sbit c1=P0^0;
    
29. sbit c2=P0^1;
    
30. sbit c3=P0^2;
    
31. sbit c4=P0^3;
    
32. sbit c5=P0^4;
    
33. sbit c6=P0^5;
    
34. sbit c7=P0^6;
    
35. sbit c8=P0^7;
    
36. 
    
37. 
    
38. sbit SDA = P2 ^ 1;                                //数据线
    
39. sbit SCL = P2 ^ 0;                                //时钟线
    
40. bit bAck;                                          //应答标志 当bbAck=1是为正确的应答
    
41. 
    
42. unsigned char dispbitcode[8]={0xf7,0xfb,0xfd,0xfe,0xef,0xdf,0xbf,0x7f};  //位扫描
    
43. unsigned char dispcode[11]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xff};  //共阳数码管字段码
    
44. unsigned char dispbuf[4];
    
45. unsigned int temp;
    
46. unsigned char getdata; //获取ADC转换回来的值
    
47. unsigned char H_count,L_count;
    
48. 
    
49. 
    
50. void delay_us(void)  //12mhz delay 1.01ms
    
51. {
    
52.    unsigned char x,y,i;
    
53.            for(i=0;i<3;i++)  
    
54.    x=4;
    
55.    while(x--)
    
56.   {
    
57.        y=30;
    
58.        while(y--);
    
59.     }
    
60. }
    
61. 
    
62. 
    
63. void display(void)  //数码管显示函数
    
64. {
    
65. 
    
66.   char k;
    
67.   for(k=0;k<4;k++)
    
68.   {
    
69.         P1 = dispbitcode[k];                //【【【【问题在这里
    
70.   P0 = dispcode[dispbuf[k]];
    
71.     if(k==1)          //加上数码管的dp小数点
    
72.           P0&=0x7f;
    
73.   delay_us();
    
74.            }
    
75. }          
    
76. 
    
77. /************
    
78. 读ADC0832函数
    
79. ************/
    
80. 
    
81. //采集并返回
    
82. unsigned int Adc0832(unsigned char channel)     //AD转换，返回结果
    
83. {
    
84.     unsigned char i=0;
    
85.     unsigned char j;
    
86.     unsigned int dat=0;
    
87.     unsigned char ndat=0;
    
88. 
    
89.     if(channel==0)channel=2;
    
90.     if(channel==1)channel=3;
    
91.     ADDI=1;
    
92.     _nop_();
    
93.     _nop_();
    
94.     ADCS=0;//拉低CS端
    
95.     _nop_();
    
96.     _nop_();
    
97.     ADCLK=1;//拉高CLK端
    
98.     _nop_();
    
99.     _nop_();
    
100.     ADCLK=0;//拉低CLK端,形成下降沿1
     
101.     _nop_();
     
102.     _nop_();
     
103.     ADCLK=1;//拉高CLK端
     
104.     ADDI=channel&0x1;
     
105.     _nop_();
     
106.     _nop_();
     
107.     ADCLK=0;//拉低CLK端,形成下降沿2
     
108.     _nop_();
     
109.     _nop_();
     
110.     ADCLK=1;//拉高CLK端
     
111.     ADDI=(channel>>1)&0x1;
     
112.     _nop_();
     
113.     _nop_();
     
114.     ADCLK=0;//拉低CLK端,形成下降沿3
     
115.     ADDI=1;//控制命令结束
     
116.     _nop_();
     
117.     _nop_();
     
118.     dat=0;
     
119.     for(i=0;i<8;i++)
     
120.     {
     
121.         dat|=ADDO;//收数据
     
122.         ADCLK=1;
     
123.         _nop_();
     
124.         _nop_();
     
125.         ADCLK=0;//形成一次时钟脉冲
     
126.         _nop_();
     
127.         _nop_();
     
128.         dat<<=1;
     
129.         if(i==7)dat|=ADDO;
     
130.     }  
     
131.     for(i=0;i<8;i++)
     
132.     {
     
133.         j=0;
     
134.         j=j|ADDO;//收数据
     
135.         ADCLK=1;
     
136.         _nop_();
     
137.         _nop_();
     
138.         ADCLK=0;//形成一次时钟脉冲
     
139.         _nop_();
     
140.         _nop_();
     
141.         j=j<<7;
     
142.         ndat=ndat|j;
     
143.         if(i<7)ndat>>=1;
     
144.     }
     
145.     ADCS=1;//拉低CS端
     
146.     ADCLK=0;//拉低CLK端
     
147.     ADDO=1;//拉高数据端,回到初始状态
     
148.     dat<<=8;
     
149.     dat|=ndat;
     
150.     return(dat);            //return ad k
     
151.                
     
152. }
     
153. 
     
154. 
     
155. //启动I2C总线，即发送起始条件
     
156. void StartI2C()
     
157. {
     
158.         SDA = 1;                              //发送起始条件数据信号
     
159.         _nop_();
     
160.         SCL = 1;
     
161.         _nop_();                                    //起始建立时间大于4.7us
     
162.         _nop_();
     
163.         _nop_();
     
164.         _nop_();
     
165.         _nop_();
     
166.         SDA = 0;                              //发送起始信号
     
167.         _nop_();
     
168.         _nop_();
     
169.         _nop_();
     
170.         _nop_();
     
171.         _nop_();
     
172.         SCL = 0;                                //时钟操作
     
173.         _nop_();
     
174.         _nop_();
     
175. }
     
176. //结束I2C总线，即发送I2C结束条件
     
177. void StopI2C()
     
178. {
     
179.         SDA = 0;                                //发送结束条件的数据信号
     
180.         _nop_();                                      //发送结束条件的时钟信号
     
181.         SCL = 1;                                //结束条件建立时间大于4us
     
182.         _nop_();
     
183.         _nop_();
     
184.         _nop_();
     
185.         _nop_();
     
186.         _nop_();
     
187.         SDA = 1;                                //发送I2C总线结束命令
     
188.         _nop_();
     
189.         _nop_();
     
190.         _nop_();
     
191.         _nop_();
     
192.         _nop_();       
     
193. }
     
194. //发送一个字节的数据
     
195. void        SendByte(unsigned char c)
     
196. {
     
197.         unsigned char BitCnt;
     
198.         for(BitCnt = 0;BitCnt < 8;BitCnt++)                                  //一个字节
     
199.                 {
     
200.                         if((c << BitCnt)& 0x80) SDA = 1;                   //判断发送位
     
201.                         else        SDA = 0;
     
202.                         _nop_();
     
203.                         SCL = 1;                              //时钟线为高，通知从机开始接收数据
     
204.                         _nop_();
     
205.                         _nop_();
     
206.                         _nop_();
     
207.                         _nop_();
     
208.                         _nop_();
     
209.                         SCL = 0;
     
210.                 }
     
211.         _nop_();
     
212.         _nop_();
     
213.         SDA = 1;                                                //释放数据线，准备接受应答位
     
214.         _nop_();
     
215.         _nop_();
     
216.         SCL = 1;
     
217.         _nop_();
     
218.         _nop_();
     
219.         _nop_();
     
220.         if(SDA == 1) bAck =0;
     
221.         else bAck = 1;                                                //判断是否收到应答信号
     
222.         SCL = 0;
     
223.         _nop_();
     
224.         _nop_();
     
225. }
     
226. //接收一个字节的数据
     
227. unsigned char RevByte()
     
228. {
     
229.         unsigned char retc;
     
230.         unsigned char BitCnt;
     
231.         retc = 0;
     
232.         SDA = 1;
     
233.         for(BitCnt=0;BitCnt<8;BitCnt++)
     
234.         {
     
235.                 _nop_();
     
236.                 SCL = 0;                                            //置时钟线为低，准备接收
     
237.                 _nop_();
     
238.                 _nop_();
     
239.                 _nop_();
     
240.                 _nop_();
     
241.                 _nop_();
     
242.                 SCL = 1;                                            //置时钟线为高使得数据有效
     
243.                 _nop_();
     
244.                 _nop_();
     
245.                 retc = retc << 1;                                    //左移补零
     
246.                 if (SDA == 1)
     
247.                 retc = retc + 1;                                     //当数据为1则收到的数据+1
     
248.                 _nop_();
     
249.                 _nop_();
     
250.         }
     
251.         SCL = 0;
     
252.         _nop_();
     
253.         _nop_();
     
254.         return(retc);                                   //返回收到的数据
     
255.                
     
256. }
     
257. 
     
258. //WChipAdd:写器件地址;RChipAdd:读器件地址;InterAdd:内部地址;如写正确则返回数据，
     
259. //否则返回对应错误步骤序号
     
260. //向指定器件的内部指定地址发送一个指定字节
     
261. unsigned char WIICByte(unsigned char WChipAdd,unsigned char InterAdd,unsigned char WIICData)
     
262. {
     
263.         StartI2C();                                                                                      //启动总线
     
264.         SendByte(WChipAdd);                                                        //发送器件地址以及命令
     
265.         if (bAck==1)                                                                                          //收到应答
     
266.         {
     
267.                 SendByte(InterAdd);                                                                //发送内部子地址
     
268.                 if (bAck ==1)
     
269.                 {
     
270.                         SendByte(WIICData);                                                        //发送数据
     
271.                         if(bAck == 1)
     
272.                         {
     
273.                                 StopI2C();                    //停止总线
     
274.                                 return(0xff);
     
275.                         }
     
276.                         else
     
277.                         {
     
278.                                 return(0x03);
     
279.                         }                       
     
280.                 }
     
281.                 else
     
282.                 {
     
283.                         return(0x02);
     
284.                 }
     
285.         }
     
286.         return(0x01);
     
287. }
     
288. //读取指定器件的内部指定地址一个字节数据
     
289. unsigned char RIICByte(unsigned char WChipAdd,unsigned char RChipAdd,unsigned char InterDataAdd)
     
290. {
     
291.         unsigned char TempData;       
     
292.         TempData = 0;
     
293.         StartI2C();                                                                        //启动
     
294.         SendByte(WChipAdd);                                                    //发送器件地址以及读命令
     
295.         if (bAck==1)                                                                            //收到应答
     
296.         {
     
297.                 SendByte(InterDataAdd);                                        //发送内部子地址
     
298.                 if (bAck ==1)
     
299.                 {
     
300.                         StartI2C();
     
301.                         SendByte(RChipAdd);       
     
302.                         if(bAck == 1)
     
303.                         {
     
304.                                 TempData = RevByte();       //接收数据
     
305.                                 StopI2C();                  //停止I2C总线
     
306.                                 return(TempData);           //返回数据
     
307.                         }
     
308.                         else
     
309.                         {
     
310.                                 return(0x03);
     
311.                         }       
     
312.                 }
     
313.                 else
     
314.                 {
     
315.                         return(0x02);
     
316.                 }
     
317.         }
     
318.         else
     
319.         {
     
320.                 return(0x01);
     
321.         }
     
322. }
     
323. //报警子函数
     
324. void alarm(void)
     
325. {
     
326.           
     
327.          if(getdata>=208.611252)                 //如果当前压力值大于100kpa，
     
328.          {
     
329.           led=0;
     
330.           beep=0;                                                   //则启动报警
     
331.          }                          
     
332.                         
     
333.                
     
334.           else
     
335.          {
     
336.                  led=1;
     
337.                  beep=1;
     
338.                   
     
339. }                        //关闭报警
     
340. }
     
341.        
     
342.        
     
343. 
     
344. 
     
345. void main(void) //主程序
     
346. {
     
347.   unsigned int OverCounter = 0;
     
348.   unsigned char i;
     
349.   bit OverFlg = 0;
     
350.   unsigned int temp,ppress = 0;
     
351.   float  press;
     
352. 
     
353.   while(1)
     
354.          
     
355.   {
     
356. 
     
357.           display( );
     
358.           if((key1==0)||(key2==0))break;   //////////////此处为加的打断
     
359.           if
     
360.             if(getdata>=208.611252);
     
361.        TR0=1;          
     
362.           getdata=Adc0832(0);
     
363.           alarm();
     
364.           for(i=0;i<25;i++)
     
365.           if(14<getdata<243)                                       //当压力值介于15kpa到115kpa之间时，遵循线性变换
     
366.                  {                            
     
367.                   int vary=getdata;                                                //y=(115-15)/(243-13)*X+15kpa                       
     
368.                         press=((10.0/23.0)*vary)+9.5;                        //测试时补偿值为9.3                                                                                                          
     
369.                         temp=(int)(press*10);                  //放大10倍，便于后面的计算
     
370.       if(temp != ppress)
     
371.       {
     
372.         ppress = temp;
     
373.         OverFlg = 1;
     
374.       }                                                                                           
     
375.                         dispbuf[3]=temp/1000;                                     //取压力值百位
     
376.                         dispbuf[2]=(temp%1000)/100;                            //取压力值十位
     
377.                         dispbuf[1]=((temp%1000)%100)/10;                    //取压力值个位
     
378.                         dispbuf[0]=((temp%1000)%100)%10;                        //取压力值十分位
     
379.                         display();
     
380.           }
     
381.           }
     
382.               }
     
383.          
     
384. 
     
385.                    
     
386.   void Time0(void) interrupt 1 using 0          //中断，改变蜂鸣器声音
     
387. {
     
388.                  if(getdata>=208.611252);
     
389.         beep=~beep;           //蜂鸣器状态改变
     
390.         if( L_count!=0x00 )
     
391.         {
     
392.            L_count--;           //初值减小
     
393.            TH0=H_count;    //高位赋初值
     
394.        TL0=L_count;           //低位赋初值
     
395.        return;                   //返回主函数
     
396.      }else  H_count--;
     
397.                
     
398.         if( H_count!=0xfc )           //H_count从0xff降到0Xfc,周期结束
     
399.         {
     
400.            L_count--;
     
401.            TH0=H_count;
     
402.        TL0=L_count;
     
403.        return;
     
404.         }
     
405.         else
     
406.      {
     
407.          if(led==0);
     
408.         H_count=0xff;
     
409.         L_count=0xa0;
     
410.         TH0=H_count;
     
411.         TL0=L_count;
     
412.         beep=1;                          //关闭蜂鸣器
     
413.         TR0=0;                         //关闭定时器
     
414.      }   
     
415. }       

复制代码

---

作者: 华夏哈哈哈    时间: 2020-3-23 12:34
key按下时的截图：

51hei图片20200323123149.png (40.83 KB, 下载次数: 118)

下载附件

2020-3-23 14:46 上传

51hei图片20200323123117.png (38.78 KB, 下载次数: 111)

下载附件

2020-3-23 14:46 上传

---

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

Powered by Discuz! X3.1