在设计或调试电子设备时，了解电路板上使用的组件的值非常重要。使用万用表可以轻松测量和识别大多数组件，但大多数普通万用表没有测量电感和电容的功能，因为这很少需要。但是，没有电容，实际上就没有电路，而复杂的电路中可能包含电感。 LCR（电感-电容-电阻）测量仪可用于确定上述组件，但通常此类仪表非常昂贵。

在本文中我们将分享一种可以在一定程度上准确测量电感和电容的方法。为此，我们可以使用常见的8位微控制器。我用过PIC18F452。当然，只要保持计算和程序，任何其他微控制器都同样适用于该目的。我们还需要一个基于LM393双模拟比较器的小型外部模拟电路。该电路是一个简单的哈特莱振荡器（Hartley）。这个想法是测量振荡器的频率或时间周期。当将诸如电感之类的新组件引入振荡器时，其频率和时间周期都会发生变化。然后我们可以反算组件值。

PIC18F452是一款8位PIC18F系列单片机。在硬件方面比流行的PIC16F877A或PIC16F887要强大得多。但是，除了捕获比较模块 (CCP) 和定时器之外，我们不需要任何其他硬件。使用PIC18F的主要原因是其工作时钟速度为40MHz。

电路原理图

以下是电感电容测量仪的原理图：

所需的组件

我们将需要电路图中所示的所有组件。组件L2到L6和C4到C8是测试组件。旋转开关SW1和SW2仅在仿真原理图中使用，实际上不存在。 2×16字母数字LCD用于显示信息。连接到引脚C0的按钮用于模式选择。

代码

1. #include <18F452.h>  
   
2.   
   
3. #device *=16  
   
4.                                                                         
   
5. #fuses NOWDT, PUT, H4, BROWNOUT, BORV42
   
6. #fuses NOLVP, NODEBUG, NOCPB, STVREN, CPD
   
7. #fuses PROTECT, NOWRT, NOWRTB, NOWRTC
   
8. #fuses NOWRTD, NOEBTR, NOEBTRB, NOOSCSEN
   
9.   
   
10. #use delay(clock = 40M)   
    
11.                                                                         
    
12. #include "lcd.c"   
    
13.                                           
    
14. #define mode_button      input(pin_C0)   
    
15.                                                
    
16. #define C_cal_in_nF         100.0
    
17. #define L_cal_in_uH         100.0              
    
18. #define pi                            3.142                                                     
    
19. #define cal_delay               1000   
    
20. 
    
21. #define scaling_factor_c    ((10.0 / (4.0 * pi * pi * L_cal_in_uH)))   
    
22. #define scaling_factor_l     ((10.0 / (4.0 * pi * pi * C_cal_in_nF)))         
    
23.                                                                
    
24. unsigned int32 overflow_count = 0;                                                      
    
25. unsigned int32 pulse_ticks = 0;                                                   
    
26. unsigned int16 start_time = 0;  
    
27. unsigned int16 end_time = 0;                              
    
28.                                                                                                
    
29. void setup(void);                                                                             
    
30.   
    
31. #int_TIMER1                                                                                             
    
32. void TMR_ISR(void)                 
    
33. {                                                                                         
    
34.     overflow_count++;      
    
35. }              
    
36. 
    
37. #int_CCP1                                                
    
38.                                                   
    
39. void CCP_ISR(void)
    
40. {
    
41.     end_time = CCP_1;                                                                                         
    
42.     pulse_ticks = ((65536 * overflow_count) + end_time - start_time);
    
43.     start_time = end_time;
    
44.     overflow_count = 0;
    
45. }
    
46.   
    
47. void main(void)  
    
48. {
    
49.      short calibration_done = 0;                                                                                          
    
50.      unsigned char mode = 0;        
    
51.      unsigned long t = 0;      
    
52.      double ref = 0.0;
    
53.      double value = 0.0;
    
54.                  
    
55.      setup();                                                                              
    
56.      while(TRUE)                          
    
57.      {                                                                     
    
58.          t = (pulse_ticks);  
    
59.          value = ((double)t * (double)t);
    
60.          
    
61.          if(mode_button == FALSE)
    
62.          {
    
63.             delay_ms(60);                                             
    
64.             while(mode_button == FALSE);   
    
65.             calibration_done = 0;
    
66.             mode++;
    
67.             
    
68.             if(mode > 1)
    
69.             {
    
70.                 mode = 0;
    
71.             }
    
72.          }  
    
73.                               
    
74.          if(calibration_done == 0)
    
75.          {
    
76.              lcd_putc("\f");               
    
77.              lcd_gotoxy(1, 1);
    
78.              lcd_putc("Calibrating....");                                                               
    
79.              lcd_gotoxy(1, 2);              
    
80.              lcd_putc("Place no part.");                                                                 
    
81.              delay_ms(cal_delay);        
    
82.              lcd_putc("\f");   
    
83.             
    
84.              if(mode == 0)
    
85.              {   
    
86.                  ref = (value * scaling_factor_c);   
    
87.                  lcd_gotoxy(1, 1);  
    
88.                  lcd_putc("C.ref/nF:");         
    
89.                  lcd_gotoxy(1, 2);
    
90.                  printf(lcd_putc, "%3.1g   ", ref);   
    
91.                   
    
92.              }
    
93.             
    
94.              if(mode == 1)            
    
95.              {                                             
    
96.                  ref = (value * scaling_factor_l);
    
97.                  lcd_gotoxy(1, 1);  
    
98.                  lcd_putc("L.ref/uH:");        
    
99.                  lcd_gotoxy(1, 2);
    
100.                  printf(lcd_putc, "%3.1g   ", ref);   
     
101.              }  
     
102.             
     
103.              delay_ms(cal_delay);        
     
104.              lcd_putc("\f");
     
105.                                                   
     
106.              calibration_done = 1;
     
107.          }
     
108.          
     
109.          else
     
110.          {   
     
111.              lcd_gotoxy(1, 1);  
     
112.             
     
113.              switch(mode)
     
114.              {
     
115.                  case 1:
     
116.                  {
     
117.                      value = (value * scaling_factor_c);  
     
118.                      lcd_putc("Ind./uH:");      
     
119.                                                 
     
120.                      break;
     
121.                  }   
     
122.                                           
     
123.                  default:
     
124.                  {   
     
125.                      value = (value * scaling_factor_l);   
     
126.                      lcd_putc("Cap./nF:");        
     
127.                               
     
128.                      break;
     
129.                  }
     
130.              }
     
131.             
     
132.              value -= ref;
     
133.                      
     
134.              if((value < 0) || (value > 1000))            
     
135.              {              
     
136.                 value = 0;
     
137.              }  
     
138.                           
     
139.              lcd_gotoxy(1, 2);                              
     
140.              printf(lcd_putc, "%3.1g         ", value);   
     
141.          }
     
142.       
     
143.          delay_ms(100);                  
     
144.      };
     
145. }
     
146.   
     
147. void setup(void)                                      
     
148. {                        
     
149.      setup_wdt(WDT_OFF);  
     
150.      setup_adc(ADC_OFF);
     
151.      setup_adc_ports(NO_ANALOGS);                                                                                    
     
152.      setup_spi(SPI_DISABLED);   
     
153.      setup_psp(PSP_DISABLED);                  
     
154.      setup_ccp1(CCP_CAPTURE_RE);
     
155.      setup_ccp2(CCP_OFF);
     
156.      setup_low_volt_detect(LVD_43);                                                
     
157.      setup_timer_0(T0_OFF | T0_8_BIT);
     
158.      setup_timer_1(T1_INTERNAL);  
     
159.      setup_timer_2(T2_DISABLED, T2_DIV_BY_1, 16);
     
160.      setup_timer_3(T3_DISABLED);  
     
161.      set_timer0(0);
     
162.      set_timer1(0);  
     
163.      set_timer2(0);                                            
     
164.      set_timer3(0);
     
165.      enable_interrupts(INT_CCP1);      
     
166.      enable_interrupts(INT_TIMER1);
     
167.      enable_interrupts(global);  
     
168.      lcd_init();
     
169.      lcd_putc("\f");                              
     
170. }         

复制代码

代码说明

根据所讨论的理论知识，我们需要PIC18的高处理速度以及定时器和捕捉模块。我们还需要一个LCD来显示结果。下面显示的setup()函数显示了这些模块及其设置。

1. void setup(void)                                             
   
2. {                        
   
3. …
   
4.      setup_ccp1(CCP_CAPTURE_RE);
   
5. …
   
6.      setup_timer_1(T1_INTERNAL);  
   
7. …
   
8.      set_timer1(0);  
   
9. …
   
10.      enable_interrupts(INT_CCP1);      
    
11.      enable_interrupts(INT_TIMER1);
    
12.      enable_interrupts(global);  
    
13.      lcd_init();
    
14.      lcd_putc("\f");      
    
15. }

复制代码

CCP1模块设置为上升沿捕捉。这意味着CCP1将在检测到上升沿时捕获定时器1的计数。PIC单片机中的CCP模块通常工作在定时器1模块中，因此它的计数被捕获。捕获两个连续的上升沿会导致输入波形的周期测量。这是我们最需要的。

为了进一步使事情明显以并发方式工作，使用了中断。 CCP1中断在出现上升沿捕获时触发，定时器1中断用于跟踪定时器溢出。在处理定时器1溢出时，会存储当前和先前的捕获计数。这些将用于确定时间段。定时器1很少会溢出，因为它只会在输入波形的频率非常低时才会溢出，而这实际上永远不会发生。

1. #int_TIMER1                                                                                                                              
   
2. void TMR_ISR(void)                 
   
3. {         
   
4.     overflow_count++;      
   
5. }              
   
6.                                                                                                          
   
7. 
   
8. #int_CCP1                                                
   
9.                                                   
   
10. void CCP_ISR(void)
    
11. {
    
12.     end_time = CCP_1;                                                                                         
    
13.     pulse_ticks = ((65536 * overflow_count) + end_time - start_time);
    
14.     start_time = end_time;
    
15.     overflow_count = 0;
    
16. }

复制代码

PIC18的PLL用于将外部10MHz晶体振荡器时钟升频至40MHz。这反映在熔丝位和时钟设置中。

1. #fuses H4 ….
   
2.   
   
3. #use delay(clock = 40M)   

复制代码

但是，PIC通常每条指令需要4个时钟周期，因此有效的系统时钟频率为10MHz。

因此，定时器1的一个滴答时间是：

因此，在50kHz (20 µs) 的基本频率下，定时器1将计数：

参考电感和电容值可以简单地知道以下等式：

这同样适用于电感测量，公式简化如下：

固定常量在代码顶部的定义中定义

1. #define C_cal_in_nF         100.0
   
2. #define L_cal_in_uH         100.0              
   
3. #define pi                  3.142                                                                                                                                             
   
4. #define cal_delay           1000   
   
5.                                                                               
   
6. #define scaling_factor_c    ((10.0 / (4.0 * pi * pi * L_cal_in_uH)))   
   
7. #define scaling_factor_l    ((10.0 / (4.0 * pi * pi * C_cal_in_nF)))  

复制代码

现在假设我们要测量220nF。因此，对于这个电容量，振荡器频率将是：

定时器1将计数355个计数，同时从振荡器捕获此频率。

现在，如果我们使用前面显示的公式进行反算，则发现电容的值为：

是的，读数与实际值有点偏离，但与实际值足够接近。产生误差是因为计时器计数只能是整数。这个误差可以在代码中巧妙地补偿。

连接到引脚C0的按钮用于选择电感或电容测量模式。每次更改模式时，都需要进行校准。校准过程很简单。除了参考电容和电感外，我们只需要让我们的仪表不连接任何东西，如下面的电路图所示。这是Hartley振荡器，也是整个设备的核心部分。

在此期间，测量并保存参考分量值。 该值将在未知组件测量期间扣除。 在校准过程中，仪表的显示屏将显示不放置任何外部元件的说明。

校准完成后，可以对未知元件进行相应的放置和测量。这些工作在程序的主循环函数完成。

演示

以下是测量电容电感值的演示效果：

本文提到的所有文件可以在以下链接获取：

https://libstock.mikroe.com/projects/view/5038/inductance-capacitance-measurement-using-pic18-microcontroller