Capacímetro com Arduino

Através da compreensão das equações de carga e descarga de capacitores faremos a montagem de um protótipo de capacímetro com uso do microcontrolador Arduino UNO. 

Basicamente pode-se afirmar que após a constante de tempo t (tau) = R.C carrega-se 63,2% da carga total do capacitor. A partir desta premissa pode-se encontrar o valor do capacitor utilizando-se do tempo discorrido e um resistor base para cálculo.

Caso você já tenha algum conhecimento de eletrônica ou arduino poderá ir diretamente ao desenvolvimento do capacímetro.

Índice do Projeto:

:: O Funcionamento do Capacitor
:: Circuito RC
:: O Capacímetro com Arduino
:: O Arduino

O Funcionamento do Capacitor

Como a pilha, o capacitor possui dois terminais. Dentro do capacitor, os terminais conectam-se a duas placas metálicas separadas por um dielétrico. O dielétrico pode ser ar, papel, plástico ou qualquer outro material que não. conduza eletrecidade e impeça que as placas se toquem.

A capacitância, medida em Farads, depende da área das placas (A) e a distância entre elas (d) e da constante dielétrica (k). Em outras palavras, quanto maior a área (A) das armaduras, maior será a capacitância e vice versa. Quanto menor a distância (d) entre as armaduras, maior será a capacitância e vice versa. Quanto maior for a constante dielétrica K do isolante (dielétrico) maior será a capacitância e vice versa. Isso pode ser visto na equação 1:

onde “C” é a capacitância medida em Farads; 

“K” é a constante dielétrica; 

“E” é a permissividade do vácuo 8,84 x 10^-12 F / m; 

“A” é a área das placas em m²; 

^“d” é a distância entre as placas em metros. 

Geralmente, as placas condutoras de um condensador são separados por ar ou algum tipo de material de isolamento, em vez de vácuo do espaço livre.

Por exemplo, se o material dielétrico for o ar o “K” será 1,0009. Se o dielétrico for o vácuo será de 1. Se o material do dielétrico for, em outro caso, porcelana, o K será de 6[1]. 

 Circuito RC Simples

Em um circuito RC ideal simplificado (figura 2) — considerando a resistência interna da fonte de tensão como nula e desprezando-se a resistência dos fios condutores usados no circuito — ao aplicarmos uma tensão através de um resitor (R1), a um capacitor (C), este se carrega com um valor que depende do intervalo de tempo em que se desenvolve o processo.

Estando o capacitor inicialmente descarregado (Vc = 0 Volts, sendo Vc a tensão no capacitor), em t = 0 segundos, fechamos a chave S do circuito. Neste momento a corrente inicial do circuito(em Amperes) é

a medida que o capacitor se carrega, sua voltagem Vc  aumenta e a diferença de potencial através do resistor Vr aumenta ocorrendo em consequência uma diminuição da corrente no circuito. No entanto, a soma dessas duas voltagens(Vr e Vc) permanece constante e igual à força eletromotriz da fonte(Vt) :

depois do tempo de carga, o capacitor fica completamente carregado, a corrente torna-se nula e a diferença de potencial no resistor é igual a zero. Dessa forma a ddp final nos terminais do capacitor é igual à f.e.m. da bateria (Vt = Vc).

Equações De Carga E Descarga Do Capacitor

A equação que descreve  matematicamente a carga de um capacitor é:        

Sendo Vc(t) a tensão total do capacitor dada em volts, em função do tempo dado em segundos; Vcc a tensão da fonte também dada em volts; “e” é o número de Euller equivalente aproximadamente a 2,7128; “t” o tempo dado em segundos; R o valor do resistor em Ohms e C o valor do capacitor em Farads.

E a equação que descreve a descarga do capacitor é:

Onde  t = R . C  é a constante de tempo; sendo R o valor do Resistor em Ohms e C o valor do capacitor em Farads. A constante (t) apresentará o tempo de aproximadamente 63,2% da carga total do capacitor em segundos.

Por exemplo se t = 0s e substituirmos na equação 3 da tensão em C resultará zero e na equação da tensão na resistência resultará Vcc.

Teoricamente, de acordo com a equação 3, a carga total só acontecerá após um tempo infinito, mas na prática  bastam 5 constantes de tempo para considerarmos  o capacitor totalmente carregado (Para 5 constantes de tempo a tensão atingirá aproximadamente  99% de Vcc(tensão da fonte), ou seja, 99% da carga total possível). Veja o gráfico de carga e descarga na Figura 3. Observa-se que na constante de tempo(R.C) igual a 1 a carga do capacitor é de aproximadamente 63,2%. Este conhecimento será utilizado na produção do software de nosso capacímetro.

O comportamento da corrente no circuito, é descrito pela equação :

Onde I_Max, em ampéres, pela simples aplicação da lei de Ohm, é Vcc/R .

 

  

2.4 Exemplo De Carga De Capacitor

Vejamos agora um exemplo para confirmar os cálculos. Utilizaremos para tanto o circuito modelo da figura 4:

 

Após uma constante de tempo RC, o capacitor carrega com 63,2% da tensão da fonte.( 63,2% de V ).

t = R . C  

t = 100.10³. 100.10^--6 =10000.10^--3

t = 10 segundos

Assim, após 10 segundos o capacitor terá uma carga de 63,2% de V) e após 5.R.C, o capacitor está praticamente carregado com a tensão da fonte (99,3% de V).

t = 5.R.C = 5. (100.10³. 100.10^--6)

t = 50000.10^--3 segundos

t = 50 segundos

Sendo “t” o tempo total de carga total ou aproximadamente 99% da tensão total fornecida, em nosso exemplo V=12volts.

Nota-se que A função do resistor R é controlar o tempo de carga do capacitor. O tempo de carga depende diretamente do produto R.C.

Observemos a tabela da figura 4 que nos permite acompanhar a evolução da carga no capacitor de nosso exemplo:

Para calcularmos a descarga do capacitor em nosso circuito modelo utilizaremos a equação 4. Observemos os resultados na tabela da figura 6:

Observemos o desenvolvimento dos gráficos de carga e descarga do capacitor de nosso circuito exemplo através da figura 7:

O CAPACÍMETRO COM ARDUINO

O protótipo mostrará o valor do capacitor a ser medido em um LCD 16x2. Para tanto utilizamos duas protoboards para que os circuitos possam ser mais facilmente compreendidos.

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

t = R . C

·       t : 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 t 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 5 constantes de tempo.

A Figura 8 mostra o diagrama esquemático simplificado do capacímetro em conexão com o arduíno.

 

O gráfico da figura 9 permite exemplificar a carga do capacitor em função do tempo.

O Ambiente De Desenvolvimento Do  Arduino

O código deve ser digitado e carregado no Arduino através de sua interface própria. O Software de desenvolvimento Arduino é bastante fácil e intuitivo de se utilizar, não havendo qualquer nível de dificuldade. O primeiro passo consiste em efetuar o download do respectivo software de desenvolvimento, através do site oficial Arduino (www.arduino.cc).

 

Após o download e a instalação do software segue-se os passos:

1. Montagem do protótipo no protoboard sem conexão de energia para que não se danifique o arduíno ou os componentes;
2. Digita-se o código em seu ambiente próprio (figura 11);
3. Compila-se e o código (figura 12). Neste momento erros de sintaxe e lógicos serão apontados pelo compilador e devem ser corrigidos.
4. Faz-se o upload do código compilado (figura 13) sem erros no microcontrolador para ser executado.

 

 

 O CÓDIGO NO ARDUINO

O código arduíno faz uma adaptação da equação de tempo (t = RC) para C = t / R.

A chave para entendimento do código está no laço While que efetua a leitura da porta analógica do controlador até que este tenha atingido 63,2% da carga

while(analogRead(analogPin) < 648) {}

A leitura da porta analógica leva a que um valor compreendido entre 0 e 5 V, como a porta possui um conversor A/D este valor de tensão apresentar-se-á como um inteiro compreendido entre os valores (int) 0 e 1023.

O valor verificado no laço while (648)  corresponde exatamente a 63,2% de 1023.

Coleta-se o tempo discorrido até esse ponto (variável elapsedTime) e efetua-se o cálculo do valor do Capacitor

microFarads = ((float)elapsedTime / resistorValue *  1000).

A multiplicação por 1000 é para que haja a conversão do tempo de milisegundos para segundos.

A melhor compreensão deste segmento do código pode ser obtida através da observação do fluxograma da figura 16:

Abaixo o código completo a ser carregado no microcontrolador Arduino:

/* *************************************************** * 

  CAPACÍMETRO COM ARDUINO UNO

 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)

 */

#include <LiquidCrystal.h> //Inclui a biblioteca do LCD

LiquidCrystal lcd(9, 8, 5, 4, 3, 2); //Configura os pinos do Arduino para se comunicar com o LCD

#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

// valor do resistor base, o o "F" informa o compilador

// que trata-se de um ponto flutuante

#define resistorValue  10000.0F  

unsigned long startTime;

unsigned long elapsedTime;

float microFarads;                // variável ponto flutuante para efetuar os cálculos

float nanoFarads;

//Inicia uma variável inteira (temp), para escrever no LCD a //contagem do tempo

int  temp;

void setup()

{

    //Inicia o LCD com dimensões 16x2(Colunas x Linhas)

   lcd.begin(16, 2);

    //Posiciona o cursor na primeira coluna(0) e na primeira  

   // linha(0) do LCD

   lcd.setCursor(0, 0);

   lcd.print("FADEP-CapEdu 1.0"); //Escreve no LCD !"

   //Posiciona o cursor na primeira coluna(0) e na segunda  

   //linha(1) do LCD

   lcd.setCursor(0, 1);

 

   // ajuste chargePin como saída

   pinMode(chargePin, OUTPUT);          

   digitalWrite(chargePin, LOW); 

    // inicializa a comunicação serial para fins de depuração      

    //de erros

   Serial.begin(9600);           

}

void loop()

{

    lcd.setCursor(0, 1);

  

   // setar HIGH em chargePin

   digitalWrite(chargePin, HIGH);

   startTime = millis();

    // 647 = 63.2% de 1023, que corresponde ao fim de  

    // escala

    while(analogRead(analogPin) < 648)

    {     

          //Continua lendo a porta Analógica até que atinja os

          // 63,2% de carga

    }

   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

    if ((long)microFarads > 1)

    {

          Serial.print((long)microFarads);  // imprima na  serial

          Serial.println(" microFarads");   // imprima unidade

         

          lcd.setCursor(0, 1);

          lcd.print(microFarads);

          lcd.setCursor(8, 1);

          lcd.print("microF");

    }

    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

          // multiplique por 1000 para converter a nanofarads

         //(10^-9 farads)

          nanoFarads = (microFarads * 1000.0);                

        

         Serial.print((long)nanoFarads);         // imprima à saída

          Serial.println(" nanoFarads");          // imprima unidade

         

          lcd.setCursor(0, 1);

          lcd.print((long)nanoFarads);

          lcd.setCursor(8, 1);

          lcd.print("nanoF");

    }

    /* descarregue capacitor  */

      digitalWrite(chargePin, LOW);    //  LOW em chargePin

      pinMode(dischargePin, OUTPUT);  // ajuste  como saída

      digitalWrite(dischargePin, LOW);          // LOW

      // espere até esvaziar capacitor

      while(analogRead(analogPin) > 0)

     {  

      }

   

     // ajuste de novo o pino para entrada

     pinMode(dischargePin, INPUT);  

 }

  

Entendendo O Código Arduino

Em nosso código do capacímetro utilizaremos algumas das muitas funções do escopo do Arduíno. Abaixo segue uma explicação sintética bem como exemplo de sua utilização para que o entendimento do código se faça de forma absoluta:

Serial.begin(int baud rate)

Descrição: Instrução necessária para iniciar a comunicação série, permitindo definir qual a “baud rate” da comunicação. Os valores de velocidade de comunicação mais comuns para comunicação com um computador são: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 e 115200 (No entanto podem definir-se outros valores).

Sintaxe:  Serial.begin( int baud rate);

Exemplo:

(1) int leitura_serie=0; //Declaração de uma variável do tipo integer com o nome “leitura_serie”, inicializada com o valor “0”

(2) void setup() {

(3) Serial.begin(9600); // Permite a inicialização da comunicação Série

(4) }

(5) void loop(){

(6) if(Serial.available()>0) // Condição if que verifica se estão sendo recebidos dados por Série

(7) leitura_serie=Serial.read(); // Caso esteja-se recebendo dados por série, o seu valor é guardado na variável integer “leitura_serie”

(8) }

(9) }

Serial.read()

Descrição: Permite a leitura dos dados recebidos por série. Esta função retorna o valor “-1” se não houver dados disponíveis.

Sintaxe:  Valor recebido (int) = Serial.read();

Exemplo:

(1) int leitura_serie=0; ; //Declaração de uma variável do tipo integer com o nome “leitura_serie”, inicializada com o valor “0”

(2) void setup() {

(3) Serial.begin(9600); // Permite a inicialização da comunicação Série

(4) }

(5) void loop(){

(6) if(Serial.available()>0) ) // Condição if que verifica se estão a ser recebidos dados por Série

(7) leitura_serie=Serial.read(); // Caso se estejam a receber dados por série, o seu valor é guardado na variável integer “leitura_serie”

(8) }

(9) }

pinMode()

Descrição: Ao recorrer a esta instrução, é possível configurar o modo de comportamento de um determinado pino. Possibilitando assim defini-lo como input ou output, esta definição normalmente é efectuada recorrendo à função “void setup()”.

Sintaxe: pinMode(Número do pino, Modo);

O “Modo” acima descrito pode ser definido da seguinte forma:

• “INPUT”
• “OUTPUT”

Exemplo:

 (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor

(2) void setup() {

(3) Serial.begin(9600); // Permite a inicialização da comunicação Série

(4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT”

(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT”

(6) }

(7) void loop(){

(8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val”

(9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500)

(10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V)

(11) }

(12) }

digitalWrite()

Descrição: Possibilita, nos pinos configurados como output através da instrução “pinMode”, estabelecer a saída dos respectivos pinos com o valor lógico 1 (HIGH – 5 V) ou com o valor lógico 0 (LOW – 0V)

Sintaxe: digitalWrite(Número do pino, Modo);

O “Modo” acima descrito, pode ser definido como:

• “HIGH”
• “LOW”

Exemplo:

 (1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor

(2) void setup() {

(3) Serial.begin(9600); // Permite a inicialização da comunicação Série

(4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT”

(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT”

(6) }

(7) void loop(){

(8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val”

(9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500)

(10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V)

(11) }

(12) }

digitalRead()

Descrição: Possibilita a leitura de uma entrada digital específica, retornando um valor no formato integer (int). Se obtivermos um valor de retorno de “1”,  estamos perante uma leitura do tipo “HIGH” (valor lógico 1). Se tal não se  verificar, e tivermos um valor de retorno igual a “0”, estamos perante uma  leitura do tipo “LOW” (valor lógico 0).

Sintaxe: Variável do tipo integer = digitalRead(Número do pino);

Exemplo:

(1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor

(2) void setup() {

(3) Serial.begin(9600); // Permite a inicialização da comunicação Série

(4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT”

(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT”

(6) }

(7) void loop(){

(8) val=digitalRead(botao); // Permite a leitura do valor do pino 3 digital atribuindo o seu valor à variável “val”

(9) if(val==1) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500)

(10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V)

(11) }

(12) else{ // Caso a condição do ciclo if não se verifique

(13) digitalWrite(13,LOW); // Se a condição não for verificada, é atribuído ao pino digital 13 a condição “LOW” (0 V)

(14) }

(15) }

analogRead()

Descrição: Possibilita a leitura do valor analógico do pino especificado, com um conversor A/D possuindo uma resolução de 10 bits. O que leva a que um valor compreendido entre 0 e 5 V, esteja compreendido entre os valores inteiros (int) 0 e 1023.

Sintaxe: Variável do tipo integer = analogRead(Número do pino);

Exemplo:

(1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor

(2) void setup() {

(3) Serial.begin(9600); // Permite a inicialização da comunicação Série

(4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT”

(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT”

(6) }

(7) void loop(){

(8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val”

(9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500)

(10) digitalWrite(13,HIGH); // Se a condição for verificada, é atribuído ao pino digital 13 a condição “HIGH” (5 V)

(11) }

(12) }

analogWrite()

Descrição: Possibilita a utilização dos pinos PWM (Pulse Width Modulation) da placa Arduino. O sinal PWM mantém-se até ser modificado através de uma outra instrução que afete esse pino, a frequência do sinal PWM criado é de  490 Hz

Sintaxe: analogWrite(Número do pino, valor);

O “valor” referido anteriormente varia entre 0 (sempre desligado), até ao valor 255 (que representa um sinal de 5 V constante).

Exemplo:

(1) int botao=3,val; // Declaração de uma variável do tipo integer, com o nome “botao” inicializada com o valor “3” e de uma variável do mesmo tipo com o nome “val” não inicializada com nenhum valor

(2) void setup() {

(3) Serial.begin(9600); // Permite a inicialização da comunicação Série

(4) pinMode(botao,INPUT); // Permite definir o pino 3 como “INPUT”

(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como “OUTPUT”

(6) }

(7) void loop(){

(8) val=analogRead(botao); // Permite a leitura analógica do valor do pino 3 atribuindo o seu valor à variável “val”

(9) if(val>=500) // Ciclo if que testa a condição – “val>=500” (maior ou igual a 500)

(10) analogWrite(9,255); // Instrução com a mesma função que  “digitalWrite(9,HIGH)”

(11) }

(12) else{

(13) analogWrite(9,0); // Instrução com a mesma função que “digitalWrite(9,LOW)”

(14) }

(15) }

millis()

Descrição: Possibilita o retorno da quantidade de tempo, em milisegundos na forma de uma variável do tipo “unsigned long”. O valor retornado representa o tempo que, passou desde que o programa atual começou a ser executado.

Sintaxe: unsigned long tempo = millis();

Exemplo:

 (1) unsigned long tempo; // Declarada uma variável do tipo unsigned long com o nome “tempo”

(2) void setup() {

(3) (…..)

(4) }

(5) void loop(){

(6) tempo = millis(); // Atribui à variável “tempo” o valor em milisegundos desde que o sketch actual começou a ser executado

(7) }

delay (milisegundos)

Descrição: Possibilita efectuar uma pausa ao programa em execução, por uma quantidade de milisegundos especificada. Útil para manter um estado durante uma certa quantidade de tempo.

Sintaxe: delay(tempo que deseja efectuar a pausa – ms);

Exemplo:

 (1) int led_pin=13; // Declaração de uma variável do tipo integer com o nome

“led_pin”, sendo-lhe atribuída o valor “13”

(2) void setup() {

(4) pinMode(led_pin,OUTPUT); // Permite definir o pino 13 como “OUTPUT”

(5) Serial.begin(9600); // Permite a inicialização da comunicação Série

(6) }

(7) void loop(){

(8) digitalWrite(led_pin,HIGH); // É atribuído ao pino digital 13 a condição “HIGH”

(5 V)

(9) delay(200); // É efectuado um delay de 200 ms, antes de efectuar a próxima instrução

(10) digitalWrite(led_pin,LOW); // É atribuído ao pino digital 13 a condição “LOW”

(0 V) (11) delay(600); // É efectuado um delay de 600 ms, antes de efectuar a próxima instrução, neste caso a função “void loop()” recomeça

(12) }

O Hardware Do Capacímetro

A montagem do protótipo foi efetuada em duas protoboards por questões didáticas. Assim, os circuitos do LCD e do Capacímetro ficam mais claros.

Lista De Componentes Necessários:

·       Arduino Uno (Rev3)          

·       LCD screen tipo Caracter; pinos 16x2

·       R1  Potenciômetro - 16mm; Linear; 10kΩ

·       R2  10k Ω Resistor          

·       R3  220 Ω Resistor

Placa Arduino

O Arduino Uno é uma placa microcontroladora baseada no chip ATmega328. Ele tem 14 pinos digitais de input/output, 6 entradas analógicas, um conector USB para alimentação via PC e carga de códigos, conector de carga (jack power) para alimentação via bateria e um botão de reset.

LCD

Atenção especial deve ser dada as conexões entre o Arduíno e o LCD (figuras 18, 19 e 20):

Pinagem Arduíno	Pinagem LCD
2	14
3	13
4	12
5	11
8	6
9	4
5V	15
GND	16
GND	1
5V	2

      Figura 20. Tabela 3. As conexões do LCD

Potenciômetro

O potenciômetro em nosso protótipo é utilizado para realizar o ajuste de contraste do LCD através da conexão do terminal base do potenciômetro (figura 21) ao pino 3 (V0) do LCD (figura 21).

Alimentação

O placa microcontrolada Arduíno permite a alimentação via bateria, mas em nosso caso usaremos a conexão via USB com o PC para que possamos demonstrar a compilação e a carga do código.

A Montagem em Protoboards

O layout completo das conexões pode ser observado na figura abaixo:

Depuração

Através do monitor do Arduíno podemos obter o tempo em milisegundos e a capacitância calculada, assim podemos ilustrar alguns valores como os da tabela da figura 28.

Esses valores são mostrados no Serial Monitor graças ao trecho do código fonte que imprime na saída serial:

Serial.print(elapsedTime);

Serial.print((long)microFarads);

Em caso de valores inferiores a microFarads:

Serial.print(elapsedTime);

Serial.print((long)nanoFarads);

No caso da figura 27, por exemplo, temos que 11 milisegundos se passaram até a carga de 63,2% do capacitor fosse atingida, ou seja, 11 milisegundos é a nossa constante de tempo. Assim , lembrando da equação:

t = R . C   ou  C = t /  R

Calculamos o valor do capacitor. Lembrando que o tempo deve ser dados em segundos, por isso a multiplicação por 1000, uma vez que o valor fornecido pelo arduino nos é dado em milisegundos:

C = (elapsedTime / resistorValue) *  1000;

E encontramos C = 1000 nF.

Observemos agora a tabela 4 da figura 25 que contém outros valores obtidos experimentalmente em nosso protótipo através da simples substituição do capacitor a ser medido e que podem ainda ser comparados através da aferição com Capacímetro comercial (figura 29):

Valor Nominal	tempo (ms)			Valor Medido (na unidade nominal )
Leituras	1ª	2ª	3ª	1ª	2ª	3ª
1000 nF	11	10	10	1100	1000	1000
33 µF	355	356	354	35.4	35.5	35.4
100 µF	1065	1064	1063	106.5	106.5	106.3
220 µF	2111	2109	2108	211	210.9	210.7
470 µF	5036	5038	5026	503.6	503.8	502.6
1000 µF	10037	10035	10007	1003	1003	1000

Figura 28. Tabela 4. Amostragem de valores obtidos experimentalmente.

Valor Nominal	Maior valor Medido no Protótipo	Aferição
1000 nF	1100 nF	1103 nF
33 µF	35.4 µF	35 µF
100 µF	106.5 µF	138.3 µF
220 µF	211 µF	276.5 µF
470 µF	503.8 µF	450 µF
1000 µF	1003 µF	1287 µF

Figura 29. Tabela 5. Aferições com Capacímetro comercial [15].

REFERÊNCIAS BIBLIOGRÁFICAS

ARDUINIANA. (2009). "Arduino software jewellry and wisdom." http://arduiniana.org/. Acessado em 8 maio de 2014.

ARDUINO.http://www.arduino.cc. Acessado em 8 de maio de 2014.

GUSSOW, Milton. Eletricidade Básica. Ed.Pearson Makron Books, São Paulo. 1997.

LABORATÓRIO DE GARAGEM. http : // labdegaragem . com / profiles/blogs/tutorial-lcd-com-arduino. Acessado em 1 de abril de 2014.

MCROBERTS, Michael. Arduino Básico. Ed.Novatec, São Paulo-SP. 2011.

RIZZONI, Giogio. Fundamentos de Engenharia Elétrica. Bookman Editora, Porto Alegre,RS, 2013.

SADIKU, Matthew; ALEXANDER, Charles. Fundamentos de Circuitos Elétricos. AMGH Editora. Porto Alegre, RS. 2013.

SPARKFUN. https: // www.sparkfun.com / datasheets / LCD / ADM1602K-NSW-FBS-3.3v.pdf. Acessado em 8 maio de 2014.

TORRES, Gabriel. Eletrônica. Novaterra Editora, Rio de Janeiro, RJ. 2012.

---

[1] Tabela completa de constantes dielétricas podem ser encontradas em http:// www. foz. unioeste. br/~lamat/ downmateriais/materiaiscap18.pdf

[2] Fonte da Imagem: http : // www. Electronics –tutorials .ws/ capacitor / cap_1.html

[3] Fonte da Imagem: Instituto Federal de educação IN: http://dc372.4shared.com/doc/PccZGHTo/preview.html

[4] Gráficos produzidos com Microsoft Excel 2007 são meramente ilustrativos não sendo confiáveis em precisão matemática.

[5] Fonte da Imagem:http://playground.arduino.cc

[6] Arduino versão 1.0.5-r2 (www.arduino.cc)

[7] Fonte da Imagem: http://www. Techtudo . com . br / noticias / noticia / 2013/10/ o-que-e-um-arduino-e-o-que-pode-ser-feito-com-ele.html

[8] Fonte da Imagem : http:// pt.wikipedia. org/wiki/Arduino# mediaviewer / Ficheiro: Arduino - uno- perspective-transparent. png

[9] Fonte: https: // www.sparkfun.com / datasheets / LCD / ADM1602K-NSW-FBS-3.3v.pdf

[10] Fonte da imagem : http : //www. engineersgarage.com / electronic-components/16x2-lcd-module-datasheet

[11] Imagem adaptada do original em http: / /www . dreaminc. com.br / sala_de_aula/7a-resistencia-eletrica/

[12] Imagem adaptada do original em http : // adriandavidm. blogspot.com.br / 2010_08_01_archive.html

[13] Prototipagem feita no software Fritzing Versão Beta 0.8.7

[14] Esquemático feito no software Fritzing Versão Beta 0.8.7

[15] As aferições foram feitas com o Capacímetro HIKARI modelo HX-110.