Relógio Arduino com Alarme e Módulo TM1637
No Artigo anterior, criamos um relógio utilizando o módulo TM1637 e a única funcionalidade implementada foi a apresentação das horas. Entretanto, uma característica bastante comum nos relógios digitais é o alarme programado. Ou seja, por meio disso, podemos gerar um alarme para alertar um usuário ou acionar uma carga por meio de um relógio Arduino com alarme.
Portanto, nesse artigo apresentaremos o processo de implementação de um alarme programável a partir do artigo: Relógio com o Módulo TM1637 e Arduino
Através desse artigo, você será capaz de aprender:
- Implementação do alarme no Arduino;
- Utilização da memória EEPROM para salvar dados permanentes.
Agora, iniciaremos a apresentação completa da nova funcionalidade desenvolvida.
Desenvolvimento do Projeto
Primeiramente, apresentamos o circuito desenvolvido para a criação do sistema de alarme.
Para o desenvolvimento e montagem desse projeto, você irá utilizar os seguintes componentes, que são encontrados em nossa Loja Autocore Robótica.
Lista de Materiais
- Arduino Nano
- Módulo RTC DS1307
- Módulo TM1637
- Resistor 10kR
- Resistor 330R
- 4 Botões de Toque
- 1 Buzzer 5V
- 1 LED Vermelho 5mm
Funcionamento do Relógio Arduino com Alarme
De acordo com o circuito da Figura 1, implementamos mais dois botões, um buzzer e um LED sinalizador.
O Botão A será utilizado para configurar o alarme. Após o usuário pressioná-lo, o LED Vermelho sinalizador será acionado. E por meio dos botões H e M, o usuário irá ajustar o tempo e hora de alarme em que o Buzzer será acionado.
Logo após a finalização do ajuste, o usuário deverá pressionar o botão F, para finalizar o processo de configuração do alarme e o LED será desligado.
Baseado nesse princípio de funcionamento, foi implementada a função a seguir, a fim de criar o sistema de configuração do alarme.
<code>#include <TM1637Display.h>
#include <DS1307.h>
#include <Wire.h>
#include <EEPROM.h>
TM1637Display display(2, 3);
bool BotaoHora = 0, BotaoMinuto = 0;
bool EstadoBotaoHoraAnt = 0, EstadoBotaoMinutoAnt = 0;
int valorfinal;
int DataTime[7];
byte segto = 0x80, hora = 0, minuto = 0, AlarmeHora = 0, AlarmeMinuto = 0;
void ConfigAlarme();
#define HORAMEM 0
#define MINMEM 1
#define Buzzer 7
#define Alarme 8
#define Enter 9
#define PinoHora 10
#define PinoMinuto 12
#define LED 13
void setup()
{
display.setBrightness(0x0f);
DS1307.begin();
pinMode(Enter, INPUT);
pinMode(PinoHora, INPUT);
pinMode(PinoMinuto, INPUT);
pinMode(LED, OUTPUT);
pinMode(Buzzer, OUTPUT);
AlarmeHora = EEPROM.read(HORAMEM);
AlarmeMinuto = EEPROM.read(MINMEM);
}
void loop()
{
DS1307.getDate(DataTime);
hora = DataTime[4];
minuto = DataTime[5];
display.showNumberDecEx((hora * 100) + minuto, 0x40, 1, 4, 0); //Apresenta o valor da hora e do display
BotaoHora = digitalRead(PinoHora);
BotaoMinuto = digitalRead(PinoMinuto);
if (BotaoHora == 1 && EstadoBotaoHoraAnt == 0)
{
hora++;
DS1307.setDate(0, 0, 0, 0, hora, minuto, 0); //Ano, Mes, Data do Mes, Dia da Semana, hora, minuto, segundo
EstadoBotaoHoraAnt = 1;
if (hora > 23)
{
hora = 0;
}
}
if (BotaoHora == 0 && EstadoBotaoHoraAnt == 1)
{
EstadoBotaoHoraAnt = 0;
}
if (BotaoMinuto == 1 && EstadoBotaoMinutoAnt == 0)
{
minuto++;
DS1307.setDate(0, 0, 0, 0, hora, minuto, 0); //Ano, Mes, Data do Mes, Dia da Semana, hora, minuto, segundo
EstadoBotaoMinutoAnt = 1;
if (minuto > 59)
{
minuto = 0;
}
}
if (BotaoMinuto == 0 && EstadoBotaoMinutoAnt == 1)
{
EstadoBotaoMinutoAnt = 0;
}
bool BotaoAlarme = digitalRead(Alarme);
if(BotaoAlarme == 1)
{
ConfigAlarme();
}
if((hora == AlarmeHora) && (minuto == AlarmeMinuto))
{
digitalWrite(Buzzer, HIGH);
}
else
{
digitalWrite(Buzzer, LOW);
}
}
void ConfigAlarme()
{
bool BotaoEnter = 0;
digitalWrite(13, HIGH);
delay(1000);
do
{
BotaoHora = digitalRead(PinoHora);
BotaoMinuto = digitalRead(PinoMinuto);
if (BotaoHora == 1 && EstadoBotaoHoraAnt == 0)
{
AlarmeHora++;
EstadoBotaoHoraAnt = 1;
if (AlarmeHora > 23)
{
AlarmeHora = 0;
}
}
if (BotaoHora == 0 && EstadoBotaoHoraAnt == 1)
{
EstadoBotaoHoraAnt = 0;
}
if (BotaoMinuto == 1 && EstadoBotaoMinutoAnt == 0)
{
AlarmeMinuto++;
EstadoBotaoMinutoAnt = 1;
if (AlarmeMinuto > 59)
{
AlarmeMinuto = 0;
}
}
if (BotaoMinuto == 0 && EstadoBotaoMinutoAnt == 1)
{
EstadoBotaoMinutoAnt = 0;
}
BotaoEnter = digitalRead(Enter);
display.showNumberDecEx((AlarmeHora * 100) + AlarmeMinuto, 0x40, 1, 4, 0); //Apresentacao do Tempo
}while(BotaoEnter == 0);
EEPROM.write(HORAMEM, AlarmeHora);
EEPROM.write(MINMEM, AlarmeMinuto);
delay(1000);
digitalWrite(LED, LOW);
}</code>
A seguir, apresentaremos a discussão do código acima. Ele é similar ao apresentado no artigo anterior, porém, possui a implementação da função de alarme.
Primeiramente, realizamos a implementação da função ConfigAlarme. Esta função foi implementada, a fim de criar a configuração do alarme.
Função de Configuração do Alarme
A função de configuração será chamada quando o botão Configurar for pressionado. Isto é apresentado no trecho de código apresentado a seguir.
<code> if(BotaoAlarme == 1)
{
ConfigAlarme();
}</code>
Quando o botão for pressionado, a função será chamada e será executado o seguinte bloco de código.
<code>void ConfigAlarme()
{
bool BotaoEnter = 0;
digitalWrite(13, HIGH);
delay(1000);
do
{
BotaoHora = digitalRead(PinoHora);
BotaoMinuto = digitalRead(PinoMinuto);
if (BotaoHora == 1 && EstadoBotaoHoraAnt == 0)
{
AlarmeHora++;
EstadoBotaoHoraAnt = 1;
if (AlarmeHora > 23)
{
AlarmeHora = 0;
}
}
if (BotaoHora == 0 && EstadoBotaoHoraAnt == 1)
{
EstadoBotaoHoraAnt = 0;
}
if (BotaoMinuto == 1 && EstadoBotaoMinutoAnt == 0)
{
AlarmeMinuto++;
EstadoBotaoMinutoAnt = 1;
if (AlarmeMinuto > 59)
{
AlarmeMinuto = 0;
}
}
if (BotaoMinuto == 0 && EstadoBotaoMinutoAnt == 1)
{
EstadoBotaoMinutoAnt = 0;
}
BotaoEnter = digitalRead(Enter);
display.showNumberDecEx((AlarmeHora * 100) + AlarmeMinuto, 0x40, 1, 4, 0); // dispaying value of hour and minutes on display
}while(BotaoEnter == 0);
EEPROM.write(HORAMEM, AlarmeHora);
EEPROM.write(MINMEM, AlarmeMinuto);
delay(1000);
digitalWrite(LED, LOW);
}</code>
Inicialmente, realizamos o acionamento do LED, para sinalizar que o sistema entrou na opção de ajuste de alarme, conforme apresentado na Figura 2.
Logo após, o fluxo de código entrará no laço do while, a fim de realizar a leitura dos botões de ajuste da hora do alarme.
A lógica de ajuste é similar à configuração das horas e minutos, inclusive, são utilizados os mesmos botões a fim de criar uma simples interface de configuração.
Logo após a configuração do alarme, o usuário necessita pressionar o botão F, para finalizar e sair do laço.
Posteriormente, o valor de hora e minuto serão salvos na memória EEPROM, de acordo com o código abaixo.
<code> EEPROM.write(HORAMEM, AlarmeHora);
EEPROM.write(MINMEM, AlarmeMinuto);
delay(1000);
digitalWrite(LED, LOW);</code>
A seguir, apresentaremos o processo de armazenamento do tempo de alarme na memória EEPROM e sua aplicação neste projeto.
Armazenando as Horas na Memória EEPROM
Os dados de Hora e Minuto são salvos na memória, de modo a garantir que quando o CHIP seja desligado, os dados possam permanecer salvos no sistema.
Baseado nisso, implementamos as seguintes linhas de programação na função void setup().
<code> AlarmeHora = EEPROM.read(HORAMEM); AlarmeMinuto = EEPROM.read(MINMEM);</code>
Assim, ao energizar o Arduino, os dados serão lidos da posição HORAMEM e MINMEM da memória EEPROM.
Portanto, jamais perderemos os dados configurados pelo usuário.
Logo após a configuração do alarme, o fluxo sairá da função e retornará para o código principal na função loop.
Execução do Alarme do relógio Arduino
No loop principal, o usuário poderá ajustar as horas e minutos, conforme já apresentado no artigo anterior. Além disso, foi inserida a condição para verificar se a hora atual é igual à hora de alarme ajustada pelo usuário.
A seguir, é possível ver a porção de código, que representa esta condição.
<code> if((hora == AlarmeHora) && (minuto == AlarmeMinuto))
{
digitalWrite(Buzzer, HIGH);
}
else
{
digitalWrite(Buzzer, LOW);
}</code>
Portanto, caso a hora e minuto sejam iguais ao tempo ajustado pelo usuário, o Buzzer será acionado. Caso contrário, o Buzzer permanecerá desligado.
Após isto, o código ficará em loop apresentando as horas, conforme apresentado na Figura 3.
Por fim, o usuário poderá realizar a configuração de um novo alarme ou ajuste em tempo real das horas, conforme apresentado no artigo citado no início deste projeto.
Conclusão
Os alarmes programados são de grande interesse na área de automação industrial e residencial. Através deles, podemos realizar diversos acionamentos de cargas e atividades em horários específicos.
Assim, por meio desse artigo, foi possível implementar o alarme e compreender o processo de manipulação da memória EEPROM. Dessa forma, o usuário poderá manter o valor ajustado salvo e recuperá-lo posteriormente, caso ocorra o desligamento do CHIP.
Portanto, sugerimos utilizar este projeto e utilizá-lo para a criação de um novo sistema para acionamento programado de dispositivos. Para isso, conheça todos os nossos artigos do blog e cadastre-se em nossa lista de e-mail, a fim de receber novos projetos.
Deixe um comentário
