Capacímetro com Arduino

Introdução

Um resistor carrega 63,2% de um capacitor em 'TC' segundos, sendo

TC = R x C

• TC: chamada de constante de tempo e dada em segundos;
• R: resistência elétrica, dada em ohms
• C: capacitância, dada em farads

Isto é, a tensão elétrica no capacitor após TC segundos de carga é igual à 63,2% da tensão elétrica de carga.

Na prática, pode-se considerar que o capacitor carrega-se totalmente após cinco constantes de tempo.

Experimento

O esboço abaixo funciona porque os pinos do Arduino podem estar em um dos dois estados abaixo, que são eletricamente bem diferentes:

• Estado de entrada
  

  Alta impedância: demanda pouca energia do circuito a ser lido

  Bom para ler sensores, mas não para acender LEDs


• Estado de saída
  

  Baixa impedância: pode ser fonte de até 40 mA (polaridade positiva) ou drenar 40 mA (polaridade negativa)

  Bom para acender LEDs e alimentar outros circuitos, mas não para ler sensores

Além disso, os pinos podem estar em HIGH para carregar o capacitor e LOW para descarregá-lo.

Algoritmo do esboço do capacímetro

• Ajustar pino de descarga como entrada (de forma que ele não pode descarregá-lo)
• Registrar o horário inicial com millis()
• Ajustar o pino de carga para HIGH
• Averiguar continuamente a tensão no capacitor para saber se já chegou aos 63,2%
• Ao carregar o capacitor, subtrair o horário atual do horário inicial para saber o tempo de carga
• Dividir o tempo em segundos pela resistência em ohms e, assim, obter o valor da capacitância
• Descarregar o capacitor. Para isso:
  • Ajustar o pino de carga como entrada
  • Ajustar o pino de descarga como saída e lá pôr LOW
• Ler a tensão elétrica para certificar-se de que o capacitor está vazio
• Meia-volta ao início do algoritmo

Código

/*  Capacímetro_RC
 *  Paul Badger 2008
 *  Demonstra uso da constante de tempo RC como meio de medir o valor do capacitor 
 *
 * Theory
 *  Um capacitor carregar-se-á, via um resistor, em uma 
 *  constante de tempo, definida como TC segundos onde
 *    TC = R * C
 * 
 *    TC = constante de tempo expressa em segundos
 *    R = resistência em ohms
 *    C = capacitância em farads (1 microfarad (ufd) = .0000001 farad = 10^-6 farads ) 
 *
 *  A tensão no capacitor em uma constante de tempo
 *  é definida como 63.2% da tensão de carga.
 *
 * Montagem do hardware
 *  O capacitor a testar fica entre o ponto comum e o terra
 *  (não se esqueça: ligue o + do capacitor ao ponto comum)
 *  O resistor a testar fica entre o pino de carga
 *  (chargePin) e o ponto comum
 *  Um resistor de 220 ohms entre o pino de descarga
 *  (dischargePin) e o ponto comum
 *  Um fio entre o ponto comum e o pino analógico 
 *  (analogPin, entrada A/D)
 */

#define analogPin      0          // pino analógico a medir tensão no capacitor
#define chargePin      13         // pino a carregar o capacitor
#define dischargePin   11         // pino a descarregar o capacitor
#define resistorValue  10000.0F   // mude esse valor para o valor do seu resistor
                                  // o "F" informa o compilador que trata-se de um ponto flutuante

unsigned long startTime;
unsigned long elapsedTime;
float microFarads;                // variável ponto flutuante para efetuar os cálculos
float nanoFarads;

void setup(){
  pinMode(chargePin, OUTPUT);     // ajuste chargePin como saída
  digitalWrite(chargePin, LOW);  

  Serial.begin(9600);             // inicializa a comunicação serial para fins de depuração de erros
}

void loop(){
  digitalWrite(chargePin, HIGH);  // ponha HIGH em chargePin
  startTime = millis();

  while(analogRead(analogPin) < 648){       // 647 = 63.2% de 1023, que corresponde ao fim de escala
  }

  elapsedTime= millis() - startTime;
 // converta milissegundos a segundos ( 10^-3 ) e farads a microfarads ( 10^6 ), líquidos 10^3 (1000)  
  microFarads = ((float)elapsedTime / resistorValue) * 1000;   
  Serial.print(elapsedTime);       // imprima à saída serial
  Serial.println(" mS    ");       // imprima unidade e retorno de carro

  if (microFarads > 1){
    Serial.print((long)microFarads);  // imprima à saída serial
    Serial.println(" microFarads");   // imprima unidade e retorno de carro
  }
  else
  {
    // se o valor for menor que um microfarad, converta
    // a nanofarads (10^-9 farad). 
    // trata-se de um artifício para que Serial.print imprima pontos flutuantes

    nanoFarads = microFarads * 1000.0;      // multiplique por 1000 para converter a nanofarads (10^-9 farads)
    Serial.print((long)nanoFarads);         // imprima à saída serial
    Serial.println(" nanoFarads");          // imprima unidade e retornod de carro
  }

  /* descarregue capacitor  */
  digitalWrite(chargePin, LOW);             // ponha LOW em chargePin
  pinMode(dischargePin, OUTPUT);            // ajuste dischargePin como saída
  digitalWrite(dischargePin, LOW);          // ponha LOW
  while(analogRead(analogPin) > 0){         // espere até esvaziar capacitor
  }

  pinMode(dischargePin, INPUT);            // ajuste de novo o pino para entrada
}