Detecção de tensão com o 4N25

Introdução

Muitas vezes, pode ser necessário detectar a energização de um circuito elétrico, para efeito de alguma automação. Quando o circuito em questão utiliza corrente contínua, existem módulos que funcionam muito bem, como esse ou esse, e podem facilmente ser incluídos no projeto. Quando é necessário detectar a existência de corrente em um circuito de alta tensão, acima de 110V e em corrente alternada, temos que lançar mão de outros artifícios. Existe um módulo bastante interessante – o ZMPT101B – que pode ser explorado, que além de detectar, a presença de tensão, também faz a sua medição.

No histórico do blog, temos um ótimo artigo ilustrando como efetuar a medição de corrente e de energia utilizando um sensor de corrente não invasivo – o sensor SCT-013.

Nesse artigo, iremos abordar uma outra forma de detectar a energização de um circuito, utilizando um optoacoplador muito interessante e de baixo custo – o 4N25. Importante salientar que utilizando o 4N25 não teremos como determinar quanto de energia ou de corrente existe em um circuito, mas se existe ou não corrente no circuito medido. Utilizaremos, nessa montagem, um optoacoplador 4N25 e o ESP32 para leitura da informação. Alguns componentes eletrônicos auxiliares serão utilizados.

Antes de mais nada, e muito importante, temos que considerar que a própria manipulação de tensão mais alta é perigosa por natureza – e aqui fica o alerta para tomada de todas as precauções necessárias para isso!

Os optoacopladores

Um componente optoacolador é muito importante na medida em que ele isola fisicamente dois circuitos, mantendo apenas a transmissão da informação utilizando um acoplamento ótico. No circuito A, temos a circulação de energia de alta tensão (127 ou 240VAC); no circuito B, temos um microprocessador como o ESP32 com tensões muito baixas e em corrente contínua. Qualquer problema ou sobretensão no circuito A não irá afetar o circuito B, pois não há nenhum contato físico entre eles, mantendo a integridade do circuito B e de todos seus componentes.

Fig. 1. Esquemático do 4N25.

Para que o 4N25 detecte a existência de tensão, uma corrente contínua e de baixa intensidade deve passar pelo diodo que existe entre os pinos 1 e 2. Quando essa corrente excita o LED interno, a luz infravermelha emitida é captada pela base do fototransistor, que assim permite a passagem de corrente entre os pinos 4 e 5. Essa passagem de corrente pode, assim, disparar qualquer evento em seu programa, do lado do ESP32.

O circuito

Faremos um circuito bastante simples, apenas para ilustrar o funcionamento do 4N25. A detecção de energia se dará em uma rede normal, de 127VAC, ou seja, corrente alternada. Temos nesse ponto dois desafios:

• Fazer a corrente circular em baixa intensidade; e
• Permitir a passagem de corrente apenas em um sentido (lembre-se, a corrente alternada flui nos dois sentidos!)

Para resolver o primeiro problema, basta usar um resistor de maior valor, sempre lembrando da fórmula V = R.I. Assim, para V=127V e um resistor de 100K, teremos uma corrente aproximada de I = 127 / 100000 = 1,3 mA, que deve ser suficiente para excitar o diodo. A documentação do 4N25 (datasheet) fala em 60 mA no máximo, e nesse caso bastaria um resistor de apenas 2K. Entretanto, isso poderia aquecer muito o nosso resistor e ultrapassar a potência máxima, pois geralmente utilizamos resistores pequenos, de 0,25W. Trabalharemos então com baixa corrente, utilizando um resistor mais alto. Mesmo em locais onde a energia é 240VAC, esse resistor é suficiente para gerar uma baixa corrente.

Já a passagem de corrente apenas em um sentido pode ser resolvida com o uso de um diodo retificador comum, que permite a passagem de corrente apenas em um sentido.

Fig. 2. Representação da onda após filtragem pelo diodo retificador.

Dessa forma, a onda senoidal da corrente alternada se torna uma sequência de “meias ondas”, o que pode ser um problema para o processo de detecção de corrente, já que o LED ficará parte do tempo excitado, parte apagado, e isso pode trazer alguma “confusão” para o circuito detector, levando o ESP32 a detectar uma sequência de ativações e desativações, que não é o que desejamos. Então, vamos inserir um capacitor no circuito. Ele será carregado quando o fototransistor do 4N25 permitir a passagem de corrente, e descarregado quando o LED interno estiver apagado, mas manterá o sinal ativo para o ESP32 até o próximo pulso da onda senoidal.

Fig. 3. O circuito detector.

O ESP32 poderá tomar qualquer ação a partir da informação de que existe ou não energia na linha, como enviar uma mensagem, acender um LED, enviar uma mensagem ou qualquer outra ação. Aqui, o limite é a criatividade! Usaremos nesse artigo a simples informação no Monitor Serial, já que nosso objetivo é fazer a detecção pelo 4N25.

Materiais

Bom… então mãos à obra! Usaremos os seguintes materiais:

• Protoboard
• Jumpers
• Resistores de 100kΩ e 10 kΩ
• 01 Capacitor eletrolítico de 470 µF
• 01 diodo retificador 1N4007
• 01 circuito integrado acoplador ótico 4N25 – O datasheet pode ser consultado aqui.
• 01 ESP32 – nessa montagem utilizamos o modelo de 38 pinos, mas poderia ser qualquer um

A montagem é bastante simples, como mostra a imagem abaixo. Nesse ponto, é sempre importante o alerta: já que vamos mexer com tensões mais altas, o cuidado na montagem e manipulação do circuito é muito importante. Para a ligação dos cabos que trazem a tensão de 127AC (de uma tomada comum), você pode utilizar um conector borne KRE de duas vias, como mostra a imagem abaixo.

Fig. 4. Sugestão de ligação da entrada da energia monitorada na protoboard.

Um outro ponto de atenção é a correta posição do capacitor, já que ele é eletrolítico e, portanto, polarizado. Na lateral do capacitor existe uma faixa, que pode ser vista no circuito mostrado e no detalhe com uma foto real. A faixa indica o pino que deve ser ligado ao terra (GND).

O circuito, após montagem, ficará como mostrado na Figura 5. Utilizaremos o pino GPIO 5 para a leitura da informação da existência ou não decorrente na entrada de alta tensão.

Fig. 5. Como fica a montagem do experimento.

Código

O código em si é extremamente simples, já que todo o “serviço pesado” será feito pelo 4N25. Será um programa básico, que apenas faz a leitura da GPIO 5 e mostra o resultado da leitura no Monitor Serial. Não há necessidade de nenhuma biblioteca especial, apenas a correta configuração da IDE do Arduíno para aceitar a carga do programa no ESP32. A alimentação se dará normalmente pela porta USB do ESP32.

Além da informação ser impressa no Monitor Serial, faremos o LED embarcado na placa ESP32, associado à GPIO 2, acender sempre que houver energização do circuito VAC.

/***************************************************************************************
 ***************************************************************************************
 * Sketch EG001-00
 * Faz a leitura digital de um GPIO para verificação da energização de um circuito VAC
 * usando o 4N25
 * 
 * Blog Eletrogate, 03 JUL 2021 - Autor: Marden Cicarelli
 ***************************************************************************************
 ***************************************************************************************/
#define myPIN 5             // define o pino de entrada
#define ledPIN 2            // define o pino LED
#define myRate 115200       // determina a velocidade da saída serial
#define SerialMon Serial    // define o monitor serial para saída

int onOff = 2;              // armazena o estado anterior do sinal de entrada
int leitura;                // armazena cada leitura do sinal na porta myPIN

void setup() {
  pinMode(myPIN, INPUT);    // não preocupacom com pullup ou pulldown, já que isso foi feito no circuito
  pinMode(ledPIN, OUTPUT);  // definimos o pino do led como saída

  SerialMon.begin(myRate);  // inicializa Monitor Serial com a velocidade escolhida (verificar configuração do monitor!)
  SerialMon.println("===================================================");
  SerialMon.println("Iniciando o programa... ligue e desligue o circuito");
  SerialMon.println("para testar...");
  SerialMon.println("===================================================");
  SerialMon.println();
}

void loop() {
  leitura = digitalRead(myPIN);   // faz a leitura do sinal
  if (leitura != onOff) {         // mudou o estado?
    onOff = leitura;              // armazena o novo estado
    if (leitura == HIGH) {        // valor lido é alto?
      digitalWrite(ledPIN, HIGH); // acende o led
      SerialMon.println("Circuito ligado. PERIGO DE CHOQUE ELÉTRICO!");
    } else {
      digitalWrite(ledPIN, LOW);  // apaga o led
      SerialMon.println("Circuito desligado. :)");
    }
  }
  delay(100);                     // aguarda um tempo de 0.1 s para próxima leitura.
}

A imagem reproduzida abaixo mostra a saída no monitor serial após vários testes, ligando e desligando a energia do circuito em corrente alternada.

Fig. 6. A saída no Monitor Serial.

Conclusão

Esse foi um exemplo simples do uso do optoacoplador 4N25, mas que possui um potencial muito interessante em projetos de automação residencial ou qualquer monitoramento em que se pretende verificar se um determinado dispositivo está ligado ou não, como um motor, uma lâmpada, ou qualquer aparelho elétrico.

Caso você possua dúvidas ou sugestões, fique à vontade para nos contatar por meio desse blog. Boa diversão e até a próxima!

Sobre o Autor

Marden Cicarelli Engenheiro Civil (FUMEC), Bacharel em Ciência da Computação (UFMG) e MSc em Tecnologia (CEFET). Mais que uma diversão, as experiências com IoT são um mundo novo, em que busco unir os conhecimentos de TI e suas aplicações na Engenharia.