Arduino Tutorial - Alarm Clock - EEPROM

1,536

18

7

Posted

Introduction: Arduino Tutorial - Alarm Clock - EEPROM

Neste tutorial onde iremos mostra-vos como utilizar a memória EEPROM do Arduino através de uma montagem de um relógio despertador, que irá indicar a hora do relógio e a hora programada do alarme num pequeno Display. Esta montagem utiliza uma placa RTC, que fornece a informação de hora e data ao Arduino, um LCD 16x2, onde será escrita a essa informação e um pequeno Buzzer que produz um sinal sonoro, quando é activado o alarme.

Como realizado em tutoriais anteriores, "Arduino Tutorial - Clock - LCD" ou "Arduino Tutorial - LDC - Menu", será recordada a explicação do funcionamento da placa RTC DS1307, de um LCD 16x2, com também de um Buzzer, sendo este o componente mais simples.

Caso queiram saber mais sobre a RTC DS1307, o LCD 16x2 ou o Buzzer vejam as suas datasheet (Ver ficheiros abaixo), alem destes vejam também as especificações detalhadas do Arduino UNO através da página oficial do Arduino em "https://store.arduino.cc/arduino-uno-rev3".

Step 1: Montagem

Esta montagem utiliza uma Breadboard onde realizamos as ligações eléctricas entre os vários componentes, um LCD 16x2 onde visualizamos a informação do relógio e do alarme, uma placa RTC DS1307 que fornece essa informação ao Arduino, por fim 3 botões para navegar no menu de acerto do nosso relógio e um Buzzer que produz um aviso sonoro sempre que a hora do relógio for igual à hora do alarme.

Material necessário:

  • 1x Arduino UNO;
  • 1x Cabo USB;
  • 1x Breadboard;
  • 1x LCD16x2;
  • 1x Resistência 220Ω;
  • 1x Potenciómetro 10KΩ;
  • 1x RTC DS1307;
  • 3x Botões (Push Button);
  • 3x Resistências 1KΩ;
  • 1x Buzzer Module.

Instalação do LCD 16x2:

Como podem observar na imagem da montagem completa não utilizamos todos os pinos do LCD, pois cada pino tem uma função especifica (Ver legenda acima). Assim para explicar mais facilmente o funcionamento do LCD, agrupei os seus pinos em 3 grupos, o grupo dos Pinos de Alimentação, o de Pinos de Comunicação e o de Pinos de Informação.

Pinos de Alimentação:

  • Gnd;
  • Vcc;
  • V0;
  • LED - ou A (Anodo);
  • LED + ou K (Catodo).

As alimentações do LCD (Gnd e Vcc) são feitas através dos pinos Gnd e +5V do Arduino UNO, pois são estáveis e protegidas não permitindo que existam sobrecargas ou curto-circuitos.

O Pino V0 tem a função de ajustar o contraste dos caracteres, para podermos controlar esse ajuste ligamos este pino uma resistência variável de 10KΩ, a funcionar como um divisor de tensão (Ver imagem acima), alterando assim a tensão entre 0 e 5V.

Os pinos de alimentação do LED de luz de fundo do LCD (A e K) são também ligados aos pinos de Gnd e +5V do Arduino UNO, no entanto, ligamos em série uma resistência de 220Ω para que o brilho não seja demasiado intenso, não permitindo que os LED internos do LCD se danifiquem.

Pinos de Comunicação:

  • RS (Register Select);
  • R/W (Read / Write);
  • E (Enable).

Nos pinos de comunicação apenas teremos de ter atenção ao pino R/W, pois este deve estar ligado a Gnd, para que seja permitido escrever no LCD aparecendo assim o caracteres, caso contrario podemos estar a ler o dados guardados na memoria interna do LCD, ficando o LCD em branco.

Pinos de Informação:

  • D0;
  • D1;
  • D2;
  • D3;
  • D4;
  • D5;
  • D6;
  • D7.

Nesta montagem utilizamos todos os pinos de alimentação e comunicação, no entanto, utilizamos apenas 4 dos 8 possíveis pinos de informação, pois podemos realizar esta montagem com metade dos pinos de dados. Isto é possível através da Biblioteca LiquidCrystal.h que utilizamos no código, permitindo ler o Byte (Byte = 8 bits) de informação enviado pelo Arduino dividido em 2 partes, ou seja, 4 bits de cada vez.

Para isso esta Biblioteca controla os pinos de comunicação, de forma a que o LCD saiba qual o tipo e quais os canais de comunicação que receberão a informação (Pinos D4 a D7).

Instalação da RTC DS1307:

Este componente tem a função de definir a informação de data e hora, fornecendo essa informação de forma precisa, mesmo quando a alimentação externa é desligada por algum motivo. Neste caso utilizámos uma RTC DS1307, que contem 2 linhas de pinos de alimentação externa e de comunicação (Ver legenda acima), no entanto iremos utilizar a linha com menos pinos, pois para esta montagem apenas são necessários os pinos Gnd, Vcc, SDA e SCL .

Pinos de Alimentação:

  • Gnd;
  • Vcc;
  • Bat.

A alimentação externa da RTC (Gnd e Vcc) são feitas através dos pinos Gnd e +5V do Arduino UNO, pois são estáveis e protegidas não permitindo que existam sobrecargas ou curto-circuitos.

O pino Bat apesar de não ser um pino de alimentação externa coloca-mos-o neste grupo, pois este pino está ligado directamente à bateria do tipo botão da RTC, que serve de alimentação interna, sendo este pino muito utilizado para a monitorização da carga da bateria.

Pinos de Comunicação:

  • SCL;
  • SDA;
  • DS;
  • SQ.

Os pinos de comunicação SCL e SDA da placa RTC fazem parte de um sistema de comunicação chamado I2C (Ver diagrama acima). Onde é possível comunicar com um ou mais equipamentos através de apenas duas únicas linhas, sendo o SDA ou SERIAL DATA a linha que transmite e recebe a informação, no entanto o SCL ou SERIAL CLOCK é o responsável por saber quando é que os equipamentos têm que receber ou enviar informação ficando assim todos sincronizados.

Estes pinos devem ser ligados aos pinos de entrada analógica do Arduino, no entanto, nem todas as entradas analogias têm as funções de comunicação I2C com as funções SCL e SDA. O Arduino UNO não tem indicação destes pinos na placa, de qualquer forma adiantamos que as entradas com essa função são A5 e A4, sendo o pino SCL o pino A5 e o pino SDA o pino A4 (Ver imagem acima).

Caso queiram saber mais sobre o sistema de comunicação I2C, vejam a sua explicação detalhada através deste Link "https://goo.gl/TF3FPe".

O pino DS está ligado a um sensor de Temperatura (Ver ficheiro abaixo), sendo este pino que permite transmitir os dados relativos à temperatura que o sensor está a sentir, sendo ligado aos pinos de entrada digitais do Arduino, no entanto, não iremos utiliza-lo nesta montagem.

O pino SQ normalmente não é utilizado, pois apenas contem um sinal de onda quadrada, não tendo uma função essencial ou relevante para a utilização da RTC, no entanto, existem muitas montagens onde este é utilizado para ligar um pequeno LED, indicando assim que a RTC está a funcionar correctamente.

Instalação do Buzzer Module:

O Buzzer Module é um dispositivo de sinalização de áudio montado numa pequena placa, que pode ser electromecânico ou piezoeléctrico, sendo a sua principal utilização em dispositivos de alarme e temporizadores.

Este Buzzer funciona a uma tensão de 5V DC, podendo ser alimentado directamente a uma fonte de alimentação DC produzindo um som contínuo. No entanto este tipo de Buzzer está incorporado num circuito com o transístor, permitindo um melhor controlo deste, vejam as sua explicações através deste Link "https://goo.gl/EAPZL2".

Pinos:

  • Gnd;
  • Vcc;
  • I/C;

Com os equipamentos mais complexos montados, colocamos por fim os 3 botões com as suas respectivas resistência de 1KΩ na Breadboard e ligamos-os aos pinos de entradas digitais. Com estes botões na montagem poderemos navegar nas páginas de acerto do relógio e de alarme através do LCD (Ver esquema abaixo), para isso esses botões têm as seguintes designações MAIS, MENU e MENOS.

Caso queiram saber mais sobre as entradas digitais do Arduino, vejam também o tutorial "Arduino Tutorial - Digital Input - Button - Monitor Serial", onde explicamos esta característica mais detalhadamente.

Step 2: Código

Agora no código, começamos por importar estas 3 bibliotecas, a TimeLib.h, a Wire.h e a DS1307RTC.h, estas bibliotecas facilitam a programação, pois contêm comandos, funções e referencias criadas especificamente para trabalhar com a placa RTC.

A biblioteca TimeLib.h activa as funcionalidades de tempo, como variáveis para os segundos, minutos, hora, dia , mês, etc, facilitando assim os cálculos dos valores de tempo.

void loop(){	//Variáveis com valores de tempo:
	second();
	minute();
	hour();
	day();
	month();
	year();
	now();	//Hora e data que está defina neste momento.
	
	//Verifica se tempo está definido ou sincronizado:
	timeStatus()
		//Devolve os seguintes valores:
		timeNotSet	//O valor de tempo não está definido;
		timeNeedsSync	//O Valor de tempo foi definido mas a sincronização falhou.
		timeSet		//O Valor de tempo está definido e sincronizado.	
	
	int h, m, s, D, M, A;		// Variáveis para alteração da hora e data.
	setTime (h, m, s, D, M, A);	//Alterar ou definir a hora e data.

	//Configura o valor de tempo sincronizado de outro equipamento.
	setSyncProvider(getTimeFunction);
}

A biblioteca Wire.h activa as funções de comunicação entre equipamentos através do sistema de comunicação I2C. Os pinos de comunicação deste sistema são diferentes nos vários modelos de Arduino, caso queiram saber quais os pinos utilizados vejam o Link "https://www.arduino.cc/en/Reference/Wire".

Por ultimo a biblioteca DS1307RTC.h activa as funcionalidades que permitem a leitura e escrita na dos dados de tempo guardados na RTC.

void loop(){
	int h, m, s, D, M, A;	// Variáveis para alteração da hora e data.
	//Define uma nova hora e data:
	setTime(h, m, s, D, M, A);
	//Grava na RTC os dados de tempo:
	RTC.set(now());
	//Lê na RTC os dados de tempo:
	RTC.get();
}

Alem destas 3 bibliotecas, importamos também a biblioteca EEPROM.h que permite gravar e ler dados gravados na memória não volátil do Arduino. Sendo assim possível memorizar a hora de alarme neste despertador mesmo que este fique sem energia.

Este tipo de memória é diferente nos vários tipos de placas do Arduino, tendo diferentes capacidades:

  • ATmega328 - 1024 Bytes - 1KB;
    • Arduino UNO;
    • Arduino Micro;
    • Arduino Nano;
    • Arduino Mini;
  • ATmega168 - 512 Bytes;
  • ATmega8 - 512 Bytes;
  • ATmega1280 - 4096 Bytes;
    • Arduino Mega.
  • ATmega2560 - 4096 Bytes - 4KB.
    • Arduino Mega.

Como nesta montagem utilizamos um Arduino UNO e este tem uma memória de 1KB, vejam as especificações técnicas em "https://store.arduino.cc/arduino-uno-rev3", este terá 1024 endereços ou posições, onde podemos guardar os nosso dados. No entanto teremos de ter em atenção de apenas podemos guardar nesses endereços dados de 8 bits, ou seja, com um valor até 256 (Ver quadro acima).

Para utilizar a memória EEPROM do Arduino através desta biblioteca, poderemos utilizar os seus principais comandos: Caso queiram ver mais sobre estes e outros comandos desta biblioteca, vejam as sua referencia em "https://www.arduino.cc/en/Reference/EEPROM"

//Apagar os dados na EEPROM.
int i;	//Variável para os endereços da EEPROM;
	
void loop(){
	for (int i=0; i<EEPROM.length(); i++){
		EEPROM.write(i, 0);	//"i" = Endereço onde será escritos 0.
	}
}
//-----------------------------------------------------
//Ler os dados gravados da EEPROM.
int i;		//Variável para os endereços da EEPROM;
int Valor;	//Variável para leitura da EEPROM;

void loop(){
	Valor = EEPROM.read(i);	//"i" = Endereço onde serão lidos os dados.
}
//-----------------------------------------------------
//Gravar dados na EEPROM.
int i;		//Variável para os endereços da EEPROM;
int Valor;	//Variável para leitura da EEPROM;

void loop(){
	EEPROM.write(i, Valor);	//"i" = Endereço onde serão lidos os dados.
}

Por fim importamos a biblioteca LiquidCrystal.h que simplifica o código de configuração do LCD, sendo apenas necessário configurar 2 funções para que fique a funcionar correctamente.

//Definir os pinos de comunicação e informação do LCD:
LiquidCrystal lcd ("RS", "E", "D7", "D6", "D5", "D4");

e

void setup(){
	//Inicia a comunicação com LCD 16x2:
	lcd.begin(2, 16);
}

Para escrever no LCD definimos apenaso local onde irá começar a ser escrita a informação, ou seja, a coluna e a linha, depois imprimimos o texto que queremos tendo em atenção que este LCD apenas tem 16 colunas e 2 linhas, caso o texto passe estes limites não aparecerão os caracteres.

void loop(){
	//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
	lcd.setCursor(0, 0);
	
	//Escreve no LCD:
	lcd.print("Bateria da RTC INOP");
}

Por fim, este é o código completo para a nossa montagem, onde são utilizados os conceitos descritos anteriormente tornando possível a concretização de um pequeno relógio despertador, onde se pode ver e alterar a hora do relógio e do alarme, activando um pequeno Buzzer sempre que estas são coincidentes (Ver ficheiro abaixo).

#include <TimeLib.h>	//Importar a "TimeLib" library.
#include <Wire.h>	//Importar a "Wire" library.
#include <DS1307RTC.h>	//Importar a "DS1307RTC" library.

#include <EEPROM.h>	//Importar a EEPROM library.

#include <LiquidCrystal.h>	//Importar a LCD library.

//Definir os pinos de comunicação e informação do LCD.
LiquidCrystal lcd(8, 9, 10, 11, 12, 13);

int Botao_mais = 2;	//Variável para selecção do pino de entrada digital.
int Botao_menu = 3;	//Variável para selecção do pino de entrada digital.
int Botao_menos = 4;	//Variável para selecção do pino de entrada digital.

int Buzzer = 6;		//Variável para selecção do pino de saída digital.

int Num_Pag = 0;	//Variável para selecção da página do menu.

int Num_Menu = 1;	//Variável para selecção da opção da página.

int H, M, S;	//Variáveis para alteração da hora do relógio.
int A_H, A_M;	//Variáveis para alteração da hora do alarme.
int A_Act;	//Variável para activação do alarme.

//Variável array de selecção do nome da opção da página do menu.
char Lista_menu[] = {' ', 'h', 'm', 's'};

//Correr a função SETUP apenas uma vez após ser pressionado reset:
void setup() {
	//Iniciar a comunicação com LCD de 16x2:
	lcd.begin(2, 16);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Botao_mais, INPUT);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Botao_menu, INPUT);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Botao_menos, INPUT);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Buzzer, OUTPUT);
	//Função para obter o tempo da RTC.
	setSyncProvider(RTC.get);
	//Verifica se o valor de tempo não está definido.
	if (timeStatus() != timeSet) {
		//Escreve no LCD:
		lcd.print("BAT. do RTC INOP");
		//Atraso para o próximo passo:
		delay(3000);
		//Apaga a informação do LCD.
		lcd.clear();
		//Alteração dos dados de hora e data.
		H = 1;
		M = 1;
		S = 1;
		//Grava no RTC uma nova hora e data.
		setTime(H, M , S , 1 , 10 , 2001 );
		RTC.set(now());
	}
	else {
		//Escreve no LCD:
		lcd.print("RTC OK");
		//Atraso para o próximo passo:
		delay(3000);
		//Apaga a informação do LCD.
		lcd.clear();
	}
}

//Correr a função LOOP repetidamente:
void loop() {
	//Correr a função:
	Pagina_Menu_0();
	
	//Correr a função:
	Pagina_Hora_1();

	//Correr a função:
	Pagina_Alarm_2();

	//Correr a função:
	Relogio();
	
	//Correr a função:
	Alarme();

	//Atraso para o próximo passo:
	delay(500);
}

//>>>Página 0 - Menu:
	void Pagina_Menu_0() {
	//Condição para aparecer a página:
	if (Num_Pag == 0){
		//Apaga a informação do LCD.
		lcd.clear();
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
		lcd.setCursor(1, 0);
		//Escreve no LCD:
		lcd.print("Hora: ");
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
		lcd.setCursor(1, 1);
		//Escreve no LCD:
		lcd.print("Alarme: ");
		//Condição para seleccionar página 1:
		if (Num_Menu == 1) {
			//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
			lcd.setCursor(0, 0);
			//Escreve no LCD:
			lcd.print(">");
		}
		//Condição para seleccionar página 2:
		else if (Num_Menu == 2) {
			//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
			lcd.setCursor(0, 1);
			//Escreve no LCD:
			lcd.print(">");
		}
		//Condição para aparecer activação alarme:
		if (A_Act == 1) {
			//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
			lcd.setCursor(13, 1);
			//Escreve no LCD:
			lcd.print("(A)");
		}

		//Condição para acção dos botões na página:
		if (digitalRead(Botao_mais) == HIGH) {
			//Condição para seleccionar a página:
      			if (Num_Menu == 1) {
        			//Altera o valor de selecção do menu.
				Num_Menu = Num_Menu + 1;
			}
			//Condição para activar alarme:
			if (Num_Menu == 2) {
				if (A_Act == 1) {
					A_Act = 0;
				}
				else {
					A_Act = 1;
				}
				//Grava na EEPROM a activação do alarme.
				EEPROM.write(2, A_Act);
			}
		}

		//Condição para acção dos botões na página:
		if (digitalRead(Botao_menos) == HIGH) {
			//Condição para seleccionar a página:
			if (Num_Menu == 2) {
				//Altera o valor de selecção do menu.
				Num_Menu = Num_Menu - 1;
			}
		}
		//Condição para acção dos botões na página:
		if (digitalRead(Botao_menu) == HIGH) {
			//Condição para seleccionar a página:
			if (Num_Menu == 1) {
				//Altera o valor da página.
				Num_Pag = 1;
				//Alterar o valor de selecção do menu.
				Num_Menu = 0;
				//Apaga a informação do LCD.
				lcd.clear();
			}
			//Condição para seleccionar página:
			else if (Num_Menu == 2) {
				//Altera o valor da página.
				Num_Pag = 2;
				//Altera o valor de selecção do menu.
				Num_Menu = 0;
				//Apaga a informação do LCD.
				lcd.clear();
			}
		}
	}
}

//>>>Página 1 - Acerto do relógio:
void Pagina_Hora_1() {
	//Condição para aparecer a página:
	if (Num_Pag == 1) {
		//Apaga a informação do LCD.
		lcd.clear();
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
		lcd.setCursor(0, 0);
    		//Escreve no LCD:
    		lcd.print("Hora:");

    		//Condição para activar o acerto do relógio:
    		if (digitalRead(Botao_menu) == HIGH) {
      			//Altera o valor de selecção do menu.
      			Num_Menu = Num_Menu + 1;
    		}
    		
		//Condição para seleccionar o nome do dado a alterar no relógio:
    		if (Num_Menu < 4) {
      			//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
      			lcd.setCursor(15, 0);
      			//Escreve no LCD:
      			lcd.print(Lista_menu[Num_Menu]);
    		}
    		//Condição para voltar ao relógio.
    		else if (Num_Menu > 4) {
			//Altera o valor de selecção do menu.
      			Num_Menu = 0;
    		}
		//Condição para sair do acerto do relógio:
		if (Num_Menu == 0) {     
			//Condição para acção dos botões na página:
			if (digitalRead(Botao_menos) == HIGH) {
				//Altera o valor da página.
				Num_Pag = 0;
				//Altera o valor de selecção do menu.
				Num_Menu = 1;
			}
		}
	}
}

//>>>Página 2 - Acerto do alarme.
void Pagina_Alarm_2() {
	//Condição para aparecer a página:
	if (Num_Pag == 2) {
		//Apaga a informação do LCD.
		lcd.clear();
		//Define a coluna (em 16) e a linha (em 2) do LCD onde escrever:
		lcd.setCursor(0, 0);
		//Escreve no LCD:
		lcd.print("ALARME:");

		//Condição para activar o acerto do alarme:
		if (digitalRead(Botao_menu) == HIGH) {
			//Altera o valor de selecção do menu.
			Num_Menu = Num_Menu + 1;
		}

		//Condição para seleccionar o nome do dado a alterar no alarme:
if (Num_Menu < 3) { //Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: lcd.setCursor(15, 0); //Escreve no LCD: lcd.print(Lista_menu[Num_Menu]); } //Condição para voltar ao alarme. else if (Num_Menu > 1) { Num_Menu = 0; } //Condição para sair da alteração do alarme: if (Num_Menu == 0) { //Condição para acção dos botões na página: if (digitalRead(Botao_menos) == HIGH) { //Altera o valor de selecção do menu. Num_Pag = 0; //Altera o valor de selecção do título do menu. Num_Menu = 2; } } } } //>>>Função de escrita dos dados do relógio no LCD: void Relogio() { //Verifica se o valor de tempo está definido. if (timeStatus() == timeSet) { //Condição para aparecer os dados do relógio na página: if (Num_Pag == 0) { //Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: lcd.setCursor(8, 0); //Escreve no LCD: if (hour() < 10) lcd.print('0'); lcd.print(hour()); lcd.print(":"); if (minute() < 10) lcd.print('0'); lcd.print(minute()); lcd.print(":"); if (second() < 10) lcd.print('0'); lcd.print(second()); } //Condição para aparecer os dados do relógio na página: else if (Num_Pag == 1) { //Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: lcd.setCursor(0, 1); //Escreve no LCD: if (hour() < 10) lcd.print('0'); lcd.print(hour()); lcd.print(":"); if (minute() < 10) lcd.print('0'); lcd.print(minute()); lcd.print(":"); if (second() < 10) lcd.print('0'); lcd.print(second()); } } else { //Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: lcd.setCursor(0, 0); //Escreve no LCD: lcd.print("BAT RTC INOP"); //Atraso para o próximo passo: delay(3000); //Alteração dos dados de hora e data. H = 1; M = 1; S = 1; //Grava no RTC uma nova hora e data. setTime(H, M, S, 1, 1, 2001); RTC.set(now()); } //Condição para acerto das "horas": if (Num_Pag == 1 & Num_Menu == 1) { //Condição para incrementar +1 hora: if (digitalRead(Botao_mais) == HIGH) { H = hour() + 1; //Grava no RTC uma nova hora e data. setTime(H, minute(), second(), day(), month(), year()); RTC.set(now()); } //Condição para retirar -1 hora: if (digitalRead(Botao_menos) == HIGH) { H = hour() - 1; //Grava no RTC uma nova hora e data. setTime(H, minute(), second(), day(), month(), year()); RTC.set(now()); } } //Condição para acerto dos "minutos": else if (Num_Pag == 1 & Num_Menu == 2) { //Condição para incrementar +1 minuto: if (digitalRead(Botao_mais) == HIGH) { M = minute() + 1; //Grava no RTC uma nova hora e data. setTime(hour(), M, second(), day(), month(), year()); RTC.set(now()); } //Condição para retirar -1 minuto: if (digitalRead(Botao_menos) == HIGH) { M = minute() - 1; //Grava no RTC uma nova hora e data. setTime(hour(), M, second(), day(), month(), year()); RTC.set(now()); } } //Condição para acerto dos "segundos": else if (Num_Pag == 1 & Num_Menu == 3) { //Condição para incrementar +1 segundo: if (digitalRead(Botao_mais) == HIGH) { S = second() + 1; //Grava no RTC uma nova hora e data. setTime(hour(), minute(), S, day(), month(), year()); RTC.set(now()); } //Condição para retirar -1 segundo: if (digitalRead(Botao_menos) == HIGH) { S = second() - 1; //Grava no RTC uma nova hora e data. setTime(hour(), minute(), S, day(), month(), year()); RTC.set(now()); } } } //>>>Função de escrita dos dados do Alarme no LCD: void Alarme() { //Define os dados de hora do alarme guardados na EEPROM: A_H = EEPROM.read(0); A_M = EEPROM.read(1); A_Act = EEPROM.read(2); //Condição para aparecer os dados do Alarme na página:
if (Num_Pag == 0) { //Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: lcd.setCursor(8, 1); //Escreve no LCD: if(A_H < 10) lcd.print('0'); lcd.print(A_H); lcd.print(":"); if(A_M < 10) lcd.print('0'); lcd.print(A_M); } //Condição para aparecer os dados do Alarme na página: else if (Num_Pag == 2) { //Define a coluna (em 16) e a linha (em 2) do LCD onde escrever: lcd.setCursor(0, 1); //Escreve no LCD: if(A_H < 10) lcd.print('0'); lcd.print(A_H); lcd.print(":"); if(A_M < 10) lcd.print('0'); lcd.print(A_M); } //Condição para a alteração das "horas": if (Num_Pag == 2 & Num_Menu == 1) { //Condição para incrementar +1 hora: if (digitalRead(Botao_mais) == HIGH) { A_H = A_H + 1; //Grava na EEPROM uma nova hora no alarme. EEPROM.write(0, A_H); } //Condição para retirar -1 hora: if (digitalRead(Botao_menos) == HIGH) { A_H = A_H - 1; //Grava na EEPROM uma nova hora no alarme. EEPROM.write(0, A_H); } } //Condição para a alteração dos "minutos": if (Num_Pag == 2 & Num_Menu == 2) { //Condição para incrementar +1 minuto: if (digitalRead(Botao_mais) == HIGH) { A_M = A_M + 1; //Grava na EEPROM um novo minuto no alarme. EEPROM.write(1, A_M); } //Condição para retirar -1 minuto: if (digitalRead(Botao_menos) == HIGH) { A_M = A_M - 1; //Grava na EEPROM um novo minuto no alarme. EEPROM.write(1, A_M); } } //Condição para activação do alarme: if (hour()== A_H & minute()== A_M & A_Act == 1){ //Liga o alarme (HIGH e nível alto): digitalWrite(Buzzer, HIGH); //Atraso para o próximo passo: delay(500); //Desliga o alarme (LOW e nível baixo): digitalWrite(Buzzer, LOW); //Atraso para o próximo passo: delay(500); } }

Caso queiram saber mais ou tenham dúvidas sobre estas e outras referências do código, vejam a sua explicação detalhada no site oficial do Arduino, através deste Link "https://www.arduino.cc/en/Reference/HomePage".
Procurem os nossos tutoriais acerca do Arduino, onde explicamos diversas montagens e o funcionamento dos seus componentes, já agora visitem o nosso canal no Youtube, Facebook ou Twitter.

Abraço e bons projectos.

Share

    Recommendations

    • Science of Cooking

      Science of Cooking
    • Pocket-Sized Contest

      Pocket-Sized Contest
    • Trash to Treasure

      Trash to Treasure
    user

    We have a be nice policy.
    Please be positive and constructive.

    Tips

    Questions

    3 Comments

    Everything is wonderful, but...I don't speak Russian

    My apologies for the fact that my "Instructables" are in Portuguese, I am thinking of translating all my "Instructables" into English, but now it is easier for me, because this is my mother tongue. However, I would also like that in Brazil and in portugal which is where I am now, could know better this site and I think it is the best form at the moment.

    My apologies and I hope you understand.

    Good projects.