代码:

1. #include <reg52.h>
   
2. #include "1602.h"
   
3. #include "delay.h"
   
4. 
   
5. sbit vo = P3^2;             // 用于检测P3.2口的值，计算时间。  计时器0的开与断
   
6. sbit tr = P3^7;                                                                 // 产生一个低电平脉冲
   
7.                                                                                   // 超量程提示灯
   
8. sbit ledclc = P2^0;
   
9. 
   
10. sbit con1 = P1^5;                            // 用于控制继电器，实现档位选择
    
11. sbit con2 = P1^6;                                                               
    
12. sbit con3 = P1^7;                                                               
    
13. 
    
14. sbit key1 = P1^0;                                                          // 独立按键部分，用于用户选择量程
    
15. sbit key2 = P1^1;
    
16. sbit key3 = P1^2;
    
17. sbit key4 = P1^3;
    
18. 
    
19. sbit led1 = P2^1;                                                          // 量程提示灯
    
20. sbit led2 = P2^2;
    
21. sbit led3 = P2^3;
    
22. sbit led4 = P2^4;
    
23. 
    
24. 
    
25. unsigned int tw;                                // 用于获取定时器的数值
    
26. 
    
27. float ftemp;                                                                         // 用于计算电容值的中间变量
    
28. 
    
29. unsigned long int c;                                                                // 存放电容值
    
30. 
    
31. unsigned char need;                                                         // 需要测量时置1，一次测量结束置0
    
32. unsigned char R;                            // 表示不同的档位
    
33. unsigned char flag;                                  // 数据处理结束置1
    
34. unsigned char temp[8];                        // 存放电容值的各个位         
    
35. unsigned char zimu1[] = " range is higher";                   //量程太高
    
36. unsigned char zimu2[] = "The value of Cap";
    
37. unsigned char zimu3[] = "please press key";
    
38. unsigned char zimu4[] = "     to measure ";
    
39. unsigned char zimu5[] = " range is lower ";        
    
40. void process(unsigned long int c);                         // 数据处理函数
    
41. void keyscan();                                                                 // 键盘扫描函数
    
42. void ledlight(unsigned char R);                                         //        量程指示灯函数
    
43. void init_timer0()                                     // 定时器0  初始化   
    
44. {
    
45.         TMOD = 0x09;                   // gate置1，方式1,16位计时，定时器由P3.2控制开断
    
46.         TH0 = 0x00;
    
47.         TL0 = 0x00;
    
48.         EA   = 1;
    
49.         ET0 = 1;                                            
    
50.         TR0 = 1;
    
51. }
    
52. void init_INT1 ()                                                                    // 定时器0  初始化
    
53. {
    
54.         EA = 1;
    
55.         IT1 = 1;                                      // 下降沿触发
    
56.         EX1 = 1;
    
57. }                  
    
58. void main()
    
59. {
    
60.          ledclc = 1;                                                                    // 超量程提示灯熄灭
    
61.          need = 0;                                                // 一开始无需测量
    
62.     con1 = con2 = con3 = 1;
    
63.         flag = 0;
    
64.           init_timer0();                                                                    // 初始化
    
65.         init_INT1();
    
66.         LCD_init();
    
67.          dispchar1(zimu3);
    
68.         dispchar2(zimu4);
    
69.         while(1)
    
70.         {
    
71.                   if(need == 1)
    
72.                 {                                                                                        // 当需要测量时
    
73.                         if(vo == 0 ) //vo == 0时检测计数器的值可能还没开始计数，可能计数结束
    
74.                         {
    
75.                                  if(TH0 != 0x00 || TL0 != 0x00) // 是计数结束 若有读数，用tw 存下
    
76.                                  {
    
77.                                           tw = TH0 << 8;
    
78.                                          tw = tw | TL0;        
    
79.                                          TH0 = 0x00;                               // 一次结束，计时器清零
    
80.                                          TL0 = 0x00;
    
81.                      need = 0;    // 需要再次测量时，need置1.避免tw的值被更//改   即不需要测量时，一直保持
    
82.                                          EX1 = 1;                                                 // 开外部中断1
    
83.                                  }
    
84.                                  else          // 反之，证明没有计数，无电容，默认值tw置0
    
85.                                  {
    
86.                                          tw = 0;
    
87.                                  }
    
88.                         }
    
89. 
    
90.                         ftemp = tw / 1.1  ; // 计算电容值   根据公式 tw = 1.1 * R * C
    
91. 
    
92.                         c = (unsigned long int)(ftemp )*100;    //扩大了一百倍   便于后续程序
    
93. //取两位小数点
    
94.                         process(c);                 // 调用数据处理函数，根据不同的R值进行处理                                                                                                                                                        
    
95.                 }                                                         
    
96.                 if(flag == 1 ) // 数据处理结束   每次处理结束，证明需要更新显示的数据
    
97.                 {
    
98.                         if(tw>=50000 || ledclc == 0)                        // 量程超出
    
99.                         {
    
100.                                 dispchar3(zimu1);               // 量程太高
     
101.                                 ledclc = 0;
     
102.                         }                                                
     
103.                         else if(tw<=100 && ledclc == 1)                   //量程太低
     
104.                         {
     
105.                                 dispchar3(zimu5);
     
106.                                 ledclc = 0;
     
107.                         }
     
108.                         else   
     
109.                       {
     
110.                                 dispchar1(zimu2);
     
111.                                 disp(temp);
     
112.                         }                                                         
     
113.                         flag = 0;
     
114.                 }               
     
115.                 keyscan();
     
116.         }   
     
117. }
     
118. 
     
119. void timer0()  interrupt 1                      // 定时器0中断  用于超量程提示
     
120. {
     
121.          ledclc = 0;
     
122. }
     
123. 
     
124. void exint1        () interrupt 2          // 外部中断0  用于产生低脉冲，启动555定时器
     
125. {
     
126.         unsigned char a;
     
127.         tr = 1;                                                            // tr端一个负脉冲
     
128.         a = 1;
     
129.         while(--a);
     
130.         tr = 0;
     
131.         a = 20;
     
132.         while(--a);
     
133.         tr = 1;                               // tr端负脉冲结束           大约40us的负脉冲
     
134.         need = 1;                                                                                // 表示需要测量
     
135.         ledclc = 1;                                                                            // 关闭先前的超量程提示
     
136.         EX1 = 0;                 // 暂时关闭外部中断，一次测量结束，再开放外部中断
     
137. }
     
138. 
     
139. void process(unsigned long int c)
     
140. {
     
141.                 if(R == 1)          // 10M         的电阻                   量程10pf ~ 5000pf
     
142.                 {
     
143.                         c = c /10;                  
     
144.                          lcd_pos(0x4a);
     
145.                            LCD_write_Data(' ');
     
146.                         LCD_write_Data('p');
     
147.                         LCD_write_Data('f');
     
148.                         LCD_write_Data(' ');
     
149.                         LCD_write_Data(' ');
     
150.                 }
     
151.                 if(R == 2)                  // 100k 的电阻               量程5nf~ 500nf
     
152.                 {
     
153.                         c = c /100;                  
     
154.                          lcd_pos(0x4a);
     
155.                            LCD_write_Data(' ');
     
156.                         LCD_write_Data('n');
     
157.                         LCD_write_Data('f');
     
158.                         LCD_write_Data(' ');
     
159.                         LCD_write_Data(' ');                        
     
160.                 }
     
161.                 if(R == 3)                      //1k欧姆 的电阻                   量程0.5uf ~ 50uf
     
162.                 {
     
163.                         c = c /1000;                 // 扩大了一百倍 单位  c = tw/500   uf
     
164.                          lcd_pos(0x4a);
     
165.                            LCD_write_Data(' ');
     
166.                         LCD_write_Data('u');
     
167.                         LCD_write_Data('f');
     
168.                         LCD_write_Data(' ');
     
169.                         LCD_write_Data(' ');                     
     
170.                 }
     
171.                 if(R == 4)                 //100欧姆 的电阻                   量程50uf ~ 500uf
     
172.                 {
     
173.                         c = c /100;                  // 扩大了一百倍 单位  c = tw/500   uf
     
174.                          lcd_pos(0x4a);
     
175.                            LCD_write_Data(' ');
     
176.                         LCD_write_Data('u');
     
177.                         LCD_write_Data('f');
     
178.                         LCD_write_Data(' ');
     
179.                         LCD_write_Data(' ');                                                        
     
180.                 }
     
181.                 temp[0] = c / 100000;                                // 千位
     
182.                 temp[1] = c / 10000 % 10;                        // 百位                                       
     
183.                 temp[2] = c / 1000 % 10;                           // 十位
     
184.                 temp[3] = c / 100 %10;                            // 个位        
     
185.                 temp[4] = c / 10 % 10;            
     
186.                 temp[5] = c  % 10;
     
187.                 flag = 1;
     
188. }
     
189. void keyscan()
     
190. {
     
191.         if(key1 == 0)
     
192.         {
     
193.                 delay_ms(10);
     
194.                 if(key1 == 0)                                        //  b3按下
     
195.                 {
     
196.                         while(key1==0);
     
197.                         R = 1;        // 10M 的电阻               量程10pf~ 5000pf(5nf)
     
198.                         con1 = 0;
     
199.                         con2 = 0;
     
200.                         con3 = 0;
     
201.                         ledclc = 1;
     
202.                         dispchar1(zimu3);
     
203.                         dispchar2(zimu4);
     
204.                 }
     
205.         }
     
206.         if(key2 == 0)                                                                           //  b4按下
     
207.         {
     
208.                 delay_ms(10);
     
209.                 if(key2 == 0)
     
210.                 {
     
211.                         while(key2==0);
     
212.                         R = 2;             // 100k 的电阻               量程5nf~ 500nf
     
213.                         con1 = 1;
     
214.                         con2 = 1;
     
215.                         con3 = 0;
     
216.                         ledclc = 1;
     
217.                         dispchar1(zimu3);
     
218.                         dispchar2(zimu4);
     
219.                 }
     
220.         }
     
221. 
     
222.         if(key3 == 0)                                                                             //  b5按下
     
223.         {
     
224.                 delay_ms(10);
     
225.                 if(key3 == 0)
     
226.                 {
     
227.                         while(key3==0);
     
228.                         R = 3;
     
229.                         con1 = 0;       // 1k欧姆 的电阻                   量程0.5uf ~ 50uf
     
230.                         con2 = 1;
     
231.                         con3 = 1;
     
232.                         ledclc = 1;
     
233.                         dispchar1(zimu3);
     
234.                         dispchar2(zimu4);
     
235.                 }
     
236.         }
     
237.         if(key4 == 0)                                                                             //  b6按下
     
238.         {
     
239.                 delay_ms(10);
     
240.                 if(key4 == 0)
     
241.                 {
     
242.                         while(key4==0);
     
243.                         R = 4;
     
244.                         con1 = 0;       // 100欧姆 的电阻           量程50uf ~ 500uf
     
245.                         con2 = 0;
     
246.                         con3 = 1;
     
247.                         ledclc = 1;
     
248.                         dispchar1(zimu3);
     
249.                         dispchar2(zimu4);
     
250.                 }
     
251.         }
     
252.         ledlight(R);
     
253. }        
     
254. ……………………
     
255. 
     
256. …………限于本文篇幅 余下代码请从51黑下载附件…………