A Comunicação I2C do Módulo RTC é uma ferramenta bastante útil quando optamos por projetos mais complexos, com grande volume de pinos e dados uma vez que possibilita a inclusão de mais de um produto em apenas dois pinos digitais do módulo Arduino mais suas respectivas alimentações.
A facilidade e a utilidade de um projeto são de suma importância para quem deseja executar um trabalho de qualidade e eficiência, para uma melhor visualização das realidades que envolvem um projeto de comunicação I2C, iremos utilizar como exemplo um Display LCD 16×2 com Adaptador I2C e um RTC (Real Time Clock) DS1307.
Projeto Relógio Arduino com Display e RTC
A maioria dos MCUs utilizados para o desenvolvimento de projetos é independente de tempo, ou seja, não dependem de informações como data e horário para o seu funcionamento e por mais que normalmente isto não interfira em nossos projetos, de vez em quando nos deparamos com ideias onde esta informação é fundamental e daí, é necessária a inclusão de um RTC.
O Módulo DS1307 é perfeito para projetos que contêm registros de dados, armazenamento de tempos mais longos, temporizadores mais precisos, alarmes e até mesmo para projetos de Relógios Arduino e em casos como este, é necessária a inclusão de um display para visualização destas informações, mas e se fosse possível fazer tudo isto com apenas dois pinos do Arduino?
Módulo RTC DS1307
O Real Time Clock, ou em sua tradução o Relógio de Tempo Real, é um produto que possui a capacidade de manter armazenadas informações de horas, minutos e segundos, além de dia, mês e ano. Para quem possui dúvidas quanto ao seu funcionamento, o mesmo possui um ajuste para meses com menos de 31 dias e realiza a conversão automática de anos bissextos até o ano de 2100.
Tendo como base de funcionamento o chip RTC DS1307 bastante preciso e de baixo custo, o módulo possui a capacidade de gerenciar todas as funções de cronometragem através de uma interface I2C simples de dois fios, facilmente conectada a qualquer microcontrolador.
Módulo Tempo Real – Chip DS1307 e 24C32
Na imagem acima, além do Chip DS1307, também podemos observar a inclusão do chip EEPROM 24C32 de 32 bytes da Atmel, que possibilita a armazenagem de dados, configurações e demais informações e utiliza o mesmo barramento I2C com endereço fixo em 0x50 HEX.
O módulo RTC possui também uma entrada de bateria que mantém a contagem de tempo mesmo que a energia principal do dispositivo seja interrompida, Com um sistema que monitora continuamente o status do pino VCC e detecta falhas de energia e alterna automaticamente para a fonte de backup.
Local para Instalação da Bateria CR2032 junto ao RTC
Com este recurso, não é necessário preocupar-se com quedas de energia, por exemplo, pois mesmo sem a alimentação do microcontrolador o RTC ainda pode continuar acompanhando o tempo e permanecer configurado. Com um suporte de bateria 20mm, torna-se compatível com qualquer bateria de lítio 3V do tipo CR2032, além de possuir uma trava que auxilia na remoção da bateria para eventuais manutenções e procedimentos.
Módulo RTC DS1307 com Sensor DS18B20
Ao analisarmos o Módulo RTC verificamos que o mesmo possui um local com três terminais isolados no canto superior ao lado do suporte da bateria, este local é fornecido para a conexão direta de um módulo Dallas DS18B20, veja abaixo o local específico para instalação e lembre-se que a ordem de instalação dos pinos deve coincidir com o desenho expresso na placa:
Local para Instalação do Sensor de Temperatura DS18B20
Vale ressaltar que o sensor de temperatura é um elemento adicional e não precisa ser obrigatoriamente instalado, porém caso seja necessário ao projeto, após a instalação do DS18B20 este irá apresentar os seus respectivos valores através do pino DS do Módulo RTC e deve ser conectado a uma porta previamente configurada do Arduino.
Pinagem do Módulo DS1307
O módulo RTC DS1307 possui um total de sete pinos para alimentação e comunicação sendo cinco desses, duplicados para auxiliar na instalação e utilização do mesmo. Na imagem abaixo podemos observar de forma descriminada todos os pinos disponíveis junto ao módulo e após uma breve descrição dos mesmos:
Pinos para comunicação e Alimentação do Módulo RTC DS1307
SQ ou SQW – Pino que fornece uma frequência de onda quadrada de 1Hz, 4kHz, 8kHz ou 32kHz que pode ser utilizado através de programação.
DS – Pino disponível para leitura de temperatura do sensor DS18B20. Obs: O sensor precisa ser instalado para gerar este valor.
SCL e SDA – Pinos de comunicação I2C utilizados para enviar e receber dados em conjunto com o microcontrolador.
VCC e GND – Pinos de alimentação 3,3 ou 5V.
BAT – Entrada para célula de lítio de 3V ou outra fonte de alimentação de mesma tensão para manutenção dos dados caso haja problema com a alimentação via pino ou bateria. Elemento opcional e pouco utilizado uma vez que a bateria CR2032 normalmente supre esta necessidade.
Produtos Utilizados no Teste
– Módulo Relógio Tempo Real RTC Compacto – DS1307;
– Display LCD 16×2 I2C com Fundo Verde;
– Buzzer Ativo 5V Bip Contínuo – PCI 12mm;
– Jumper Premium para Protoboard Macho-Fêmea 20 cm.
Esquema de Ligação do Relógio Arduino com Display I2C
O esquema de ligação do Projeto com Módulo RTC é bastante simples, diferencia-se apenas no fato de estar sendo utilizada uma comunicação I2C que compartilha seus pinos de funcionamento. No Arduino estes dois pinos são normalmente associados aos pinos Analógicos A4 e A5, porém possuem acesso também em uma posição oposta após os pinos digitais, observe na imagem abaixo:
Pinos de Comunicação I2C do Arduino UNO
Como podemos ver na imagem, estes pinos elencados possuem as mesmas funções, então se alfo for conectado nos pinos da esquerda ou nos pinos da direita, estarão correspondendo aos mesmos pinos de comunicação I2C, o que consequentemente faz destes, pinos de comunicação analógica.
O esquema de ligação é extremamente simples, além dois pinos de alimentação para os módulos e os dois pinos de comunicação I2C, inclui-se apenas um buzzer para emissão de sinais sonoros do despertador, veja na imagem abaixo:
Esquema de ligação do Relógio Arduino com Despertador
O presente projeto será dividido em três partes, inicialmente será desenvolvido um código para verificação do endereço de cada um dos dispositivos I2C, após iremos configurar o horário do RTC, procedimento que deve ser desenvolvido uma única vez salvos os momentos em que o mesmo fique sem nenhuma alimentação, nem mesmo a bateria, caso contrário o horário ficará armazenado continuamente.
A terceira parte será responsável pela configuração do Display e do RTC para oportunizar e acionar o alarme sonoro sempre que o horário pré-programado for atingido.
Scanner I2C para Leitura de Endereços
O primeiro passo fundamental para o desenvolvimento de um projeto que utiliza equipamentos de comunicação I2C é descobrir o endereço de cada um destes dispositivos. Esta informação é bastante importante, uma vez que é ela quem irá diferenciar o local de origem de cada um dos dados fornecidos ao Arduino.
Para realizarmos este procedimento iremos utilizar o seguinte código abaixo, um código padrão que é utilizado para este tipo de procedimento, mas que está totalmente traduzido e pronto para uso, segue abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
// Scanner I2C Arduino – Projeto Relógio Arduino com Despertador #include <Wire.h> void setup() { Wire.begin(); Serial.begin(9600); Serial.println("Scanner I2C"); } void loop() { byte erro, endereco; int dispositivos; Serial.println("Procurando Dispositivo I2C ..."); dispositivos = 0; for (endereco = 1; endereco < 127; endereco++ ) { Wire.beginTransmission(endereco); erro = Wire.endTransmission(); if (erro == 0) { Serial.print("Dispositivo I2C encontrado. Endereco 0x"); if (endereco < 16) Serial.print("0"); Serial.print(endereco, HEX); Serial.println(" !"); dispositivos++; } else if (erro == 4) { Serial.print("Erro desconhecido no Endereco 0x"); if (endereco < 16) Serial.print("0"); } } if (dispositivos == 0) Serial.println("Nenhum dispositivo I2C encontrado\n"); else Serial.println("Scanneamento Concluido\n"); while(Serial); } |
Este código utiliza apenas uma biblioteca, já instalada automaticamente junto ao software Arduino e que não necessita ser incluída, através da função while(Serial); delimitei o loop de leitura para apenas uma vez, após esta é necessário fechar a tela do monitor serial e reabri-la para verificar alguma alteração nos endereços, outra opção é alterar este procedimento por um delay, por exemplo.
Endereços obtidos na leitura junto ao Scanner I2C
Acima, podemos observar os endereços obtidos na leitura de endereços junto ao Scanner I2C, estas informações serão muito importantes para o desenvolvimento do nosso projeto quando trabalharmos em projetos mais complexos.
Configurando horário junto ao Módulo RTC
A configuração do horário pode ser feita uma única vez já que o Módulo RTC possui a capacidade de armazenar os dados em sua memoria interna com o auxilio da Bateria CR2032, então mesmo que cesse a energia de alimentação do seu projeto, este continuará marcando o horário corretamente quando voltar.
Mesmo com esta capacidade, infelizmente o Módulo RTC não vêm configurado de fabrica, desta maneira é necessário o desenvolvimento de um código específico que execute a configuração deste horário. A configuração do horário pode ser desenvolvida tanto de maneira manual, utilizando o horário em específico desejado, quanto de forma automática tendo como base o horário de compilação do código no Arduino.
Para realizar a compilação do código, é necessária a utilização das seguintes bibliotecas:
Biblioteca LiquidCrystal I2C: DOWNLOAD AQUI.
Biblioteca RTClib: DOWNLOAD AQUI.
Abaixo, segue o código que executa ambas as opções, porém vale lembrar que deve-se optar por uma delas e a outra deve ficar temporariamente como comentário, ou seja, deve conter as duas “//” antes do comando para não interferir, veja:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
#include <LiquidCrystal_I2C.h> // Inclui a Biblioteca #include <RTClib.h> // Inclui a Biblioteca RTC_DS1307 rtc; LiquidCrystal_I2C lcd(0x27, 16, 2); // Inicia o display 16x2 no endereço 0x27 void setup() { rtc.begin(); // Inicia o módulo RTC rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Ajuste Automático da hora e data //rtc.adjust(DateTime(2019, 11, 29, 10, 23, 00)); // Ajuste Manual (Ano, Mês, Dia, Hora, Min, Seg) lcd.init(); // Inicia o Display lcd.backlight(); // Inicia o Backlight } void loop() { DateTime now = rtc.now(); lcd.setCursor(1, 0); // Posiciona o cursor na primeira linha lcd.print("Hora: "); // Imprime o texto "Hora: " lcd.print(rtc.now().hour()); // Imprime a Hora lcd.print(":"); // Imprime o texto entre aspas lcd.print(rtc.now().minute()); // Imprime o Minuto lcd.print(":"); // Imprime o texto entre aspas lcd.print(rtc.now().second()); // Imprime o Segundo lcd.setCursor(0, 1); // Posiciona o cursor na segunda linha lcd.print("Data: "); // Imprime o texto entre aspas lcd.print(rtc.now().day()); // Imprime o Dia lcd.print("/"); // Imprime o texto entre aspas lcd.print(rtc.now().month()); // Imprime o Mês lcd.print("/"); // Imprime o texto entre aspas lcd.print(rtc.now().year()); // Imprime o Ano delay(1000); // Aguarda 1 segundo e reinicia lcd.clear(); } |
O exemplo citado é o que segue:
|
1 2 |
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Ajuste Automático da hora e data //rtc.adjust(DateTime(2019, 11, 29, 10, 23, 00)); // Ajuste Manual (Ano, Mês, Dia, Hora, Min, Seg) |
Desta maneira em específico, será realizada a configuração automática através do horário de compilação, para realizar a configuração manual devemos tirar as barras antes da segunda função e incluí-las na primeira, de forma que fique do seguinte modo:
|
1 2 |
//rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Ajuste Automático da hora e data rtc.adjust(DateTime(2019, 11, 29, 10, 23, 00)); // Ajuste Manual (Ano, Mês, Dia, Hora, Min, Seg) |
Assim como descrito no comentário após o comando, os números de dia e horário são dispostos de maneira que siga a seguinte ordem: Ano, mês, dia, hora, minuto e segundo, ou seja, da maneira que está temos o dia 29 de novembro de 2019 (20/11/2019) com o horário das 10:23:00.
As demais informações deste código encontram-se todas citadas através dos comentários e possuem fácil compreensão.
Configurando o Despertador Arduino com Módulo RTC
A configuração do despertador utiliza um código bastante semelhante ao especificado acima, porém neste, eliminamos o ajuste dia e hora, já que já foram realizados anteriormente e adicionamos uma função que verifica a hora e aciona um elemento de sinal sonoro, o qual utilizamos um Buzzer Ativo 5V ligado diretamente no Arduino.
O código está totalmente comentado e é de fácil adaptação de acordo com cada necessidade individual, veja abaixo o código completo e após uma prevê explicação de algumas funções:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
#include <LiquidCrystal_I2C.h> // Inclui a Biblioteca #include <RTClib.h> // Inclui a Biblioteca RTC_DS1307 rtc; LiquidCrystal_I2C lcd(0x27, 16, 2); // Inicia o display 16x2 no endereço 0x27 #define buzzer 11 // Define o buzzer como pino 11 int Hor; // Inicia a variável Hor int Min; // Inicia a variável Min int Seg; // Inicia a variável Seg void setup() { pinMode(buzzer, OUTPUT); rtc.begin(); // Inicia o módulo RTC lcd.init(); // Inicia o Display lcd.backlight(); // Inicia o Backlight } void loop() { DateTime now = rtc.now(); Hor = rtc.now().hour(); // Chama o horário de Hor Min = rtc.now().minute(); // Chama o minuto de Min Seg = rtc.now().second(); // Chama os segundos de Seg // Define o horário do despertador e executa o som do buzzer if ( Hor == 15 && Min == 7) { digitalWrite(buzzer, HIGH); delay(1000); digitalWrite(buzzer, LOW); delay(1000); } lcd.setCursor(1, 0); // Posiciona o cursor na primeira linha lcd.print("Hora: "); // Imprime o texto "Hora: " lcd.print(Hor); // Imprime a Hora lcd.print(":"); // Imprime o texto entre aspas lcd.print(Min); // Imprime o Minuto lcd.print(":"); // Imprime o texto entre aspas lcd.print(Seg); // Imprime o Segundo lcd.setCursor(0, 1); // Posiciona o cursor na segunda linha lcd.print("Data: "); // Imprime o texto entre aspas lcd.print(rtc.now().day()); // Imprime o Dia lcd.print("/"); // Imprime o texto entre aspas lcd.print(rtc.now().month()); // Imprime o Mês lcd.print("/"); // Imprime o texto entre aspas lcd.print(rtc.now().year()); // Imprime o Ano delay(1000); // Aguarda 1 segundo e reinicia lcd.clear(); } |
Desta vez, para diferenciar um pouco os códigos, nomeamos as variáveis de hora, minuto e segundo através do seguinte comando:
|
1 2 3 4 |
DateTime now = rtc.now(); Hor = rtc.now().hour(); // Chama o horário de Hor Min = rtc.now().minute(); // Chama o minuto de Min Seg = rtc.now().second(); // Chama os segundos de Seg |
Desta maneira reduzimos um pouco os comandos e trabalhamos a nomeação de variáveis em elementos fixos, ou seja, no caso acima, dizemos que sempre que no código estiver presente o texto “Hor”, este irá relacionar-se com a variável rtc.now().hour() e apresentar os respectivos valores desta.
Quanto à definição do horário do despertados, esta é realizada através da função abaixo, a qual delimita um horário e um minuto específico para acionamento do buzzer e tem como duração de acionamento o intervalo de um minuto, teoricamente enquanto a Hor e o Min delimitados foram o mesmo do código, este mantem-se acionado, veja:
|
1 2 3 4 5 |
if ( Hor == 15 && Min == 7) { digitalWrite(buzzer, HIGH); delay(1000); digitalWrite(buzzer, LOW); delay(1000); |
Tendo a função “if” acima, temos que sempre que o horário for 15:07 o buzzer irá acionar-se por um período de um segundo e deligar-se no mesmo período continuamente até finalizar o seu tempo de ação. Uma observação importante é que no código tanto hora quanto minuto não devem conter o 0 de unidade, ex 4, 7 ou 9, apenas de dezenas como 10 ou 20, por exemplo.
Conclusão
O projeto para desenvolvimento de um despertador com Módulo RTC é extremamente simples, mesmo que aparente ser parcialmente complicado, através das respectivas bibliotecas este se mostra direto e preciso. O Arduino em conjunto com o Módulo RTC pode ser utilizado para os mais diversificados projetos e é facilmente configurado.
O despertador desenvolvido trabalha com um tempo de acionamento fixo, enquanto o horário estipulado por o mesmo, este irá manter-se acionado, um fator o qual explica não setarmos os segundos, uma vez que o despertador iria acionar-se apenas naquela hora minuto e segundo e após finalizar sua execução.
Para quem desejar, fica o desafio de incluir ao projeto um push button, por exemplo, para realizar a função de desligar o despertador, uma função para controle de backlight para inclusão de sinais luminosos e também outras funções que complementam o projeto.
Ao realizar o seu projeto, não se esqueça de deixar o seu comentário com a sua experiência, compartilhar as funções que adicionou e as melhorias que implementou. Use e abuse das capacidades do Arduino em seus projetos, explore todas as funções e aqui deixo um desafio, que tal adicionar mais um elemento de comunicação I2C ao seu projeto?
Boa tarde, amigo! Excelente seu artigo, fiz a transposição da parte do relógio para um display OLED, também I2C, e me foi muito útil! Obrigado.
TENHO 50 AINDA NAO CONHECIA ESTE TIPO DE TECNOLOGIA QUE PARECE SER TÃO COMPLICADO , QUE NA VERDADE E MUITO SIMPLES DE APRENDE É UM MUNDO MUITO GRANDE PRA SE CONHECER, MAIS PELO POUCO QUE CONHECEI ME APAIXONEI POR ESSA TECNOLOGIA QUE ACREDITO NAO DEIXA MAS, QUE AGORA VAI FAZER PARTE DA MINHA VIDA, ATE COMO ROBY, E COMO PROFISSIONAL, POS JA TENHO CONHECIMENTO EM ELETRÔNICA QUE JÁ NÃO USO MAIS COMO PROFISSÃO QUE AGORA VAI ME SERVIR MAIS MAIS UMA VEZ, OBRIGADO
boa tarde ,mechamo alexandre ,estou precisando de montar uma sirene para escola ,que seja acionada nos intervalos das aulas ,recreio ,na verdade e para um trabalho de fisica,teria algo do genero no arduino ?desde ja agradeço
Boa tarde Alexandre, precisaria desenvolver um projeto com um rele, RTC, Arduino e uma Sirene. Não possuímos um projeto similar já publicado.