Franzininho - Controle do Relé Serial

Introdução

Agora que já vimos como programar a Franzininho DIY em nosso tutorial Franzininho - Primeiros Passos, está na hora de ampliar o universo de possibilidades desta pequena placa. Por possuir poucas entradas e saídas digitais, temos que aproveitar ao máximo os seis pinos disponíveis, e a melhor solução para essa limitação é o uso de módulos que possuam comunicação serial, como o Módulo Display Serial e o Módulo Relé Serial. Estes módulos podem ter todas suas funcionalidades controladas por apenas duas portas digitais de seu microcontrolador, além de possibilitar o controle individual de até 10 módulos interligados.

Neste tutorial iremos ensinar como controlar o Relé Serial através da Franzininho DIY, e como criar uma onda de acionamento de relés.

Lista de Materiais

Lista completa de produtos

comprar

Franzininho DIY

R$ 37,90 no PIX

Módulo Relé Serial

R$ 47,40 no PIX

Chave Momentânea (PushButton) - Pacote com 10 unidades

R$ 2,85 no PIX

Mini Protoboard 170 Pontos - Preta

R$ 3,70 no PIX

Fonte Chaveada 12V 1A

R$ 14,15 no PIX

Adaptador P4 Fêmea - Borne

R$ 3,70 no PIX

Jumpers Macho-Macho x40 Unidades

R$ 7,50 no PIX

Jumper Premium 10cm Fêmea-Fêmea - 40 Unidades

R$ 8,55 no PIX

Jumper Premium 10cm Macho-Fêmea - 40 Unidades

R$ 8,55 no PIX

Projeto Piscando Relé

Assim como fizemos em nosso tutorial de primeiros passos com a Franzininho, e como é sempre recomendado para os primeiros testes de qualquer novo microcontrolador, vamos iniciar os estudos do módulo Relé Serial piscando o relé de número um do módulo, em intervalos de um segundo.

Circuito

Para este projeto, monte o circuito abaixo.

Vale lembrar que os relés do módulo Relé Serial possuem bobinas de 12 V, portanto é indispensável o uso de uma fonte que seja capaz de fornecer essa tensão.

Software

Biblioteca

Antes de prosseguir neste tutorial, instale a biblioteca do Relé Serial em sua Arduino IDE. Para isso, baixe o arquivo do botão abaixo.

Biblioteca "SerialRelay"

Caso não saiba como instalar bibliotecas na Arduino IDE, siga os passos do nosso tutorial Adicionando Bibliotecas na IDE Arduino.

Código

Para observar o piscar de seu módulo Relé Serial, copie e carregue o código a seguir.

/*******************************************************************************
* Franzininho DIY - Pisca Rele (v1.0)
* 
* Codigo para piscar o rele 1 do modulo 1 com intervalos de 1 segundo.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (24/03/2020).
* Creditos: Francois - RoboCore (2015)
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Inclusao da biblioteca
#include <SerialRelay.h>

//Definicao da variavel que armazena a quantidade de modulos
const int NUMERO_MODULOS = 1; //Altere essa variavel de acordo com a quantidade de modulos utilizados

//Declaracao do objeto
SerialRelay rele(0,1,NUMERO_MODULOS); //(PINO_DATA, PINO_CLK, NUMERO_DE_MODULOS)

void setup() {
  
}

void loop() {
  
  //Aciona o rele 1 do modulo 1 durante 1 segundo e entao o desliga
  rele.SetRelay(1, SERIAL_RELAY_ON, 1);
  delay(1000);
  rele.SetRelay(1, SERIAL_RELAY_OFF, 1);
  delay(1000);
  
}

Entendendo o Código

Primeiramente incluímos no código a biblioteca SerialRelay, previamente instalada. Em seguida declaramos a variável NUMERO_MODULOS, que é responsável por armazenar a quantidade de módulos Relé Serial que estão interligados. Com o comando SerialRelay rele(0,1,NUMERO_MODULOS), criamos o objeto rele em função da classe SerialRelay, através dos pinos 0 e 1 da Franzininho (DATA e CLOCK, respectivamente, no Relé Serial) e em relação ao número de módulos utilizados, mediante à variável NUMERO_MODULOS já declarada.

//Inclusao da biblioteca
#include <SerialRelay.h>

//Definicao da variavel que armazena a quantidade de modulos
const int NUMERO_MODULOS = 1; //Altere essa variavel de acordo com a quantidade de modulos utilizados

//Declaracao do objeto
SerialRelay rele(0,1,NUMERO_MODULOS); //(PINO_DATA, PINO_CLK, NUMERO_DE_MODULOS)

Por fim, no looping do código, acionamos o relé 1 do módulo 1 através do comando rele.SetRelay(1, SERIAL_RELAY_ON, 1). Aguardamos um segundo (delay(1000)) para desligá-lo por meio do comando rele.SetRelay(1, SERIAL_RELAY_OFF, 1), e aguardamos um segundo novamente, para que o código se repita.

//Aciona o rele 1 do modulo 1 durante 1 segundo e entao o desliga
rele.SetRelay(1, SERIAL_RELAY_ON, 1);
delay(1000);
rele.SetRelay(1, SERIAL_RELAY_OFF, 1);
delay(1000);

O Que Deve Acontecer

Após carregar o código para a placa com o circuito montado, será possível observar o LED do relé um do módulo acender e apagar, como no GIF a seguir, e ouvir o barulho do acionamento e desacionamento do relé.

Resultado Final

Projeto Onda de Acionamentos

Neste projeto iremos selecionar o sentido de onda de acionamentos através de botões. Ao pressionar um dos botões, os relés irão simular uma onda para a esquerda ou para a direita.

Circuito

Para este projeto, monte o circuito a seguir.

Código

Com o circuito acima montado, carregue o código a seguir para a sua Franzininho.

/*******************************************************************************
* Franzininho DIY - Onda de Acionamentos (v1.0)
* 
* Codigo para acionar os reles do modulo Rele Serial simulando uma onda
* para esquerda ou para a direita, ao pressionar um dos botoes seletores.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (24/03/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Inclusao da biblioteca
#include <SerialRelay.h>

//Definicao da variavel que armazena a quantidade de modulos
const int NUMERO_MODULOS = 1; //Altere essa variavel de acordo com a quantidade de modulos utilizados

//Definicao da variavel de intervalo de tempo em milissegundos
const int TEMPO_ESPERA = 1000; //Altere essa variavel de acordo com o tempo entre acionamentos desejado

//Definicao das variaveis dos botoes
const int PINO_BOTAO_DIREITA = 2;
const int PINO_BOTAO_ESQUERDA = 3;

//Declaracao do objeto
SerialRelay rele(0,1,NUMERO_MODULOS); //(PINO_DATA, PINO_CLK, NUMERO_DE_MODULOS)

void setup(){

  //Definicao dos pinos dos botoes como entradas de nivel logico alto
  pinMode(PINO_BOTAO_DIREITA, INPUT_PULLUP);
  pinMode(PINO_BOTAO_ESQUERDA, INPUT_PULLUP);

}

void loop(){

  //Verifica se o botao foi pressionado
  if(digitalRead(PINO_BOTAO_DIREITA) == LOW){
    delay(30);
    if(digitalRead(PINO_BOTAO_DIREITA) == LOW){

      //Executa a animacao de acionamento dos reles
      for(int i=1; i <= NUMERO_MODULOS; i++){
        for(int j=1 ; j <= 4 ; j++){
          rele.SetRelay(j, SERIAL_RELAY_ON, i);
          rele.SetRelay(j - 1, SERIAL_RELAY_OFF, i);    
          delay(TEMPO_ESPERA);
        }
        rele.SetRelay(4, SERIAL_RELAY_OFF, i);
      }
      
    }
  }

  //Verifica se o botao foi pressionado
  if(digitalRead(PINO_BOTAO_ESQUERDA) == LOW){
    delay(30);
    if(digitalRead(PINO_BOTAO_ESQUERDA) == LOW){

      //Executa a animacao de acionamento dos reles
      for(int i=NUMERO_MODULOS; i >= 1; i--){
        for(int j=4 ; j >= 1 ; j--){
          rele.SetRelay(j, SERIAL_RELAY_ON, i);
          rele.SetRelay(j + 1, SERIAL_RELAY_OFF, i);    
          delay(TEMPO_ESPERA);
        }
        rele.SetRelay(1, SERIAL_RELAY_OFF, i);
      }

    }
  }
  
}

Entendendo o Código

Na declaração global do código, além da inclusão da biblioteca SerialRelay, da criação do objeto rele e da declaração da variável NUMERO_MODULOS, incluímos as variáveis PINO_BOTAO_DIREITA e PINO_BOTAO_ESQUERDA, que armazenam os pinos da Franzininho aos quais estão conectados os botões. Além destas variáveis, declaramos a variável TEMPO_ESPERA, que é utilizada para realizar um tempo de espera entre os acionamentos dos relés.

//Definicao da variavel de intervalo de tempo em milissegundos
const int TEMPO_ESPERA = 1000; //Altere essa variavel de acordo com o tempo entre acionamentos desejado

//Definicao das variaveis dos botoes
const int PINO_BOTAO_DIREITA = 2;
const int PINO_BOTAO_ESQUERDA = 3;

Em seguida, nas configurações do programa, configuramos as variáveis que armazenam os pinos dos botões como entradas, em nível lógico alto (pull up).

//Definicao dos pinos dos botoes como entradas de nivel logico alto
pinMode(PINO_BOTAO_DIREITA, INPUT_PULLUP);
pinMode(PINO_BOTAO_ESQUERDA, INPUT_PULLUP);

No looping do código, adicionamos a lógica por trás da animação de onda dos relés, mas primeiramente, por meio de um debounce de trinta milissegundos, verificamos através dos comandos if(digitalRead(PINO_BOTAO_DIREITA) == LOW) e if(digitalRead(PINO_BOTAO_ESQUERDA) == LOW), se algum dos botões foi pressionado. Caso o botão da esquerda tenha sido pressionado, por exemplo, o código executa a animação de onda para o lado esquerdo.

Para as animações de onda, utilizamos dois laços for, um dentro do outro. Para a animação no sentido da direita, o primeiro laço (for(int i = 1; i <= NUMERO_MODULOS; i++)) é responsável por executar a animação dos relés enquanto a variável i for menor ou igual ao valor configurado pela variável NUMERO_MODULOS. A cada repetição deste laço, a variável i é incrementada em uma unidade através do comando i++, e o relé 4 do módulo i é desligado, já que, caso isso não fosse feito, o relé 4 de cada módulo se manteria aceso após o ciclo. Já o laço for(int j = 1; j <= 4; j++) é responsável por selecionar, na sequência, um relé por vez do módulo atual, ou seja, o laço será verdadeiro enquanto a variável j for menor ou igual a 4, que é o número de relés por módulo. Neste laço, a cada repetição, a variável j é incrementada em uma unidade, um dos relés é acionado, e o relé anterior é desligado, tudo isso com intervalos definidos pela variável TEMPO_ESPERA, através do comando delay(TEMPO_ESPERA).

Todo o laço de animação acima apenas aciona os relés para a direita, mas para que possamos acionar os relés para a esquerda, temos de inverter a lógica dos laços. Para isso utilizamos os laços for(int i=NUMERO_MODULOS; i >= 1; i--) e for(int j = 4; j >= 1; j--), que executam uma lógica contrária à utilizada anteriormente, decrementado as variáveis dos laços. Além disso, alteramos a condição de desligamento do relé anterior e para desligar o último relé do módulo, já que agora a onda está se movimentando no sentido contrário.

//Verifica se o botao foi pressionado
if(digitalRead(PINO_BOTAO_DIREITA) == LOW){
  delay(30);
  if(digitalRead(PINO_BOTAO_DIREITA) == LOW){

    //Executa a animacao de acionamento dos reles
    for(int i=1; i <= NUMERO_MODULOS; i++){
      for(int j=1 ; j <= 4 ; j++){
        rele.SetRelay(j, SERIAL_RELAY_ON, i);
        rele.SetRelay(j - 1, SERIAL_RELAY_OFF, i);    
        delay(TEMPO_ESPERA);
      }
      rele.SetRelay(4, SERIAL_RELAY_OFF, i);
    }
      
  }
}

//Verifica se o botao foi pressionado
if(digitalRead(PINO_BOTAO_ESQUERDA) == LOW){
  delay(30);
  if(digitalRead(PINO_BOTAO_ESQUERDA) == LOW){

    //Executa a animacao de acionamento dos reles
    for(int i=NUMERO_MODULOS; i >= 1; i--){
      for(int j=4 ; j >= 1 ; j--){
        rele.SetRelay(j, SERIAL_RELAY_ON, i);
        rele.SetRelay(j + 1, SERIAL_RELAY_OFF, i);    
        delay(TEMPO_ESPERA);
      }
      rele.SetRelay(1, SERIAL_RELAY_OFF, i);
    }

  }
}

O Que Deve Acontecer

Após carregar o código para a placa e alimentar o circuito com uma fonte de 12 V, será possível observar os LEDs realizando uma onda de acionamentos no sentido do botão pressionado, como no GIF abaixo.

Resultado Final

Indo Além

Agora que você já aprendeu a implementar um acionamento em onda dos relés do módulo Relé Serial, por que não alterar o método de acionamento das animações de um botão para um Sensor de Presença PIR, por exemplo? Deste modo você poderá criar algo como um corredor inteligente, onde as lâmpadas do corredor se acendem conforme você passa por elas. Para isso bastaria calibrar o tempo de intervalo entre acionamentos, e ampliar o número de acionamentos para a quantidade de lâmpadas de seu corredor.

Além disso, como o Módulo Display Serial utiliza a mesma comunicação do Relé Serial, tente implementar um cronômetro com a Franzininho DIY, seguindo os passos de nosso tutorial Módulo Display Serial - Primeiro Contato. Vale lembrar que talvez sejam necessárias algumas alterações de código e de circuito para este projeto.

Comentários

Para fazer comentários é necessário estar logado. Efetuar login.

Você ainda nao é cadastrado? Cadastre-se agora!

juliano4
date

Enviado 2022-04-20 16:40:55

VC SO PODE CONTROLAR 4 RELES, PRECISO DE 8 RELES
SE PUDER ME AJUDAR AGRADEÇO

detoledo.victor
date

Enviado 2022-04-20 17:15:06
juliano4

Com o módulo relé Serial é possível controlar até 40 relés (10 módulos), basta adquirir outra peça e ligar ela em série, com o primeiro. Para mais informações, acesse a pagina do produto, relé serial.

fabio.baldessar
date

Enviado 2020-12-10 14:33:10

A minha versão da IDE não é a Hourly Build.

fabio.baldessar
date

Enviado 2020-12-10 14:39:57
fabio.baldessar

Oi, como este problema ainda não foi resolvido, vc poderia me ajudar em um outro problema de código, pois o Serial não é tão necessário. Eu o usária de vez em quando. Para ver se tinha outro problema tinha comentado as areás da Serial e tinha um outro problema com a função rtc. Quando verifico o código dis o seguinte código de erro:
&#39;rtc&#39; does not name a type.
Poderia me ajudar nesse segundo problema.

fabio.baldessar
date

Enviado 2020-12-10 14:40:44
fabio.baldessar

rtc does not name a type
Não sei porque saiu esse monte de digitos.

Giovanni5

Enviado 2020-12-10 15:11:15
fabio.baldessar

Você está tentando carregar um código para a Franzininho ou usar o monitor serial com ela? Vale lembrar que, a Franzinho DIY não possui conversor USB/UART (por isso não é reconhecida como porta COM), portanto não é compatível com as ferramentas seriais da Arduino IDE (plotter e monitor serial).
Além disso, você está tentando usar a Franzininho com um módulo RTC? Se sim, lembre-se que o microcontrolador ATtiny85 da placa não possui barramento I2C, portanto não é compatível com esse tipo de módulo, pelo menos não diretamente.

Giovanni5

Enviado 2020-12-10 15:12:43
fabio.baldessar

É possível fazer uma adaptação na interface serial do microcontrolador para simular um barramento I2C, como é mostrando no link a seguir, https://playground.arduino.cc/Code/USIi2c/ . Entretanto essa adaptação não deve ser muito simples de ser implementada.

fabio.baldessar
date

Enviado 2020-12-10 13:32:28

Mudei agora, mas dis que a Serial não foi declarada.

Giovanni5

Enviado 2020-12-10 13:55:45
fabio.baldessar

Se a Arduino IDE ainda está acusando a falta na seleção da porta serial, é sinal que há uma configuração incorreta, portanto certifique-se de ter selecionado o modelo de placa correto ("Arduino Gemma") , assim como o programador, que você já deve ter mudado. Além disso, qual versão da Arduino IDE você está usando? Se for a versão "Hourly Build" fornecida pela Microsoft Store, isso pode ser um erro de funcionamento da própria IDE. Portanto desinstale essa versão, para instalar a versão mais atual e estável disponível no link a seguir,  https://www.arduino.cc/en/software .

Giovanni5

Enviado 2020-12-10 13:57:06
fabio.baldessar

Se continuar com dificuldades, encaminhe um e-mail para suporte@robocore.net, com o número do seu pedido, uma cópia completa da mensagem de erro retornada pela IDE, e uma captura de tela da aba "Ferramentas" da sua Arduino IDE.

fabio.baldessar
date

Enviado 2020-12-08 09:49:47

Oi, estava tentando fazer um código para um sistema com o módulo Rele mas quando aperto em verificar Sketch o arduino IDE diz que a Serial não foi declarada, poderia me ajudar pois com as blackboards normais da Robocore o código carrega normalmente. E isso acontece apenas com o Franzininho.Mas estou usando RTC DS3231

Giovanni5

Enviado 2020-12-08 10:53:38
fabio.baldessar

Provavelmente a opção "Programador" das "Ferramentas" da Arduino IDE não foi alterada para "USBtinyISP" que ignora a seleção da porta COM. Altere essa opção antes de carregar o código para a placa, e observe o resultado ao tentar novamente.