基于单片机开发的电阻电容测量仪仿真+源程序

设计中采用利用振荡频率来完成对电阻电容的测量。需要注意的是，对电阻电容的测量需要自己通过按键功能来选择。电容测量的范围0-10000pf,电阻这边是小于1兆欧的可以测量。下面是程序。

电阻电容测量仪仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）



单片机源程序如下:

1. #include"reg52.h"
   
2. #include"stdio.h"
   
3. #include"math.h"
   
4. #include"absacc.h"
   
5. #include"intrins.h"
   
6. 
   
7. typedef unsigned char uchar;
   
8. typedef unsigned int  uint;
   
9. 
   
10. unsigned char inte=0;                                
    
11. float  uu=0;                                
    
12. unsigned long int ff=0;       
    
13. unsigned long int DL,DH;
    
14. 
    
15. sbit sc=P1^6;
    
16. sbit sr=P1^7;
    
17. sbit fw=P3^5;       
    
18. sbit srg=P1^2;
    
19. sbit srd=P1^3;       
    
20. sbit scg=P1^4;
    
21. sbit scd=P1^5;  
    
22. sbit fr=P1^0;
    
23. sbit fc=P1^1;
    
24. sbit LED=P3^7;
    
25. 
    
26. sbit rs=P2^2;            
    
27. sbit rw=P2^1;           
    
28. sbit en=P2^0;
    
29. 
    
30. sbit CS   = P3^4;
    
31. sbit Clk = P3^3;
    
32. sbit DATI = P3^2;
    
33. sbit DATO = P3^2;
    
34. 
    
35. 
    
36. /*******************************定义全局变量********************************/
    
37. unsigned char dat = 0x00;                      //AD值
    
38. unsigned char CH;  
    
39. 
    
40. unsigned char code table[]={"0123456789"};
    
41. 
    
42. #define count_M1 50000
    
43. #define H_0 (65536-count_M1)/256
    
44. #define L_0 (65536-count_M1)%256
    
45. char times=0;
    
46. 
    
47. bit status_F=1;
    
48. char scan=1;
    
49. unsigned int freq=0;
    
50. sfr16 DPTR=0x82;
    
51. 
    
52. void delay1ms(int);
    
53. void display(uint x);
    
54. void display1(uint dat);
    
55. 
    
56. //入口参数:CH  出口参数:dat
    
57. unsigned char adc0832(unsigned char CH)
    
58. {
    
59.         unsigned char i,test,adval;
    
60.     adval = 0x00;
    
61.     test = 0x00;
    
62. 
    
63.     Clk = 0;       //初始化
    
64.     DATI = 1;
    
65.         _nop_();
    
66.     CS = 0;
    
67.     _nop_();
    
68.     Clk = 1;
    
69.            _nop_();
    
70. 
    
71.         if ( CH == 0x00 )      //通道选择
    
72.            {
    
73.              Clk = 0;
    
74.                DATI = 1;      //通道0的第一位
    
75.                _nop_();
    
76.               Clk = 1;
    
77.         _nop_();
    
78.         Clk = 0;
    
79.               DATI = 0;      //通道0的第二位
    
80.               _nop_();
    
81.               Clk = 1;
    
82.               _nop_();
    
83.     }
    
84.     else
    
85.     {
    
86.                 Clk = 0;
    
87.               DATI = 1;      //通道1的第一位
    
88.                _nop_();
    
89.                Clk = 1;
    
90.                _nop_();
    
91.               Clk = 0;
    
92.               DATI = 1;      //通道1的第二位
    
93.             _nop_();
    
94.              Clk = 1;
    
95.              _nop_();
    
96.     }
    
97. 
    
98.     Clk = 0;
    
99.     DATI = 1;
    
100. 
     
101.     for( i = 0;i < 8;i++ )      //读取前8位的值
     
102.     {
     
103.                 _nop_();
     
104.                adval <<= 1;
     
105.                Clk = 1;
     
106.                _nop_();
     
107.                Clk = 0;
     
108.                if (DATO)
     
109.                 adval |= 0x01;
     
110.               else
     
111.                   adval |= 0x00;
     
112.     }
     
113. 
     
114.         for (i = 0; i < 8; i++)      //读取后8位的值
     
115.     {
     
116.                 test >>= 1;
     
117.         if (DATO)
     
118.                 test |= 0x80;
     
119.         else
     
120.         test |= 0x00;
     
121.         _nop_();
     
122.         Clk = 1;
     
123.         _nop_();
     
124.         Clk = 0;
     
125.     }
     
126.         if (adval == test)      //比较前8位与后8位的值，如果不相同舍去。若一直出现显示为零，请将该行去掉
     
127.             dat = test;
     
128.               _nop_();
     
129.                CS = 1;        //释放ADC0832
     
130.                DATO = 1;
     
131.                Clk = 1;
     
132.               return dat;
     
133. }
     
134. 
     
135. void delay(uint n)                          
     
136. {
     
137.     uint x,y;
     
138.     for(x=n;x>0;x--)
     
139.     for(y=110;y>0;y--);
     
140. }
     
141. 
     
142. 
     
143. void lcd_wcom(uchar com)           
     
144. {
     
145.     rs=0;               
     
146.     rw=0;               
     
147.     P0=com;           
     
148.     delay(5);      
     
149.     en=1;           
     
150.     en=0;
     
151. }
     
152. 
     
153. 
     
154. void lcd_wdat(uchar dat)      
     
155. {
     
156.     rs=1;            
     
157.     rw=0;            
     
158.     P0=dat;        
     
159.     delay(5);      
     
160.     en=1;        
     
161.     en=0;
     
162.   }
     
163. 
     
164. 
     
165. void lcd_init(void)            
     
166. {
     
167.     lcd_wcom(0x38);           
     
168.     lcd_wcom(0x0c);      
     
169.     lcd_wcom(0x06);   
     
170.     lcd_wcom(0x01);   
     
171. }
     
172. 
     
173. 
     
174. void lcd_xianshi1(void)            
     
175. {
     
176.         lcd_wcom(0x80+0x40);
     
177.     lcd_wdat('D');
     
178.     lcd_wdat('i');
     
179.     lcd_wdat('a');
     
180.     lcd_wdat('n');
     
181.     lcd_wdat('Z');
     
182.     lcd_wdat('u');
     
183. 
     
184.         lcd_wdat(':');
     
185.         lcd_wcom(0x80+0x4e);
     
186.     lcd_wdat(' ');
     
187.     lcd_wdat('K');
     
188. }
     
189. 
     
190. 
     
191. void lcd_xianshi2()            
     
192. {
     
193.     lcd_wcom(0x80+0x40);
     
194.     lcd_wdat('D');
     
195.     lcd_wdat('i');
     
196.     lcd_wdat('a');
     
197.     lcd_wdat('n');
     
198.     lcd_wdat('R');
     
199.     lcd_wdat('o');
     
200.     lcd_wdat('n');
     
201.     lcd_wdat('g');
     
202. 
     
203.     lcd_wdat(':');
     
204.     lcd_wcom(0x80+0x4e);
     
205.     lcd_wdat('p');
     
206.     lcd_wdat('F');
     
207. }
     
208. 
     
209. 
     
210. 
     
211. void xuanze()
     
212. {
     
213.         lcd_wcom(0x80+0x00);  //Please choose
     
214.    
     
215.     lcd_wdat(' ');
     
216.     lcd_wdat('P');
     
217.     lcd_wdat('l');
     
218.     lcd_wdat('e');
     
219.     lcd_wdat('a');
     
220.     lcd_wdat('s');
     
221.     lcd_wdat('e');
     
222.     lcd_wdat(' ');
     
223. 
     
224.         lcd_wdat('c');
     
225.         lcd_wdat('h');
     
226.         lcd_wdat('o');
     
227.         lcd_wdat('o');
     
228.         lcd_wdat('s');
     
229.         lcd_wdat('e');
     
230.         lcd_wdat(':');
     
231. 
     
232.         lcd_wcom(0x80+0x40);   //Cap or Res
     
233.                
     
234.         lcd_wdat(' ');
     
235.         lcd_wdat(' ');
     
236.         lcd_wdat(' ');
     
237. 
     
238.         lcd_wdat('C');
     
239.         lcd_wdat('a');
     
240.         lcd_wdat('p');
     
241.         lcd_wdat(' ');
     
242. 
     
243.         lcd_wdat('o');
     
244.         lcd_wdat('r');
     
245.         lcd_wdat(' ');
     
246. 
     
247.         lcd_wdat('R');
     
248.         lcd_wdat('e');
     
249.         lcd_wdat('s');
     
250. }
     
251. 
     
252. 
     
253. void huanying()
     
254. {
     
255.         lcd_wcom(0x80+0x00);  //Welcome to use
     
256.     lcd_wdat(' ');
     
257.     lcd_wdat('W');
     
258.     lcd_wdat('e');
     
259.     lcd_wdat('l');
     
260.     lcd_wdat('c');
     
261.     lcd_wdat('o');
     
262.     lcd_wdat('m');
     
263.     lcd_wdat('e');
     
264.     lcd_wdat(' ');
     
265. 
     
266.         lcd_wdat('t');
     
267.         lcd_wdat('o');
     
268.         lcd_wdat(' ');
     
269. 
     
270.         lcd_wdat('u');
     
271.         lcd_wdat('s');
     
272.         lcd_wdat('e');
     
273. }
     
274. 
     
275. void measure(void)
     
276. {       
     
277.         IE=0x8a;  
     
278.         EA=1;
     
279.         ET1=1;
     
280.         ET0=1;
     
281.         TMOD=0x51;
     
282.         TH0=H_0;
     
283.         TL0=L_0;
     
284.         TH1=0;
     
285.         TL1=0;
     
286. 
     
287.         TR0=1;
     
288. //        while(fw==1);                                          //测得引脚P3^5为高电平
     
289.     TR1=1;                                                          //timer1 开始计数
     
290. //  while(fw==0);                                        //测得引脚P3^5为低电平
     
291. //  TR1=0;
     
292.                                                                 //timer1 停止计数
     
293. //  DL=TL1;                                                        //读当前计数值
     
294. //  DH=TH1;
     
295. ///        freq=DPTR;
     
296. //        TH1=100;
     
297. //        TL1=100;
     
298. //  uu=DH*256+DPL+inte*65536;                        //计算总计数值  
     
299. //  inte=0;                                                        //清累计溢出计数
     
300. //  tt=uu/(12*1000000.0/12.0);                //求振荡周期
     
301. //  ff=(unsigned long int)(1.0/tt);         //频率值       求震荡频率
     
302. }
     
303. 
     
304. void yunsuan (void)
     
305. {
     
306.         float tt=0;  
     
307. //        DPH=11;
     
308. //        DPL=12;
     
309.         uu=DH*256+DL+inte*65536;                        //计算总计数值  
     
310.         inte=0;                                                        //清累计溢出计数
     
311.         tt=uu/(12*1000000.0/12.0);                //求振荡周期
     
312.         ff=(unsigned long int)(1.0/tt);         //频率值       求震荡频率                       
     
313. }
     
314. void judgekey1()
     
315. {   
     
316.     long int R=0;
     
317. 
     
318. 
     
319. //  R=(dat*1000)/(255-dat);
     
320.         R=10*dat-130;
     
321.         display(R);
     
322.         LED=~LED;
     
323. }
     
324. 
     
325. void judgekey2()
     
326. {   
     
327.     long int C=0;
     
328.         if(scd==0)
     
329.         {                  
     
330. //      C=3193333.0/freq;
     
331.                 C=((9.4*ff)-200)*0.8;
     
332.                 display1(C);
     
333.                 LED=~LED;            
     
334.         }
     
335.         else if (scg==0)
     
336.         {  
     
337. //                C=3193333.0/ff;
     
338.                 C=(9.4*ff)-200;
     
339.                 display1(C);
     
340.                 LED=~LED;
     
341.         }                
     
342. }
     
343.                
     
344.                  
     
345. 
     
346. void display(uint x)
     
347. {
     
348.     uchar qian,bai1,shi1,ge1;
     
349.     qian=x/1000;
     
350.     bai1=(x%1000/100);
     
351.     shi1=(x%100/10);
     
352.     ge1=x%10;
     
353. //  lcd_wcom(0x80+0x0b);
     
354.         lcd_wcom(0x80+0x49);
     
355.         if(qian==0)
     
356.         {lcd_wdat(' ');}
     
357.         else if(qian!=0)
     
358.         {lcd_wdat(table[qian]);}
     
359.     lcd_wdat(table[bai1]);
     
360.     lcd_wdat(table[shi1]);
     
361.     lcd_wdat(table[ge1]);
     
362. }
     
363. void display1(uint y)
     
364. {
     
365.         uchar qian0,bai0,shi0,ge0;
     
366.         qian0=y/1000;
     
367.     bai0=(y%1000/100);
     
368.     shi0=(y%100/10);
     
369.     ge0=y%10;
     
370.         lcd_wcom(0x80+0x49);
     
371.         if(qian0==0)
     
372.         {lcd_wdat(' ');}
     
373.         else if(qian0!=0)
     
374.         {lcd_wdat(table[qian0]);}
     
375.     lcd_wdat(table[bai0]);
     
376.     lcd_wdat(table[shi0]);
     
377.     lcd_wdat(table[ge0]);
     
378. }
     
379. 
     
380. void main(void)
     
381. {       
     
382. //  fw=1;
     
383.         LED=0;
     
384.     CH = 0x00;       //在这里选择通道 0x00或0x01
     
385.         lcd_init();
     
386.         measure();
     
387.         sr=sc=1;   
     
388.         while(1)
     
389.     {
     
390.         if(sr==0)
     
391.         {
     
392.         lcd_init();
     
393.         while(sr==0)
     
394.        {  
     
395.                  huanying();
     
396. //             fr=1;
     
397. //       fc=0;
     
398. //                 TR0=1;
     
399. //       TR1=1;
     
400. //                  measure();
     
401. //                 status_F=0;
     
402. //                 measure();
     
403. //                 while(status_F==0);
     
404.                  lcd_xianshi1();
     
405. //                 TR1=1;                            
     
406. //                 yunsuan();
     
407.                  dat=adc0832(CH);
     
408. //            dat=123;
     
409. //                 display(dat);
     
410.                  judgekey1();
     
411. //           display();
     
412.         }
     
413.         }
     
414. 
     
415. 
     
416.         else if(sc==0)
     
417.         {
     
418.         lcd_init();
     
419.     while(sc==0)
     
420. ……………………
     
421. 
     
422. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
基于单片机的电阻电容测量 程序 仿真.rar (119 KB, 下载次数: 283)

2018-4-25 02:43 上传

点击文件名下载附件
程序+仿真

学习一下

试一试，看看行不行！

aing123 发表于 2018-5-29 14:38
试一试，看看行不行！

可以用吗

51做的产品符合工业级吗？

学习，谢谢分享。。。。。。。。。。。。。。。。。

letme123 发表于 2018-7-10 10:27
可以用吗

不可以

给力。。。。。

新手 上路 回去试试

学习一下

有基于51单片机的电容测量仪的整个资料吗？我觉得你这个还是很好的 但是我只想要电容的 而且要详细的 感谢

挺好的，加油！

学习一下  

下载下来了，却不知道怎么用，程序跟图对不上

程序里面有条解释是：启用ADC0832，但仿真里面为什么没有这个软件

想装一台不知道测量阻值精度如何

真牛。顶一个