Recurso para Auto Desligamento do Arduino (v 1.0)

Recurso para Auto Desligamento do Arduino

Versão 1.1 em 18/02/2020 – Ricardo Zelenovsky

(Correção dos transistores Q1 e Q2, que estavam invertidos)

 

Proposta:

Uma solução para que o Arduino se auto desligue com o uso de uma saída digital. O religamento deve ser automático toda vez que o Arduino for energizado.

 

Importante:

O texto aqui apresentado apenas relata o experimento realizado pelo autor, sem qualquer responsabilidade nas suas aplicações. O leitor pode usar trechos deste texto, desde que cite a origem. É vedado o uso comercial. Correções e sugestões são bem-vindas.

Recomendo meu livro “Arduino: Guia Avançado para Projetos”, veja no final deste estudo.

 

Texto Completo:

Aos que se interessarem sobre o uso do Arduino Mega alimentado pelo acendedor de cigarros de um carro, com super capacitor para back up de energia e recurso para auto desligamento, baixe o texto completo em:

Zele_Estudo_01_v01.pdf

Ambientação:

O que é exposto a seguir foi desenvolvido para um projeto que será embarcado em um carro, sendo que os 12 V serão aplicados à entrada VIN do Arduino. Essa entrada VIN supre o regulador interno de 5 V que gera a tensão para todo o Arduino. O sítio do Arduino [1] indica que VIN deve estar na faixa de 7 V até 12 V (limites são de 6 V e 20 V).

Após o carro ser desligado, o Arduino sustentado por um super capacitor ainda deve funcionar por alguns segundos e depois se desliga. O que queremos abordar aqui é este circuito para o auto desligamento. No próximo artigo vamos descrever o uso do super capacitor.

 

Solução para o Auto Desligamento do Arduino

O problema de auto desligamento é interessante. Se conseguimos que o Arduino se auto desligue, precisamos também adicionar um recurso para que ele se ligue quando for novamente energizado. Em outras palavras, como ligar novamente o Arduino que se auto desligou?

 A proposta está apresentada na Figura 1. A numeração dos componentes não está em sequência porque este circuito foi recortado de um outro maior. Como já foi dito, a alimentação é feita a partir do 12 V do carro, assim, o diodo D1, por enquanto, tem a função de reduzir um pouco a tensão de alimentação para não ficarmos próximos do limite do regulador do Arduino.

 Nesta figura, o principal componente para o auto desligamento é Q1, o MOSFET IRF9530 [2] [3], que vai trabalhar no corte e saturação e foi escolhido pela sua disponibilidade no mercado local. Certamente, sua capacidade de corrente é muito superior à demanda do Arduino. Ele tem canal P e por isso deve ficar entre a alimentação e a carga (Arduino). Para evitar disparos indevidos quando sua Porta (G1) está desconectada, é usual colocar um resistor (R2) entre essa Porta (G1) e o Dreno (D1). Esse resistor não é crítico e deve ter o valor de algumas dezenas de kΩ. Quando o MOSFET entra em saturação, é como se se formasse um curto circuito entre o Dreno (D1) e a Fonte (S1), já no corte do MOSFET se assemelha a um circuito aberto. O controle da transição entre o corte e a saturação é feito pela Porta (G1).

  • G1 = nível alto (HIGH) à Q1 corta e remove a alimentação do Arduino e
  • G1 = nível baixo (LOW) à Q1 satura e alimenta o Arduino.

 Note então que R2 é, na verdade, um resistor de pullup que coloca G1 em nível alto, quando não há um acionamento na porta. A Porta G1 é controlada pelo transistor Q2, o BS170 [4], um MOSFET de canal N. Como tem canal N, ele deve estar entra a carga e a terra. O resistor R4 (pulldown) foi colocado entre a G2 e o D2 para evitar disparos indevidos. Note então que Q2 controla o nível de tensão de G1. Em suma, Q2 é o responsável por ligar (saturação) ou desligar (corte) Q1.

  • Se Q2 = saturado à G1 = LOW à Q1 satura e
  • Se Q2 = cortado à G1 = HIGH (ação de R2) à Q1 corta.

 Fig 1. Circuito para o auto desligamento do Arduino.

 

O controle do transistor Q2 será feito por um pino digital do Arduino. No caso deste projeto, o Pino 8 foi o escolhido para ser conectado à Porta G2 de Q2. Agora, controlando o nível lógico do Pino 8, podemos manter ligado ou desligar o Arduino. Em resumo:

  • Pino 8 = HIGH à Q2 satura à G1 = LOW à Q1 satura e alimenta o Arduino e
  • Pino 8 = LOW à Q2 corta à G1 = HIGH (ação de R2) à Q1 corta e desliga o Arduino.

 Agora vem o problema interessante. Quando se liga a alimentação (12 V), o Pino 8 ainda não foi configurado e por isso o Arduino não liga. Se o Arduino não liga, não conseguimos fazer Pino 8 = HIGH. A solução é adicionar um circuito auxiliar que, independente do Arduino, force a G2 para nível alto toda vez que o circuito for ligado. Se G2 está em nível alto, Q2 satura e vai garantir que Q1 alimente o Arduino.

 Na Figura 1, R4 e C4 têm a finalidade de forçar a G2 para nível alto toda vez em que a energia é ligada. Note que C4 está entre a alimentação de 11,3 V e G2. No caso de C4 estar totalmente descarregado, ele se comporta como um curto circuito quando se liga a energia. Nesse caso a tensão 11,3 V é toda aplicada à G2. Com o passar do tempo, esse capacitor vai se carregando e a tensão em G2 vai caindo até chegar a zero com C4 completamente carregado. Assim, a primeira ação do programa do Arduino deve ser a de programar Pino 8 = HIGH para assegurar a alimentação.

 É preciso lembrar que quando se liga o Arduino, o programa do usuário não é executado imediatamente. Após ser ligado, o Arduino demora perto de 0,9 segundo para passar o controle para o programa do usuário. Por outro lado, o transistor Q2 desliga quando a tensão em G2 fica abaixo de 2,0 V. O item importante aqui é que a velocidade de carregamento de C4 é ditada por seu valor nominal (2,2 µF) e pelo valor de R4 (1 MΩ). Precisamos, então, que R4 e C4 garantam G2 > 2,0 V por um pouco mais que 1 segundo.

A figura ao lado apresenta a curva de carga de C4, considerando que ele estava completamente descarregado. Elas foram traçadas considerando C4 = 2,2 µF e R4 = 1 MΩ. Note que à medida que C4 carrega, a tensão sobre G2, que inicialmente era de 11,3 V, vai caindo até chegar a zero. Já vimos que Q2 desliga e desenergiza o Arduino com G2 < 2,0 V. Assim, de acordo com a curva de “Tensão em G2”, este par RC garante aproximadamente 3,8 segundos para a inicialização do Arduino e a colocação do Pino 8 em nível alto (HIGH).

Figura 2. Tensão sobre G2 quando se ligam os 12 V.

Porém, se C4 não estiver completamente descarregado, então esse tempo (3,8 segundos) que temos para agir e garantir Pino 8 = HIGH vai diminuir. Por exemplo, se ao ligar a energia, C4 estiver carregado com 4,0 V, esse tempo diminui em aproximadamente 1 segundo. Na Figura 2, note que 4,0 V corresponde à aproximadamente 1 segundo na curva de Carga de C4. No caso desta proposta, C4 sempre estará descarregado, pois cada vez que se usa o auto desligamento, o Pino 8 em nível baixo realiza rapidamente esta tarefa.

 Essa descarga pelo pino do Arduino foi a principal preocupação em usar C4 com um valor baixo (2,2 µF). A descarga de um capacitor de maior valor poderia danificar este pino. Como C4 tinha um valor pequeno, foi necessário R4 com valor elevado para tornar lenta a carga do capacitor.

 

Testes com a Solução Proposta

 

Ensaio 1:

Vamos verificar o desempenho de C4 e R4, que são responsáveis por manter G2 > 2,0 V durante algum tempo, cada vez que a alimentação de 12 V é ligada. Vale lembrar que com C4 descarregado, quando se ligam os 12 V, temos G2 = 11,3 V. Depois essa tensão vai caindo com a carga de C4. Com G2 < 2,0 V, a alimentação VIN é desligada (Q2 corta). Então este circuito composto por C4 e R4 tem dois lados:

  • Ao ligar os 12 V, C4 está descarregado e força a saturação de Q2 o que garante alimentação para o Arduino e
  • Quando C4 se carrega, desliga Q2 e remove a alimentação do Arduino.

 Como se pode ver na Figura 3, o ensaio foi realizado com um osciloscópio acompanhando a tensão em G2 (Canal A) e a tensão VIN (Canal B), que é entregue ao Arduino. É claro que VIN = 0 significa que o transistor Q2 desligou a alimentação do Arduino.

 Fig 3. Conexão dos canais do osciloscópio para o Ensaio 1. Note que o Pino 8 não foi conectado.

 

Este primeiro ensaio foi para verificar por quanto tempo a alimentação VIN permanece ativa, quando se ligam os 12 V com C4 completamente descarregado. Como pode ser visto na Figura 4, tivemos perto de 1,9 segundo de funcionamento antes de VIN ser cortado pela ação de Q2 sobre Q1. De acordo com o calculado anteriormente e mostrado na Figura 2, deveríamos ter perto de 3,8 segundos. Conseguimos apenas a metade! Este é um ponto que merece uma investigação futura mais cuidadosa. Entretanto, vamos continuar. Esse intervalo 1,9 segundo deve ser suficiente para a inicialização do Arduino e execução do programa do usuário que assume o controle de G2.

 Nesta Figura 4, as escalas de tensão para as curvas azul e vermelha são diferentes. Mais um detalhe, o leitor pode estranhar a legenda “VIN = 10,6 V”. Isso acontece porque este ensaio foi realizado com o circuito de carga do super capacitor que, por simplicidade não está mostrado. Este circuito “rouba” 0,7 V da tensão de alimentação.

 Fig. 4. Ensaio 1: verificar quanto tempo o par C4 e R4 sustenta VIN, quando a alimentação de 12 V é ligada com C4 completamente descarregado.

 

Ensaio 2:

Para verificar se era possível o Arduino assumir o controle dentro deste período de 1,9 segundo, foi realizado este segundo ensaio, mas agora usando o canal B (em vermelho) do osciloscópio para monitorar o pino 13 do Arduino, que estava programado com a rotina da Listagem 1, apresentada logo a seguir. Neste ensaio, dois momentos são importantes:

  • Pino 13 estável em nível alto à indica programa do usuário em execução e
  • Pino 13 estável em nível baixo à indica Arduino foi desligado.

 

Listagem 1:

void setup() {

  pinMode(13,OUTPUT);   //Configurar pino 13 como saída

  digitalWrite(13,HIGH);     //Acender led (pino13 = HIGH)

  while(1);                          //Laço infinito

}

void loop() { }

 

A Figura 5 apresenta o resultado de tal medição. Como pode ser observado, o período de inicialização do Arduino durou perto de 0,9 segundo. Depois disto, o programa do usuário foi executado durante 1,0 segundo antes da alimentação ser cortada pela carga de C4. Esses valores estão aproximados. Vemos que temos folga para o programa do usuário assumir o controle da Porta G2 e ligar VIN de forma definitiva.

 Fig. 5. Ensaio 2:  verificar se o período de funcionamento garantido pelo par C4 e R4 era suficiente para a inicialização do Arduino e execução do programa do usuário.

 

Ensaio 3:

Vamos agora fazer um ensaio mais exigente. O esquema usado está na Figura 6. O Pino 8 do Arduino será usado para colocar G2 em nível alto e assim garantir, de forma definitiva, a alimentação do Arduino. Como já vimos na Figura 5, após a inicialização do Arduino, temos aproximadamente 1 segundo para fazermos Pino 8 = H (High). É claro que, quando quisermos desligar a alimentação, basta fazer Pino 8 = L (Low).

 Fig. 6. Ensaio 3:  verificar o  funcionamento do auto desligamento e o religamento quando a alimentação de 12 V é refeita.

 

 Foi usado o programa da Listagem 2, logo abaixo. Para este ensaio, assim que possível o Arduino assume o controle da alimentação e a desliga depois de 5 segundos. Note que neste programa, a primeira coisa que se faz é configurar o Pino 8 e colocá-lo em nível alto (H), assim Q2 continua saturado e garante a alimentação VIN. Depois de 5 segundos, o programa coloca o Pino 8 em nível baixo (L) e com isso se auto desliga.

 

Listagem 2:

void setup() {

  pinMode(8,OUTPUT);     //Pino 8 como saída

  digitalWrite(8,HIGH);       //Pino 8 = HIGH ==> Ligar Q2

  pinMode(13,OUTPUT);   //Pino 13 como saída

  digitalWrite(13,HIGH);     //Acender led da placa

  delay(5000);                    //Esperar 5 segundos

  digitalWrite(8,LOW);        //Pino 8 = LOW ==> Desligar Q2

  while(1);                          //Laço de segurança

}

void loop() { }

 

Na Figura 7, a linha em azul (Canal A) mostra a tensão sobre G2 e a linha vermelha (Canal B) acompanha a alimentação VIN. Veja que as escalas de tensão são diferentes. Nesta figura, em azul, se vê claramente o momento em que os 12 V foram ligados e a curva que caracteriza a carga de C4. Antes dessa curva chegar em 2,0 V, o programa colocou o Pino 8 em nível alto (H) e assim garantiu alimentação estável. Depois de 5 segundos, o programa colocou o Pino 8 em nível baixo (L) e assim desligou VIN e o Arduino parou de funcionar.

 Nesta figura, note um pequeno pico negativo indicado por “Desligou 12 V”. Este é o instante em que a alimentação de 12 V foi desligada, com isso o capacitor C4 rapidamente se descarregou pelo Pino 8 do Arduino. Na descarga, a tensão sobre o capacitor inverte de polaridade e, por isso, o pico é negativo. Um pouco depois, a alimentação foi novamente ligada e tudo se repetiu.

 Figura 7. Ensaio para verificar comportamento do circuito quando o Arduino assume o controle da alimentação.

 

Conclusão

Como se pode ver pelos ensaios realizados, o circuito que permite o auto desligamento do Arduino funciona corretamente. Além disso, o recurso para forçar o religamento por ocasião da aplicação dos 12 V também ofereceu bom desempenho. A única exigência é que a primeira ação do programa do usuário seja a de colocar em nível alto o pino que garante a alimentação. O transistor Q1 deve ser selecionada em função da corrente demanda pelo circuito completo. Na solução apresentada, ele está superdimensionado.

 No próximo artigo vamos abordar o uso de super capacitores para garantir o funcionamento do Arduino Mega por alguns segundos.

  

Referências

 [1] https://store.arduino.cc/usa/mega-2560-r3

 [2] https://pt.wikipedia.org/wiki/MOSFET

 [3] https://www.vishay.com/docs/91076/sihf9530.pdf

 [4] https://www.onsemi.com/pub/Collateral/BS170-D.PDF

 

 O autor recomenda o livro

 

Exibições: 614

Comentar

Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!

Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)

Comentário de Ricardo Zelenovsky em 9 fevereiro 2020 às 15:40

Obrigado, vou levar isso em conta (filtros de RF) quando fizer os ensaios de campo.

Comentário de José Gustavo Abreu Murta em 9 fevereiro 2020 às 12:26

Ah bom! Ai sim. Entendi. 

Para usar a bateria do carro para alimentar um Arduino, sugiro filtros (RF) para limitar ruídos de alta tensão na fonte. Eu já medi esses ruídos com scope e são significativos. 

Comentário de Ricardo Zelenovsky em 9 fevereiro 2020 às 9:57

Oi José Gustavo

Obrigado pelo comentário.

Esse esquema foi projetado para o que podemos apelidar de Caixa Preta para um carro. Assim, ela deve ligar toda vez que o carro for ligado. Quando o carro for desligado, ela armazena algumas informações numa memória flash e se desliga. Por isso, não precisa de botão de liga/desliga. Então:

1) Ligou o carro (12 V) a caixa liga sozinha.

2) Desligou o carro, a caixa ainda funciona alguns segundos sustentada pelo super capacitor e depois se auto desliga.

Acabei de enviar a terceira parte, onde está o circuito completo desta parte de alimentação.

Ricardo

Comentário de José Gustavo Abreu Murta em 9 fevereiro 2020 às 9:20

Bom dia, 

Confesso que não li tudo. 

Mas não esta faltando um botão de ligar?

Quando energiza 12 V , o Arduino liga sozinho. 

Depois poderá desligá-lo, se usar a porta de desliga (pino 8).

Como faz para ligar de novo? Sem desconectar o 12V. 

© 2022   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço