Módulo relé – Acionando cargas com Arduino

Ao se trabalhar com sistemas inteligentes, é comum a necessidade de se controlar cargas das mais diversas potências, tal como: lâmpadas, motores, resistências, etc. O componente mais usado para ligar e desligar esses aparelhos são o relés. O relés são responsáveis por ligar e desligar equipamentos através de comandos. Neste tutorial você entenderá a importância dos relés, como funcionam. Aprenderá, também, a usar um módulo relé com seu Arduino.

[toc]

Para que servem os Relés?

Os microcontroladores, tais como Atmega, PIC e MSP, são dispositivos lógicos. Eles são usados com o intuito de ser a inteligência do circuito, o cérebro de nosso sistema inteligente.

Por isso, um microcontrolador usa tensões e correntes baixas para funcionar e não são produzidos para suportar grandes tensões e correntes. O Arduino UNO, por exemplo, que usa o Atmega328, suporta um máximo de 40mA em suas portas I/O e fornece uma tensão de 5V. Além disso, é sempre aconselhável separar o sistema de inteligência do sistema de acionamento, para que curtos ou problemas no sistema de acionamento não danifique sua placa Arduino.

Quando queremos acionar cargas com valores de corrente ou tensão maiores precisamos utilizar algum dispositivo que suporte tal carga. Por exemplo: Queremos acender uma lâmpada de 127V quando estiver escuro. Sabemos que o Arduino não é capaz de fornecer tal tensão, para isso iremos precisar de algum dispositivo capaz de ligar e desligar a lâmpada através do comando do nosso Arduino, uma boa pedida é o relé.

Para entender melhor o relé, vamos ver a diferença e semelhança entre ele e um interruptor residencial.

– Entendendo um interruptor

Diariamente ligamos e desligamos lâmpadas através de um dispositivo muito eficaz, o interruptor. Tal como o nome já diz, ele tem a capacidade de interromper o fluxo de energia e vice-versa. Veja na figura abaixo como um interruptor trabalha. O fio vermelho, que é o positivo e traz a energia, passa pelo interruptor e depois vai para a lâmpada que já possui o negativo conectado. Quando o interruptor está aberto, não temos passagem de energia, quando mudamos o estado dele e fechamos o contato, a lâmpada liga.

– Entendendo um Relé

Um relé é semelhante a um interruptor, com uma diferença, não precisamos usar nosso dedo para fechar ou abrir o contato. Para essa função, usamos um sistema engenhoso que quando alimentado, fecha o contato.

Esse sistema engenhoso possui um eletroímã, ou seja. Uma bobina que quando energizada criará um campo eletromagnético, se tornando um imã. Devido a força de atração magnética do eletroímã teremos a movimentação do interruptor. Veja a imagem a baixo para que possa entender melhor:

Quando alimentamos os terminais 3 e 4 da bobina, ela gera um campo eletromagnético que atrai a haste conectada ao terminal 2, que vence a força exercida pela mola conectada a ela. Isso faz com que essa haste se mova até encostar na haste conectada ao terminal 1. Com isso, teremos o contato fechado.

Quando paramos de alimentar a bobina através dos terminais 3 e 4, a força magnética exercida sobre a haste conectada ao terminal 2 deixa de existir e a mola puxa a haste de volta ao seu lugar inicial, abrindo o contato. Portanto, agora temos um interruptor acionado por uma bobina.

Usando um relé, podemos controlar um dispositivo, tal como a lâmpada de 127V que possui uma corrente e tensão alta, através da alimentação de uma bobina. A corrente e a tensão que essa bobina precisa varia com a especificação do relé.

Módulo Relé

Apesar de a bobina relé demandar uma corrente e uma tensão baixa, ainda assim o relé precisa de mais energia do que uma porta digital da sua placa Arduino pode fornecer.

Por conta disso, precisamos de um circuito auxiliar para o acionamento do relé. Esse circuito, que usa uma fonte de alimentação que pode ser a própria saída de 5V do seu Arduino, não é trivial, mas já pode ser encontrado pronto nos módulos relés muito usados com Arduino. Esse tipo de módulo poupa tempo e é muito simples de usar.

Veja que esse módulo relé possui 3 pinos. São eles:

• Vcc – Pino para alimentação 5V
• GND – Pino para Terra 0v
• IN – Pino de comando do módulo. Esse é o pino responsável por ligar ou desligar o relé.

Existem vários modelos de módulos relés com diversas quantidades de canais, indo até 16 relés em uma só placa:

Veja algumas opções de módulos relés nesse link do Vida de Silício

---

Mãos à obra – Detectando elementos

Cuidado!

Nesse tutorial iremos mexer com tensões e correntes maiores. Tome cuidado ao manusear seu projeto, risco de choque!!

Tome cuidado para não energizar seu Arduino com a tensão da tomada. Isso irá queimá-lo.

Componentes utilizados:

• Placa UNO ou outra placa Arduino
• 1x Módulo Relé 1 canal
• 1 x Protoboard
• Jumpers

Montando o projeto

Na figura abaixo, o leitor poderá conferir como foi realizada a montagem do projeto apresentado neste tutorial.  Lembre-se de montar o projeto com o seu Arduino desligado.

Vamos separar essa montagem em duas partes:

– Circuito de controle

Essa parte do projeto representa o Arduino e seus periféricos de baixa potência. Para montar seu circuito, use a figura a seguir. Garanta que seu Arduino esteja desligado durante a montagem.

O pino de entrada do botão é o 8 e o pino de saída do relé é o 13.

– Circuito de potência

Nessa parte iremos montar a parte de maior potência do nosso circuito. Para esse projeto iremos precisar de uma extensão que você não usará mais, ou você pode fazer a sua.

Quando lidamos com energia elétrica temos que tomar muito cuidado! Então monte seu projeto com segurança.  Não queremos transformar nossa diversão em dor de cabeça, não é mesmo?

Por isso, vamos montar uma extensão segura. Caso você já tenha uma que possa cortar os seus fios, você poderá usá-la. Basta executar apenas os três últimos passos.

Para nossa extensão você vai precisar de:

• Um adaptador de tomada macho
• Um adaptador de tomada fêmea
• 4 metros de Fio de cobre (Fique à vontade em relação ao tamanho).

Vamos montar nossa extensão:

• Divida seu fio de cobre em dois fios de 2 metros (ou metade do tamanho que você tiver). Dessa forma, você terá dois fios iguais;
• Com seu alicate, descasque a ponta de cada fio;

• Parafuse a ponta dos dois no adaptador macho;

• Parafuse a outra ponta dos dois no adaptador fêmea;

• Agora vamos conectá-la ao nosso circuito.
• Corte um dos dois fios em um ponto onde ficará nosso módulo relé, verifique o melhor ponto para coloca-lo. (É para corta apenas um dos fios!)

• Descasque as duas pontas do fio cortado;
• Parafuse uma no comum (COM) e outra no contato normalmente aberta (Pode está escrito nessa porta a sigla NA ou NO);

Agora, volte, e confira se você realmente montou tudo como explicado.

Seu circuito ficará semelhante ao da foto a seguir:

Programando

Antes de adentrarmos na apresentação do código, disponibilizamos uma seção para ajudar aqueles que são iniciantes no assunto. Sinta-se livre para prosseguir caso você já tem domínio da IDE do Arduino.

– Código do projeto

Crie um programa (sketch) e salve com o nome de “programa_modulo_rele”.

Com o seu programa salvo, escreva nele o código conforme escrito abaixo.

#define RELE 13 
#define BOTAO 8

void setup() 
{
    pinMode(BOTAO, INPUT_PULLUP);
    pinMode(RELE, OUTPUT);
    estavel = digitalRead(BOTAO);
    estadoRele= 0; 
}

bool changed() 
    {
         bool now = digitalRead(BOTAO);   
         if (instavel != now) 
         {       
              bounce_timer = millis();   
              instavel = now;            
         }
         else if (millis() - bounce_timer > 10) 
         {  
              if (estavel != now) 
              {           
                  estavel = now;                  
                  return 1;
         }
    }
    return 0;
}

void loop() 
{
     if (changed()) { //verifica se houve mudança de estado
     { 
          if (digitalRead(BOTAO))
          {   
               estadoRele=!estadoRele;  //se mudou o estado e o botão está pressionado muda o valor de set
          }
     }
     digitalWrite(RELE,estadoRele);
}

Depois de escrever o código, clique em Upload para que o programa seja transferido para seu Arduino.

Colocando para funcionar

Conecte algum aparelho em sua extensão (que tenha uma coerente menor que 10A), um ventilador por exemplo. Então ligue seu Arduino e em seguida ligue a tomada de sua extensão.

Cuidado!

Só ligue seu sistema na tomada quando tiver a certeza que está tudo corretamente conectado.

Tome cuidado para não tomar um choque ou energizar seu Arduino com a tensão da tomada. Isso irá te machucar ou queimar seu Arduino.

Se tudo deu certo, quando você apertar o botão uma vez, o dispositivo que estiver ligado na tomada deverá ligar.

Quando apertar uma segunda vez, o dispositivo deverá desligar.

---

Entendendo a fundo

Software

– Nomeando os pinos utilizados através da diretiva #define

Primeiramente, utilizamos a diretiva #define para associar o pino de entrada digital 13 ao nome RELE e o pino digital 8 ao nome BOTAO (vale ressaltar que isso é apenas um recurso para facilitar a didática da programação, portanto, não obrigatório).

#define RELE 13
#define BOTAO 8

– Declarando as variáveis a serem utilizadas no projeto

Em seguida, temos um bloco onde ocorre a declaração das variáveis que serão utilizadas no decorrer do programa. As variáveis estavel e instavel (ambas booleanas) e a variável bounce_timer (tipo unsigned long) são responsáveis por coordenar o processo de tratamento do bounce existente ao utilizarmos um push-button. Além disso, temos a variável estadoRele, também booleana, cuja função é acionar e desacionar o relé.

Um ponto importante que deve ser ressaltado aqui é que neste tipo de projeto torna-se fundamental o tratamento citado anteriormente, portanto, caso você tenha dúvidas no procedimento, sugerimos a leitura do nosso tutorial Leitura de botões e o Bounce.

bool estavel;    // Guarda o último estado estável do botão;
bool instavel;   // Guarda o último estado instável do botão;
unsigned long bounce_timer;
bool estadoRele;

– Definindo as configurações iniciais do projeto

Dentro da função setup(), temos a definição dos modos de operação dos pinos que serão utilizados neste projeto, isto é, do pino 13 como um pino de saída digital e do pino 8 como um pino de entrada digital. Além desta configuração, por meio da função digitalRead(), fazemos com que a variável estavel armazene o estado em que o botão se encontra no começo do programa e por fim, carregamos a variável estadoRele com o valor 0.

void setup() {
  pinMode(BOTAO, INPUT_PULLUP);  
  pinMode(RELE, OUTPUT); 
  estavel = digitalRead(botao);
  estadoRele= 0;
}

– Acionando o relé

O procedimento de acionamento do relé é bem simples, de modo que, a única coisa que fazemos é verificar o retorno gerado através da execução da função changed(), o qual, será verdadeiro ou falso. Caso o retorno da mesma seja verdadeiro, quer dizer que o usuário do projeto deseja efetuar uma mudança no estado do relé, sendo assim, verifica-se posteriormente se o botão está pressionado, para que, por fim, o conteúdo da variável estadoRele seja atualizado com o inverso do seu valor e possa ser utilizado na manipulação do relé através da função digitalWrite().

void loop() 
{
     if (changed()) 
     { 
          if (digitalRead(botao))
          {   
               estadoRele=!estadoRele; 
          }
     digitalWrite(RELE,estadoRele);
}

Conforme ressaltamos anteriormente, utilizamos a função changed() para conferir se houve alguma mudança do estado do relé, desejada pelo operador. Esta função é a responsável por atuar no tratamento do bounce quando houver um aperto do botão. Basicamente, o que ocorre neste ponto é a verificação do estado do botão após a passagem de uma quantidade de tempo julgada necessária para garantirmos que o sinal não sofre mais alterações em virtude da trepidação inerente ao seu funcionamento.

Novamente ressaltamos que, caso você tenha alguma dúvida neste ponto, consulte nosso tutorial sobre o tratamento do bounce, clicando aqui.

bool changed() 
    {
         bool now = digitalRead(BOTAO);   
         if (instavel != now) 
         {       
              bounce_timer = millis();   
              instavel = now;            
         }
         else if (millis() - bounce_timer > 10) 
         {  
              if (estavel != now) 
              {           
                  estavel = now;                  
                  return 1;
         }
    }
    return 0;
}

---

Desafio

Agora que sabemos usar um módulo relé. Que tal usar um sensor de presença para acender uma lâmpada ou um sensor de temperatura para ligar seu ventilador? Seria uma boa ideia para automatizar o seu quarto, o que acha?

Faça isso:

• Ligue uma lâmpada quando detectar movimento no ambiente (Tutorial HC-SR501) ;
• Ligue um ventilador caso a temperatura esteja muito alta (Tutorial LM35).

Dica: Leia nosso tutorial ensinando como controlar um Módulo Relé através de seu celular utilizando um Módulo Bluetooth:

• Módulo Bluetooth HC-06 e HC-05 – Acionando relés via Bluetooth

Considerações finais

Neste tutorial demonstramos como você deve proceder para utilizar relés no acionamento de cargas cujas especificações de tensão e corrente não permitem que as mesmas sejam feitas diretamente por uma placa Arduino. Esperamos que você tenha gostado deste conteúdo e sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.