Hoje montaremos um capacímetro com Arduino. Capacitor é um componente elétrico/eletrônico básico, conhecido e presente em todos os circuitos elétricos.

Mesmo que não tenha um capacitor no circuito sempre haverá capacitância parasita em cabos/fios, entre circuitos diferentes e dentro de componentes como transistores e circuitos integrados.

   A ideia de criar um medidor de capacitâncias surgiu justamente do fato de ser um componente muito usado, aliado ao fato de que poucos multímetros “baratos” hoje em dia vem com capacímetro. O objetivo é dar ao maker/hobbista o poder de medir capacitâncias rapidamente, podendo verificar se o componente que tem em mãos é realmente o que parece.

   Para ser capaz de programar um capacímetro no Arduino (microcontrolador) nós temos que entender como um capacitor funciona e que tipo de grandeza elétrica devemos medir. Então vamos á um pouco de teoria!.

   Parafraseando a nossa queria Wikipedia: o capacitor é um componente eletrônico que consiste em (no mínimo) duas placas metálicas em paralelo separadas somente por um dielétrico (material não condutor) de espessura variável. Esta construção física torna o capacitor capaz de armazenar cargas elétricas em um campo elétrico criado entre as duas placas metálicas.

A equação básica que define a capacitância do capacitor

(em Farads) é C= Q / V  onde ‘Q’ é a quantidade de carga elétrica e ‘V’ é a tensão aplicada aos terminais do componente. Para conhecer o valor do capacitor nós podemos nos utilizar das variáveis ‘V’ (tensão) e ‘Q’ carga.

A carga mais especificamente pode ser escrita como corrente elétrica, caso seja utilizado um resistor ôhmico como limitador desta corrente.

   É justamente este efeito que observamos em um circuito RC (resistor-capacitor em série), cujo tempo de carga do capacitor pode ser utilizado para calcular sua capacitância.

Explico: multiplicando-se o valor de R (ohms) pelo valor de C (Farads) nós obtemos o valor de T (tau). Ele define o tempo que “demora” para a tensão sobre o capacitor chegar 63,2% da tensão total de alimentação.

   Portanto para conhecer a capacitância de um capacitor basta medir o tempo que ele demora para ser carregado com 63,2% da tensão inicialmente aplicada, através de um resistor de valor conhecido. O circuito abaixo é tudo que você precisa para montar seu capacímetro!.

O código (sketch)

Utilizado é visto abaixo e também está disponível na nossa página no GitHub. Logo abaixo você encontra explicações de como ele funciona.

/*
 * Capacimetro (medidor de capacitância em nF e uF) com Arduino UNO (ATMEGA328)
 * ________________________________________________________
 * Funcionamento:
 * 
 * - Ao acionar a saída digital 'pin' (2) o capacitor é carregado atraves do resistor
 * definido na variável "resistor"
 * - É contado o tempo entre o acionamento do pino 2 e a tensão sobre o capacitor
 * atingir 63,2% da tensão total (que é 5V), portanto 3,16V
 * A capacitância é então calculada: C(Farads)= T(segundos) / R(ohms)
 * - A saída 'pin' (2) é então colocada em '0' (LOW) para descarregar o capacitor
 * - O valor de capacitância (já com a unidade correta) é exibido em um monitor serial,
 * portanto é necessário conectar o Arduino à um computador
 * 
 * LIMITACOES: 
 * - Não mede capacitâncias abaixo de 44nF
 * - É lento para ler capacitâncias acima de 100uF
 * - Testado com: 100nF, 1uF, 10uF e 470uF
 * ________________________________________________________
 * 
 * Desenvolvido por: Clovis Fritzen em 04/11/2016
 * Mais informações: http://www.FritzenLab.com.br
 * 
 * ** caso REDISTRIBUIR/COPIAR este código, FAVOR ENVIAR ESTE CABEÇALHO !!! **
 * 

*/
#define analogica A0
#define pin 2


long t0, t;
int leituraAnalogica;
int constanteTau = 647; // 63.2% of 1024 !! (capacitor "Tau" constant)
String unidade = String("uF");
boolean escritaTela = false;
boolean contando = false;
float tempoEscrita = 0.00;
float tempoAnterior = 0.00;
float capacitancia = 0.000000;
float resistor = 3280;

void setup()
{
  Serial.begin(115200);
  pinMode(pin, OUTPUT);
  digitalWrite(pin, LOW);
  
}

void loop()
{
  leituraAnalogica= analogRead(analogica);
  
  if ((contando == false) && (leituraAnalogica <= 10)){
    digitalWrite(pin, HIGH);
    contando= true;
    t0 = micros();
  } else {
    //digitalWrite(pin, LOW);
  }

    
  if (leituraAnalogica >= constanteTau){
    t = micros()-t0;  // calculate elapsed time
    contando = false;
    capacitancia = t / resistor;
    if (capacitancia <= 1.0) {
      capacitancia *= 1000;
      if (capacitancia < 44){
        t= 0;
        capacitancia = 0;
      }
      unidade = " nF";
    } else {
      unidade = " uF";
    }
    
      digitalWrite(pin, LOW);
      escritaTela= true;
      /*Serial.print("tempo= ");
      Serial.print(t);
      Serial.println(" uS");*/
          
    } else {
    
  } 

tempoEscrita = micros() - tempoAnterior;
if ((escritaTela == true) && tempoEscrita > 1000000){
  tempoAnterior = micros();  
  escritaTela = false;
  Serial.print("Capacitancia= ");
  Serial.print(capacitancia,2);
  Serial.println(unidade);
       
}
  

}

O circuito é visto abaixo e funciona da seguinte forma:

• É dado o comando para ligar (colocar em nível alto, 5V) o pino digital 2; isto faz com que o capacitor comece a ser carregado. Também é disparada uma contagem de tempo em microssegundos.
• Fica-se constantemente lendo a tensão sobre o capacitor, através da entrada analógica A0;
• Quando a tensão sobre o capacitor atinge 63,2% de 5V (=3,16V ou 648 inteiros) o contador de tempo é parado e a capacitância é calculada. C (Farads) = T (segundos) / R (resistor de 3280 ohms).
• O valor de capacitância é enviado para o computador via porta serial (comando Serial.Print(capacitancia))
• Logo após o cálculo o pino digital 2 é colocado em nível baixo (0V) para descarregar o capacitor.
• A tensão sobre o capacitor é monitorada; quando ficar abaixo de 1% da tensão da fonte é iniciada uma nova medição (volta ao passo 1)!

Ao conectar seu Arduino no computador

E ligar um capacitor a ser medido, abra a IDE do Arduino e o monitor serial (imagem abaixo). A mensagem “Capacitância: xx.xx uF” será montrada com intervalos de um (segundo).

---

   Porém o circuito e o código tem algumas limitações, que o fazem capaz de ler apenas capacitâncias entre 47nF (nanoFarads) e alguns centenas de uF (microFarads):

• As funções/bibliotecas do Arduino são executadas muito lentamente; No código do meu capacímetro as funções analogRead() e digitalWrite() demoram 112uS (microssegundos) para serem executadas. Isto limita em 47nF a capacitância mínima que pode ser lida.
• O resistor de carga tem um valor muito alto (3k3 ohms) fazendo com que a carga de capacitores muito grandes (acima de 100uF) demore vários décimos de segundo. Por exemplo o capacitor de 470uF demora 1,5 segundos para ser carregado com 63,2% da tensão total. E mais 1,5 segundos para descarregar.

   Aqui estão algumas sugestões para tornar este capacímetro ainda melhor:

• Programar o Arduino com as bibliotecas de baixo nível (em C) do AVR, pois as instruções do código são executadas muito mais rapidamente do que o Arduino e suas bibliotecas. Isso permitiria medir capacitores muito menores (abaixo de 47nF).
• Utilizar dois valores de resistores diferentes; um menor que 3k3 ohms e outro bem maior (330k ohms) e um em cada pino do Arduino.
• Isto permitiria “selecionar” qual resistor utililzar para a carga de um determinado capacitor, o que permitiria carregar  capacitores maiores em menor tempo, e capacitores menores  em maior tempo.
• Incluir um display LCD, para que as medições possam ser lidas sem utilizar um computador!.

Caso queira, veja outro artigo: fazendo um teclado analógico com Arduino.