No post de hoje, vamos apreender a construir um voltímetro de 4 canais com display 20x4, baseado no Arduino Nano V3.0. São dois canais de 0-25 V e outros dois de 0-5 V. Observe que, cada canal analógico do Arduino, é capaz de medir somente tensão positiva. Esse projeto pode ser útil para monitorar protótipos de  circuitos, fontes de alimentação, tensão de pilhas e baterias.

O Arduino Nano V3.0, baseado no microcontrolador Atmega 328p, possui um conversor analógico digital (ADC) com resolução de 10 bits, e tensão máxima de leitura igual a 5 V. Para o Arduino Nano V3.0, é possível utilizar até oito portas analógicas e para leitura de tensão, já o Arduino UNO fica limitado a somente seis portas analógicas de leitura. Mas, hoje, vamos utilizar apenas quatro canais analógicos do Arduino. Sabendo que a resolução de 10 bits do ADC do Arduino equivale a 1024 passos, para uma tensão de 5 V, teremos uma resolução de leitura igual a 4,9 mV por passo. Porém, através de uma técnica básica, é possível medir tensões superiores ao limite máximo de 5 V das portas do Arduino e isto é feito com um divisor de tensão resistivo.

Figura 1: Foto da montagem do voltímetro.

Entendendo a conversão analógica para digital no código fonte.

Já sabemos que o Arduino possui um ADC com resolução de 10 bits. Isso significa que temos até 1024 valores possíveis de leitura (0 até 1023). Além disto, o Arduino possui uma tensão de referência para as suas portas analógicas. Para o nosso voltímetro, utilizamos a tensão da linha de 5 V do Arduino como referência para o ADC.

Para tomar uma medida de tensão em uma porta do Arduino, é necessário chamar a função analogRead(), essa função retorna o valor 0 para 0V na porta analógica e o valor 1023 para quando a tensão na porta analógica é igual a tensão de referência.

Logo, não podemos simplesmente chamar a função analogRead() tentar e imprimir o valor de tensão sobre a porta analógica, uma vez que irá aparecer um número entre 0 e 1023. Portanto, devemos utilizar a matemática a nosso favor e converter o valor retornado pela função analogRead() em um valor de tensão.  A maneira mais fácil de fazer isso é descobrir quanto vale cada unidade de medida da função analogRead().  Logo para uma tensão de referência igual a 5 V, temos:

Ou seja, a cada uma unidade da função analogRead(), corresponde a 4,9 mV. Então podemos escrever a seguinte expressão:

Onde, VREF= 5V. Logo, essa expressão é que nos fornece o valor de tensão lido pela porta analógica.

Medindo tensões maiores que 5 V: divisor de tensão resistivo.

Já sabemos que o Arduino está limitado a medir no máximo tensões de 5 V em suas portas analógicas e, para contornar esse problema, implementamos um divisor de tensão resistivo para dois canais do nosso voltímetro e o os outros dois canais sem divisores.

Neste caso, escolhemos dois resistores de valor comercial (R1=33k e R2=8,2K) que, em conjunto, dividem a tensão de entrada por um fator de 5. Isto é, se aplicarmos 25 V na entrada do divisor de tensão em sua saída teremos 5 V. Portanto, nosso voltímetro é capaz de medir tensões de:

• 0 até 5 V no canal 1 e 2.
• 0 até 25 V no canal 3 e 4.

Observe a figura 2, contendo o diagrama elétrico do divisor e a equação matemática que define a tensão de saída do divisor resistivo em função da tensão de entrada.

Figura 2: Diagrama elétrico do divisor resistivo e equação.

Através da equação apresentada na figura 2, é possível calcular um divisor de tensão para praticamente qualquer tensão de entrada. Para tanto, faça:

• Vin = tensão máxima que você deseja medir.
• Vout = 5V.
• R1 = 10 kΩ (ou um valor maior que 10kΩ).

Agora, é só isolar R2 e calcular o valor. Para facilitar o seu projeto criamos uma tabela com sugestões de divisores de tensão. Repare que, em nossa tabela de sugestões, Vout não é igual 5V para a maioria dos casos, pois foi necessário modificar o valor encontrado de R2 para um valor comercial de resistência.

Tabela 1: Sugestões de divisores de tensão para o voltímetro.

Para realizar uma medida de tensão com um divisor de tensão, basta multiplicar o valor de tensão, já convertido, pela razão (Vin/Vout).

Lembre-se de que a tensão sobre a porta analógica do Arduino não deve exceder, em qualquer hipótese, a tensão máxima admissível de 5V, pois tensões acima deste limite vão danificar, irreversivelmente, o seu Arduino. Portanto, caso queira projetar um divisor de tensão, específico para uma faixa de tensão, leve em conta que a saída do seu divisor de tensão não poderá exceder 5V.

Lista de materiais

• Arduino Nano V3.0
• Adaptador i2c para display 16x2 e 20x4
• Jumpers macho x macho.
• Resistores (ver texto)
• Protoboard 830 furos
• Display 20x4

Diagrama de montagem

Observe a figura 3 com o diagrama de montagem. Nesta etapa é importante executar a montagem com calma para evitar fazer conexões erradas, sobretudo conexões que possam gerar curto-circuito entre os terminais do seu Arduino.

Figura 3: Diagrama de montagem do voltímetro de 4 canais. os fios rosa-branco representam os canais 1 e 2, e os fios roxo representam os canais 3 e 4. Os capacitores cerâmicos de 100nF podem ser omitidos da montagem, caso queira.

Calibrando o seu voltímetro

Agora, vamos calibrar o nosso voltímetro, conforme a figura 4, para tanto utilize um multímetro para medir a tensão na porta de 5V do seu Arduino, copie esse valor para a linha de código a seguir.

#define VREF 4.69

Figura 4: Medindo a tensão no pino de 5V do seu Arduino, utilize esse valor para calibrar o seu voltímetro.

Testando o seu voltímetro

Feita a montagem na protoboard, teste algumas pilhas e baterias. Lembre-se de não inverter a polaridade e também de não exceder o limite de tensão de cada canal do seu voltímetro. Observe a figura 5, testamos uma pilha e uma bateria, já usadas. Os outros dois canais, ligamos a linha de 5V do Arduino. As medidas ficaram com uma excelente precisão em relação ao multímetro.

Figura 5: Testando uma pilha usada, uma bateria usada e porta de 5V do Arduino.

Código fonte

//Bibliotecas
#include <LiquidCrystal_I2C.h>
#include "Wire.h"

// Modulo I2C display no endereco 0x27, comunicaçao com os pinos A4=SDA e A5=SCL.
LiquidCrystal_I2C lcd(0x27, 20, 4);

//Portas analogicas do voltimetro
int CH1 = A2;
int CH2 = A3;
int CH3 = A0;
int CH4 = A1;

//Variaveis que armazenam o valor de tensão de cada canal.
float VCH1;
float VCH2;
float VCH3;
float VCH4;

//Com auxilio de um multimetro, verifique a tensão fornecida na linha de 5V pela sua placa ARDUINO  e digite no lugar do valor atual.
//ESSA ETAPA É FUNDAMELTAL PARA GARANTIR A PRECISÃO DO SEU VOLTIMETRO!
#define VREF 4.69
 
// vetor de bytes dos caracteres que formam o logo M da Modulo Eletronica.
byte SIMB1[8] = {B11100,B11110,B11111,B11101,B11100,B11100,B11100,B11100};
byte SIMB2[8] = {B00000,B00000,B00000,B10000,B11100,B01111,B00111,B00001};
byte SIMB3[8] = {B00000,B00000,B00000,B00001,B00111,B11110,B11100,B10000};
byte SIMB4[8] = {B00111,B01111,B11111,B10111,B00111,B00111,B00111,B00111};
byte SIMB5[8] = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100};
byte SIMB6[8] = {B00000,B00001,B00011,B00011,B00001,B00000,B00000,B00000};
byte SIMB7[8] = {B00000,B10000,B11000,B11000,B10000,B00000,B00000,B00000};
byte SIMB8[8] = {B00111,B00111,B00111,B00111,B00111,B00111,B00111,B00111};


void setup() {
 //incializa o modulo LCD com backpack I2C
  Wire.begin();
  lcd.begin(20, 4);
  lcd.backlight();
  
  //Cria os caracteres que formam o logo M da Modulo Eletronica.
  lcd.createChar(1, SIMB1);
  lcd.createChar(2, SIMB2);
  lcd.createChar(3, SIMB3);
  lcd.createChar(4, SIMB4);
  lcd.createChar(5, SIMB5);
  lcd.createChar(6, SIMB6);
  lcd.createChar(7, SIMB7);
  lcd.createChar(8, SIMB8);
  
 //Desenha o logo M da Modulo eletronica, caractere por caractere. 
  byte Count = 1;
  lcd.clear();
  
  for (byte y = 0; y < 2; y++) {
    for (byte x = 0; x < 4; x++) {
      lcd.setCursor(2+x, y);
      lcd.write(Count);
      Count++;  
    }    
  }
  
  lcd.setCursor(7, 0);
  lcd.print("   MODULO");
  lcd.setCursor(7, 1);
  lcd.print(" ELETRONICA");
  lcd.setCursor(1, 3);
  lcd.print("VOLTIMETRO 4 CANAIS"); 
  delay(2000);
  lcd.clear();
  
  //Escreve no display a legenda de cada canal do Voltimetro.
  lcd.setCursor(0, 0);
  lcd.print("CH1 (0-5V)=");
  lcd.setCursor(0, 1);
  lcd.print("CH2 (0-5V)=");
  lcd.setCursor(0, 2);
  lcd.print("CH3 (0-25V)=");
  lcd.setCursor(0, 3);
  lcd.print("CH4 (0-25V)=");
  
}

void loop() {
  
//Função que chama a leitura analogica do ADC. Uma chamada por canal.
VCH1 = analogRead(CH1);
VCH2 = analogRead(CH2);
VCH3 = analogRead(CH3);
VCH4 = analogRead(CH4);

//Converte o valor ligo pela função analog Read(0 até 1023) em um valor de tensão. 
VCH1 =(VCH1*(VREF/1023));
VCH2 =(VCH2*(VREF/1023));
VCH3 =(5*VCH3*(VREF/1023));
VCH4 =(5*VCH4*(VREF/1023));

//Escreve no display as tensões medidas por cada canal do voltimetro.
lcd.setCursor(11, 0);
lcd.print(VCH1,2);
lcd.setCursor(11, 1);
lcd.print(VCH2,2);

lcd.setCursor(12, 2);
lcd.print("    ");
lcd.setCursor(12, 2);
lcd.print(VCH3,2);

lcd.setCursor(12, 3);
lcd.print("    ");
lcd.setCursor(12, 3);
lcd.print(VCH4,2);

//taxa de atualização entre tomada de medidas.
delay(400);

}

Não deixe de tirar suas duvidas, aguarde os próximos posts do blog da Módulo Eletrônica. Aproveite para seguir o Instagram da nossa loja @moduloeletronica.