El siguiente artículo nos fue enviado por el lector Miguel Torres Gordo. ¡Diviértase leyendo y replicando!

Este es el prototipo para medir la capacitancia de un condensador con ATMega328p. Como la mayoría sabe, los pines digitales del microcontrolador tienen un voltaje de salida de 5 voltios. Utilizaremos este voltaje y la función ADC de los pines analógicos para realizar los cálculos necesarios y, por lo tanto, determinar la capacitancia de los condensadores.

Primero, un breve detalle sobre la carga de los condensadores. El circuito más sencillo para cargar un condensador y su curva de carga son:

Cuando conectamos un condensador al voltaje, podemos determinar el tiempo que tarda en cargarse hasta el 63,2% del voltaje de alimentación mediante la ecuación

T = R * C

donde T es la constante de tiempo constante en segundos, R es la resistencia en Ohmios del circuito y C es el valor del condensador en faradios.

¿Cómo puede entonces determinar el tiempo que se tarda en cargar hasta el 63.2%? La respuesta es: con la ayuda del ADC en los puertos analógicos, ya que el 63,2% de 5 voltios es 3,16 voltios. El circuito simplificado es:

El proyecto cuenta con un interruptor para seleccionar la medición de condensadores en los rangos μF-nF o nF-pF, así como una pantalla OLED para la visualización de las mediciones.

Materiales

• 1 x Nano V3.0 con Atmega328
• Resistencias: 2 x 1 kOhm, 1 x 10 kOhm, 1 x 220 Ohmios
• 1 x Pantalla OLED I2C 0.91 pulgadas 128x32 píxeles
• 1 x Interruptor
• Condensadores
• Cable de conexión con Placa de pruebas (o Piezas de Cabezal Macho y Hembra con Placa PCB)

Circuito del proyecto

Circuito de medición para valores altos (F-nF), selección del Pin D6 con el interruptor

Comenzamos a cargar el condensador con el pin A2 a través de la resistencia 10K, al mismo tiempo iniciamos un temporizador y medimos el voltaje en el pin A0. Sabemos que el voltaje suministrado por los pines es de 5 V. Así que, con el ADC sabemos que 5 V es igual al valor digital 1023 y 63,2% de 5 V es igual a 3,16 V, que es igual al valor 648. Cuando la lectura del pin A0 alcanza el valor 648, establecemos la fuente de alimentación y detenemos el temporizador. A continuación, divide el tiempo utilizado por la resistencia de 10K para determinar el valor del condensador, y luego el condensador se descarga.

Circuito de medición para valores pequeños (nF-pF), selección del pin D5 con el interruptor

Para los valores bajos, utilizamos la carga medida en los pines A3 y A0 respectivamente. Aplicamos el voltaje de 5 V al pin A3 a través de la resistencia de 220 Ohmios y empezamos a cargar el condensador. Utilizamos el ADC del pin A0. Si el valor es inferior a 976, significa que el valor del condensador está en el rango de los pF. Realizamos los cálculos necesarios con el rango de medición y error de la resistencia interna del Nano V3.0 con la resistencia externa.

Si el valor en A0 es mayor que 976, entonces configuramos el pin A0 para suministrar 5 V a la salida y el pin A3 para leer el voltaje. Contamos el tiempo en microsegundos y si en un tiempo de 400 ms el voltaje no alcanza los 5 V, realizamos los cálculos de la capacitancia del condensador con el valor de la resistencia pull-up interna, la medición del tiempo y el valor de conversión del ADC de la medida de voltaje en A3. Si el resultado del valor es mayor que 1000, la medición se realiza en μF, si es menor, se lleva a cabo en pF.

Código fuente

Siga el código fuente del sketch para el Arduino IDE (Descargar):

 / * Miguel Torres Gordo - Medidor de Capacitencia * /
 ​
 // Configuración de pantalla OLED
 #include 
 #include 
 #include 
 # INCLUYE 
 ​
 #define screen_width 128                            // Pantalla de ancho OLED
 #define screen_height 32                            // Pantalla de altura OLED
 ​
 // adafruit_ssd1306 objeto de clase                          
 Adafruit_ssd1306 monitor(Screen_width, Screen_height, &Cable, -1);   // -1 si compartir el PIN de restablecimiento de Arduino
 ​
 // Cambiar para seleccionar valores para medir
 En t Scalepf=5;
 En t Scalenf=6;
 ​
 // valores altos //
 #define analogpin a0 
 #define carepin a2
 #define warkpin a1
 #define resistorvalue 10000.0f                 // valor de resistencia 10k para cargar al condensador
 ​
 no firmado largo hora de inicio;
 no firmado largo tiempo transcurrido;
 flotador microfaradas;                
 flotador nanofarads;
 ​
 // valores bajos //
 const En t OUT_PIN = A3;
 const En t In_pin = A0;  
 const flotador In_stray_cap_to_gnd = 50.28;                    // valor con 220 resistencias 
                                               
 const flotador In_cap_to_gnd  = In_stray_cap_to_gnd;
 const flotador R_pullup = 30.0;  
 const En t Max_adc_value = 1023;
 ​
 vacío configuración() {
   De serie.empezar(9600);
   demora(100);
   De serie.imprimir("Inicializando la pantalla OLED");
 ​
   // Iniciar pantalla OLED en la dirección 0x3c
   si (!monitor.empezar(Ssd1306_switchcapvcc, 0x3c)) {
     De serie.imprimir(F("Pantalla Oled no encontrada"));
     por(;;); // no proceda, bucle para siempre
   }
 ​
   mono(Scalepf, APORTE);
   mono(Scalenf, APORTE);
 ​
   mono(OUT_PIN, PRODUCCIÓN);
   mono(In_pin, PRODUCCIÓN);
   mono(composición, PRODUCCIÓN);     
 }
 ​
 vacío círculo() {
 ​
   / *************************** Altos valores: escala 4F - 100nf ***************** ************************* /
 ​
   si (lectura digital(Scalenf)) {
   
     mono(OUT_PIN, PRODUCCIÓN);
     escritura digital(OUT_PIN, BAJO);                         // A3 como GND
     mono(analogpin, APORTE);                          // A0 leer el voltaje
   
     escritura digital(composición, ELEVADO);  
     hora de inicio = micros();
 ​
     tiempo (analógrafo(analogpin) < 648) {   }               // el condensador está cargando
 ​
     tiempo transcurrido = micros() - hora de inicio;
     microfaradas = ((flotador)tiempo transcurrido / Resistencia);
      
     si (microfaradas > 1) {
 ​
         monitor.cleardisplay();                                     // buffer limpio
         monitor.SetTextsize(1);                                     // Tamano del texto    
         monitor.SetTEXTCOLOR(Ssd1306_white);                        // texto de color   
         monitor.setcursor(1, 2);                                    // Posición de texto
         monitor.imprimir("Escala: 4f-100nf");
         monitor.setcursor(1, 12);
         monitor.imprimir(microfaradas);
         monitor.setcursor(50, 12);
         monitor.imprimir("UF");  
         monitor.monitor();                                          // mostrar texto en pantalla   
         demora(500);
 ​
     } demás {
 ​
         nanofarads = microfaradas * 783;
         monitor.cleardisplay();                                     // buffer limpio
         monitor.SetTextsize(1);                                     // Tamano del texto    
         monitor.SetTEXTCOLOR(Ssd1306_white);                        // texto de color   
         monitor.setcursor(1, 2);                                        // Posición de texto
         monitor.imprimir("Escala: 4f-100nf");
         monitor.setcursor(1, 12);
         monitor.imprimir(nanofarads);
         monitor.setcursor(50, 12);
         monitor.imprimir("NF");      
         monitor.monitor();                                          // mostrar texto en pantalla   
         demora(500);
  
     }
   
     escritura digital(composición, BAJO);            
     mono(farol, PRODUCCIÓN);            
     escritura digital(farol, BAJO);                        // descargar el condensador 
   
     tiempo (analógrafo(analogpin) > 0) {   }                 // espera hasta que el Capacitor sea descargado
 ​
     mono(farol, APORTE);                           // Esto establece el PIN a alta impedancia
   
     monitor.SetTextsize(1);                                         // Tamano del texto    
     monitor.SetTEXTCOLOR(Ssd1306_white);                            // texto de color   
     monitor.setcursor(1, 22);                                       // Posición de texto
     monitor.imprimir("DESCARGA.....");                    // Mensaje para mostrar   
     monitor.monitor();                                              // mostrar texto en pantalla   
     demora(1000);
  
   
   }
 ​
   / **************************** A escala de valores bajos 1nf - 1PF ***************** ************ /
 ​
   si (lectura digital(Scalepf)) {
     
     mono(composición, APORTE);
     mono(farol, APORTE);                       // configurar puertos con alta impedancia porque no se usa
 ​
     mono(In_pin, APORTE);
     escritura digital(OUT_PIN, ELEVADO);
     En t Val = analógrafo(In_pin);
     escritura digital(OUT_PIN, BAJO);
 ​
     si (Val < 976) {
       
       mono(In_pin, PRODUCCIÓN);
 ​
       flotador capacidad = ((flotador)Val * In_cap_to_gnd / (flotador)(Max_adc_value - Val))/2;                        
            
       monitor.cleardisplay();                                       // buffer limpio
       monitor.SetTextsize(1);                                       // Tamano del texto    
       monitor.SetTEXTCOLOR(Ssd1306_white);                          // texto de color   
       monitor.setcursor(1, 2);                                      // Posición de texto
       monitor.imprimir("Escala: 1nf-1pf");                // Mensaje para mostrar
       monitor.setcursor(1, 12);                     // Posición de texto
       monitor.imprimir(capacidad);                 // valor para mostrar
       monitor.setcursor(50, 12);
       monitor.imprimir("PF");    
       monitor.monitor();                                            // mostrar texto en pantalla   
       demora(200);
 ​
     } demás {
 ​
       mono(In_pin, PRODUCCIÓN);
       demora(1);
       mono(OUT_PIN, Input_pullup);
       no firmado largo u1 = micros();
       no firmado largo t;
       En t DigVal;
 ​
       hacer {
         DigVal = lectura digital(OUT_PIN);
         no firmado largo U2 = micros();
         t = U2 > u1 ? U2 - u1 : u1 - U2;
       } tiempo ((DigVal < 1) && (t < 400000l));
 ​
       mono(OUT_PIN, APORTE);
       Val = analógrafo(OUT_PIN);
       escritura digital(In_pin, ELEVADO);
       En t extravío = (En t)(t / 1000 l) * 5;
       
       demora(extravío);   
       
       mono(OUT_PIN, PRODUCCIÓN);  
       escritura digital(OUT_PIN, BAJO);
       escritura digital(In_pin, BAJO);
 ​
       flotador capacidad = -(flotador)t / R_pullup / Iniciar sesión(1.0 - (flotador)Val / (flotador)Max_adc_value);
       
       si (capacidad > 1000.0) {
         monitor.cleardisplay();                                         // buffer limpio
         monitor.SetTextsize(1);                                         // Tamano del texto    
         monitor.SetTEXTCOLOR(Ssd1306_white);                            // texto de color   
         monitor.setcursor(1, 2);                                        // Posición de texto
         monitor.imprimir("Escala: 1nf-1pf");
         monitor.setcursor(1, 12);
         monitor.imprimir(capacidad/1000.0, 3);
         monitor.setcursor(50, 12);
         monitor.imprimir("UF");      
         monitor.monitor();                                              // mostrar texto en pantalla   
         
         demora(200);    
       
       } demás {
         monitor.cleardisplay();                                         
         monitor.SetTextsize(1);                                             
         monitor.SetTEXTCOLOR(Ssd1306_white);                                
         monitor.setcursor(1, 2);                                        
         monitor.imprimir("Escala: 1nf-1pf");
         monitor.setcursor(1, 12);
         monitor.imprimir(capacidad, 3);
         monitor.setcursor(50, 12);
         monitor.imprimir("PF");      
         monitor.monitor();                                                  
         
         demora(200); 
       }
     }         
     tiempo (micros() % 1000 != 0);
   }
 }

Fotos del proyecto

Gracias a Miguel Torres Gordo por su contribución.