Monitor de fontes - Voltímetro e amperímetro

Wellington R. Domingos.

Neste artigo, trago o projeto de um monitor para fontes de alimentação, ele poderá monitorar uma fonte de alimentação de até 20V e 2A. Esse circuito é mais avançado e requer conhecimentos em microcontroladores PIC, porem seguindo os passos descrito nesse artigo e no vídeo no final do artigo, o leitor iniciante poderá montá-lo sem muitas dificuldades.

 

As fontes de alimentação são equipamentos que tem a principal função de substituir as pilhas e baterias, são equipamentos bastante úteis na bancada eletrônica, podem ser de valores fixos ou variáveis, como são os casos das fontes de bancada. O projeto descrito nesta postagem terá a função de monitorar uma fonte de alimentação de até 20V e 2A, 20V é a tensão máxima que a fonte deverá fornecer para uma carga qualquer e 2A é a corrente máxima que a fonte deve fornecer a carga, porém, pode se modificar o circuito para valores maiores ou menores.

O circuito.

O circuito do nosso projeto é mostrado na figura 01, ele tem como base um microcontrolador PIC16F688, que controla todo o circuito. Nas porta RC do PIC ligamos um display LCD alfanumérico, que será utilizado para mostrar os valores medidos na fonte, o trimpot RV2 é utilizado para ajustar o contraste dos pixels do display e o transistor Q1 é uma chave para ligar e desligar a luz de fundo do display (backlight). O relé K1 é utilizado para ligar e desligar a saída fonte que será monitorada, fazendo que o circuito possa ser utilizado no projeto de uma fonte de bancada, veremos isso nas próximas postagens desse blog. O controle do backlight do display e do relé é feito através de uma chave eletrônica feita com o circuito integrado CD4027, circuito esse que já foi abordado aqui no blog na postagem anterior, cofira clicando aqui antes de prosseguir. Outro detalhe desse circuito é que ele também desliga a saída da fonte caso os valores lidos ultrapassem os valores máximos programados, isso é feito pelo PIC através da porta RA2 que envia nível lógico baixo para o transistor Q4 mantendo ele saturado o tempo todo, quando for necessário resetar a fonte o estado de RA2 muda para nível lógico alto, desligando o relé. O regulador de tensão LM7805, regula uma tensão de 12V para 5V para alimentar os circuitos lógicos, com isso podemos alimentar o circuitos com uma tensão padrão de 12V.

Leitura da tensão.

A leitura da tensão é feita pela porta RA0 do PIC, figura 02, que mede a tensão de até 20V que é aplicada a um divisor de tensão feito com três resistores R2, R3 e R4, que são responsáveis por dividir a tensão de 20V para 5V, ou seja, quando a tensão aplicada variar de 0V a 20V o PIC irá enxergar uma variação de 0V a 5V, que é o máximo de tensão que ele suporta. A correção dos valores para serem exibidos do display é feita no soft do PIC, caso o leitor queira uma tensão maior ou menor, terá que fazer essa alteração no programa do PIC. Não é necessário ser um expert no assunto, dando uma lida o código do programa, o leitor poderá fazer essas alterações caso senta necessidades.

 

Leitura da corrente.

A leitura da corrente é feita pela porta RA1 do PIC figura 04, e é feita de forma um pouca mais complexa, para isso precisamos de um sensor de corrente, utilizamos um resistor de desvio conhecido como resistor SHUNT, ele recebe a tensão que passa pela carga, essa tensão multiplicada pelo valor do resistor SHUNT nos dá o valor da corrente que a carga consome, para uma corrente de 2A e um resistor de 0,33R, temos 2x0,33 que dá uma tensão de 0,66V, ou seja, quando o valor da corrente variar de 0A até 2A, a tensão em cima do resistor SHUNT irá variar de 0V até 0,66V. Para corrigir isso, temos que amplificar esse valor por 6, para isso, usamos um amplificador operacional LM741 U1 no circuito, com isso damos um ganho de 6x no valor da tensão e temos uma tensão final de 4,96V, bem próximo do valor máximo que o PIC suporta. Agora é só converter esse valor de tensão em corrente, isso é feito no programa do PIC que veremos logo a baixo.

Montagem.

Figura 04: Montagem em placa ilhada.

A montagem no projeto foi feita em uma placa ilhada, pois foi utilizado em outro projeto que veremos mas a frente em outra postagem, veja as figuras 04, 05 e 06. Notem que assim que o circuito for ligado, é necessário fazer sua calibração para a leitura da corrente, isso é simples, alimente o circuito da fonte com uma carga que consuma uma determinada corrente que você conhece, se o valor não for o correto, ajuste o trimpot RV1 até o valor coerente com a carga, pronto, o circuito está pronto para ser utilizado.

Figura 05: Circuito com backlight desligado.

 

 

 

 

Figura 06: Circuito com backlight ligado.

 

 

 

 

 

 

Programa do PIC.

Confira o código do programa do projeto, ele foi escrito em linguagem C utilizando o compilador mikroC.

-----------------------------------------------------------------------------------------------------------------

//****************************************************************************//
//* Programa medidor para fontes de bancada                              *//
//* Escrito por Wellington R. Domingos                                       *//
//* Utiliza Compilador mickroC versão 7.2.0                                 *//
//* Utiliza microcontrolador PIC16F676                                        *//
//* Escrito em 21/02/2019 as 00:40                                            *//
//****************************************************************************//
//****************************************************************************//
//*                  Define conexões para o display LCD                      *//
//****************************************************************************//

sbit LCD_RS at RC0_bit;
sbit LCD_EN at RC1_bit;
sbit LCD_D4 at RC2_bit;
sbit LCD_D5 at RC3_bit;
sbit LCD_D6 at RC4_bit;
sbit LCD_D7 at RC5_bit;

sbit LCD_RS_Direction at TRISC0_bit;
sbit LCD_EN_Direction at TRISC1_bit;
sbit LCD_D4_Direction at TRISC2_bit;
sbit LCD_D5_Direction at TRISC3_bit;
sbit LCD_D6_Direction at TRISC4_bit;
sbit LCD_D7_Direction at TRISC5_bit;

//****************************************************************************//
//*                      Declara sub rotinas do programa                      *//
//****************************************************************************//

void voltes();                           //Rotina para ler a tensão
void ampers();                           //Rotina para ler a corrente
void start();                            //Rotina para resetar a fonte

//****************************************************************************//
//*                           constante auxiliar                              *//
//****************************************************************************//

#define shunt 0.33                       //Valor do resistor de Shunt

//****************************************************************************//
//*                       Declara variáveis de uso geral                      *//
//****************************************************************************//

float volt1 = 0.0;                       //Variável para leitura do pino RA0
float volt2 = 0.0;                       //Variável para leitura no pino RA1
int volt1_1;                             //Variável que converte para inteiro
int amp;                                 //Variável que converte para inteiro
char d1, d2, d3, d4;                     //Variável de uso geral
char v1, v2, v3;                         //Variável de uso geral

//****************************************************************************//
//*                         Programa principal                               *//
//****************************************************************************//

void main() {

     TRISA0_bit = 1;                     //Inicia pino RA0 como entrada
     TRISA1_bit = 1;                     //Inicia pino RA1 como entrada
     TRISA2_bit = 0;                     //Inicia pino RA2 como saída
     
     CMCON0 = 0x07;                      //Desliga comparadores analógicos
     
     ADCON0  = 0b00000101;               //Liga conversão analógica
     ADCON1  = 0b00000000;               //Seleciona tipo de clock da conversão
     ANSEL   = 0b00000011;               //Seleciona pinos RA0 e RA1

     LCD_init();                         //Inicia display LCD
     LCD_Cmd(_LCD_CLEAR);                //Limpa o cursor
     LCD_Cmd(_LCD_CURSOR_OFF);           //Desliga o cursor
     LCD_Out(1, 1, "Fonte de bancada");  //Escreve mensagem na linha 1
     
     Delay_ms(500);                      //Aguarda display atualizar
     
     PORTA.RA2 = 0;                      //Inicia pino R2 em estado 0

//****************************************************************************//
//*                             Loop infinito                                *//
//****************************************************************************//
     
     while(1) {
     
              voltes();                  //Chama a função da tensão
              ampers();                  //Chama a função da corrente
              Delay_ms(200);             //Aguarda um tempo
     
     }

}

//****************************************************************************//
//*                    Rotina que mede a tensão da fonte                     *//
//****************************************************************************//

void voltes() {

     volt1 = ADC_Read(0);                //Ler pino RA0
     volt1 = ((volt1*20.0)/1023.0)*100.0;      //Efetua cálculos
     volt1_1 = (int)volt1;               //Converte para inteiro

     v1 = volt1_1 / 1000;
     v2 = (volt1_1 % 1000) / 100;
     v3 = (volt1_1 % 100) / 10;

     Lcd_Chr(2, 1, v1 + '0');            //Envia caractere para o display
     Lcd_Chr_Cp(v2 + '0');               //Envia caractere para o display
     Lcd_Chr_Cp(',');                    //Envia caractere para o display
     Lcd_Chr_Cp(v3 + '0');               //Envia caractere para o display
     Lcd_Chr_Cp('V');                    //Envia caractere para o display

}

//****************************************************************************//
//*                   Rotina que mede a corrente da fonte                    *//
//****************************************************************************//

void ampers() {

     volt2 = ADC_Read(1);                //Ler o pino RA1
     volt2 = ((volt2*4.0)/1023.0)*200.0; //Efetua cálculos
     volt2 = volt2/shunt;                //Divide valor pelo resistor de desvio
     amp = (int)volt2;                   //Converte valor para inteiro

     d1 = amp / 1000;
     d2 = (amp % 1000) / 100;
     d3 = (amp % 100) / 10;
     d4 = amp % 10;

     Lcd_Chr(2, 10, d1 + '0');           //Envia caractere para o display
     Lcd_Chr_Cp(',');                    //Envia caractere para o display
     Lcd_Chr_Cp(d2 + '0');               //Envia caractere para o display
     Lcd_Chr_Cp(d3 + '0');               //Envia caractere para o display
     Lcd_Chr_Cp(d4 + '0');               //Envia caractere para o display
     Lcd_Chr_Cp('A');                    //Envia caractere para o display
              
     start();                            //Chama a função de reset
}

//****************************************************************************//
//*             Rotina de protege a fonte de uma corrente máxima             *//
//****************************************************************************//

void start() {

     if (amp > 700) PORTA.RA2 = 1;      //Se corrente for maior do que 700mA
                                        //Desliga o relé
}

-----------------------------------------------------------------------------------------------------------------

Conclusão.

Nesta postagem, mostrei o circuito de um monitor de fontes de alimentação, que é capaz de medir a tensão de a corrente em uma fonte de alimentação de 20V até 2A, nas próximas postagem aqui do blog trarei mais artigos sobre o assunto, com circuitos mais complexos.

Vídeo.

Assistam ao vídeo sobre o projeto, aproveite para se inscrever no nosso canal no YouTube, os projetos são publicados primeiramente lá, Canal WD Projetos. Clique aqui.

 

Arquivos do projeto.

 

Baixe os arquivos desse projeto para monta-lo, é necessários os seguintes programas, Kicad e mikroC. Clique aqui.