//UNIFRAN - Universidade de Franca
//TCC - Alimentador automático com conexão WEB
//Fabrício Henrique de Souza

#include <Wire.h>
#include <LiquidCrystal.h>
#include "Sodaq_DS3231.h"
#include <EEPROM.h>

//============================================
//===================== Mapeamento de Hardware
#define bMenu 22
#define bHora 23
#define bMinuto 30

#define echoPin 7 // Pino 7 recebe o pulso do echo do Sensor 1
#define trigPin 6 // Pino 6 envia o pulso para gerar o echo do Sensor 1

#define bMenu0 90 // Valor de referência que a
#define bHora0 91 // função CheckButton() passa
#define bMinuto0 92 // indicando que um botão foi solto

boolean aMenu, aHora, aMinuto; // Grava o ultimo valor lidos nos botões.
// Utilizado pela função Checkbutton p/ identificar quando há uma alteração no estado do pino dos botões

//int prfdde = 24; // profundidade da caixa (aqui vc coloca a pronfudidade da caixa em CM)
int variavel; // variavel a ser alterada pelo menu
char state = 1; // variável que guarda posição atual do menu
char weekDay[][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
long previousMillis = 0;
long interval = 1000;

int hrNow; //VARIAVEIS do rtc A
int segNow; //SEREM USADAS
int minNow; //NAS COMPARAÇÕES RTC E DADOS

int hr[4]; //
int minuto[4]; //VARIAVEIS A
int por = 1; //SEREM SETADAS
int ref = 1; //PELO USUARIO

int intRetorno;
int intPosHr; //VARIAVEIS USADAS
int intPosMin; //PARA RETONAR
int intPosRef; //POSIÇÃO NA
int intPosPor; //MEMORIA EEPROM

int smotor = 38;
int teste = 31;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Declaração do objeto tipo lcd

//====================================================
//============================================== SETUP
void setup()
{
lcd.begin(16, 2); // Iniciando a biblioteca do LCD
Serial.begin(57600);
Wire.begin();
rtc.begin();

pinMode(echoPin, INPUT); // define o pino 7 como entrada (recebe)
pinMode(trigPin, OUTPUT); // define o pino 6 como saida (envia)

pinMode(bMenu, INPUT); // Botões
pinMode(bHora, INPUT);
pinMode(bMinuto, INPUT);
pinMode(smotor, OUTPUT); // saida para motor
pinMode(teste, INPUT);

digitalWrite(bMenu, HIGH); // Aciona o pull-up interno
digitalWrite(bHora, HIGH); // dos botões
digitalWrite(bMinuto, HIGH);
digitalWrite(teste, HIGH);

}

uint32_t old_ts;

//==============================================
//============================================== LOOP
void loop() {
// vrifica hora
//
// verifica o intervalo da refeicao com base nas horas
// ler os dados armazenados na eeprom
//int retorno;
switch (state) {
case 1:
switch (CheckButton()) {
case bMenu:
lcd.clear(); Set_state(2);
break;
default:
Set_state(1);
}
break;

case 2:
switch (CheckButton()) {
case bMenu:
lcd.clear(); Set_state(3);
break;
case bHora:
lcd.clear();
if (ref == 0 || ref < 5) {
ref++;
//RetornoPosicao(ref);
GravaEprom(0, ref);
}
else
{
ref = 0;
GravaEprom(0, ref);
}

break;
case bMinuto:
lcd.clear();
if (por == 0 || por < 5)
{
por++;
GravaEprom(1, por);
//RetornoPosicao(ref);
}
else
{
por = 0;
GravaEprom(1, por);
}
break;
default:
Set_state(2);
}
break;

case 3:
switch (CheckButton()) {
case bMenu:
lcd.clear(); Set_state(4);
break;
case bHora:
lcd.clear();
if (hr[0] == 0 || hr[0] < 23)
{
hr[0]++;
//RetornoPosicao(ref);
GravaEprom(2, hr[0]);
}
else
{
hr[0] = 0;
GravaEprom(2, hr[0]);
}
break;
case bMinuto:
lcd.clear();
if (minuto[0] == 0 || minuto[0] < 59)
{
minuto[0]++;
//RetornoPosicao(ref);
GravaEprom(3, minuto[0]);
}
else
{
minuto[0] = 0;
GravaEprom(3, minuto[0]);
}
break;
default:
Set_state(3);
}
break;

case 4:
switch (CheckButton()) {
case bMenu:
lcd.clear(); Set_state(5);
break;
case bHora:
lcd.clear();
if (hr[1] == 0 || hr[1] < 23)
{
hr[1]++;
GravaEprom(4, hr[1]);
}
else
{
hr[1] = 0;
GravaEprom(4, hr[1]);
}
break;
case bMinuto:
lcd.clear();
if (minuto[1] == 0 || minuto[1] < 59)
{
minuto[1]++;
GravaEprom(5, minuto[1]);
}
else
{
minuto[1] = 0;
GravaEprom(5, minuto[1]);
}
break;
default:
Set_state(4);
}
break;

case 5:
switch (CheckButton()) {
case bMenu:
lcd.clear(); Set_state(6);
break;
case bHora:
lcd.clear();
if (hr[2] == 0 || hr[2] < 23)
{
hr[2]++;
GravaEprom(6, hr[2]);
}
else
{
hr[2] = 0;
GravaEprom(6, hr[2]);
}
break;
case bMinuto:
lcd.clear();
if (minuto[2] == 0 || minuto[2] < 59)
{
minuto[2]++;
GravaEprom(7, minuto[2]);
}
else
{
minuto[2] = 0;
GravaEprom(7, minuto[2]);
}
break;
default:
Set_state(5);
}
break;

case 6:
switch (CheckButton()) {
case bMenu:
lcd.clear(); Set_state(7);
break;
case bHora:
lcd.clear();
if (hr[3] == 0 || hr[3] < 23)
{
hr[3]++;
GravaEprom(8, hr[3]);
}
else
{
hr[3] = 0;
GravaEprom(8, hr[3]);
}
break;
case bMinuto:
lcd.clear();
if (minuto[3] == 0 || minuto[3] < 59)
{
minuto[3]++;
GravaEprom(9, minuto[3]);
}
else
{
minuto[3] = 0;
GravaEprom(9, minuto[3]);
}
break;
default:
Set_state(6);
}
break;

case 7:
switch (CheckButton()) {
case bMenu:
lcd.clear() ; Set_state(1);
break;
case bHora:
lcd.clear();
if (hr[4] == 0 || hr[4] < 23)
{
hr[4]++;
GravaEprom(10, hr[4]);
}
else
{
hr[4] = 0;
GravaEprom(10, hr[4]);
}
break;
case bMinuto:
lcd.clear();
if (minuto[4] == 0 || minuto[4] < 59)
{
minuto[4]++;
GravaEprom(11, minuto[4]);
}
else
{
minuto[4] = 0;
GravaEprom(11, minuto[4]);
}
break;
default:
Set_state(7);
}
break;
}
//=====================================================
//==========================================Comparações

if (ref == 1 && hr[0] == hrNow && minuto[0] == minNow) {
porcao();
}
if (ref == 2 && hr[0] == hrNow && minuto[0] == minNow || ref == 2 && hr[1] == hrNow && minuto[1] == minNow ) {
porcao();
}
if (ref == 3 && hr[0] == hrNow && minuto[0] == minNow || ref == 3 && hr[1] == hrNow && minuto[1] == minNow || ref == 3 && hr[2] == hrNow && minuto[2] == minNow) {
porcao();
}
if (ref == 4 && hr[0] == hrNow && minuto[0] == minNow || ref == 4 && hr[1] == hrNow && minuto[1] == minNow || ref == 4 && hr[2] == hrNow && minuto[2] == minNow || ref == 4 && hr[3] == hrNow && minuto[3] == minNow) {
porcao();
}
if (ref == 5 && hr[0] == hrNow && minuto[0] == minNow || ref == 5 && hr[1] == hrNow && minuto[1] == minNow || ref == 5 && hr[2] == hrNow && minuto[2] == minNow || ref == 5 && hr[3] == hrNow && minuto[3] == minNow || ref == 5 && hr[4] == hrNow && minuto[4] == minNow) {
porcao();
}
//===============================================
//==========================================Teste
int valor = digitalRead(teste);
if (valor == !HIGH) {
digitalWrite(smotor, LOW);
}
else {
digitalWrite(smotor, HIGH);
}
}
//==============================================
//============================================== Set_state
void Set_state(char index) {
state = index; // Atualiza a variável state para a nova tela
int retorno;
switch (state) { // verifica qual a tela atual e exibe o conteúdo correspondente
case 1:
relogio();
lcd.setCursor(4, 0);
lcd.print(hrNow);
lcd.print(":");
if (minNow > 59 ) {
minNow = 0;
}
lcd.print(minNow);
lcd.print(":");
lcd.print(segNow);
break;
case 2://====================================
relogio();
lcd.setCursor(0, 0);
lcd.print("Refeicoes");
lcd.setCursor(4, 1);
ref = EEPROM.read(0);
if (ref == 255) {
ref = 1;
}
lcd.print(ref);

lcd.setCursor(10, 0);
lcd.print("Porcoes");
lcd.setCursor(13, 1);
por = EEPROM.read(1);
if (por == 255) {
por = 1;
}
lcd.print(por);
break;

case 3://====================================
relogio();
lcd.setCursor(0, 0);
lcd.print("Programacao 1");
lcd.setCursor(0, 1);
lcd.print("H ");
hr[0] = EEPROM.read(2);
lcd.print(hr[0]);
lcd.print(" : ");
lcd.print("M ");
minuto[0] = EEPROM.read(3);
//if(minuto[0] == 255){
//minuto[0]=0;
//}
lcd.print(minuto[0]);
break;

case 4://====================================
relogio();
lcd.setCursor(0, 0);
lcd.print("Programacao 2");
lcd.setCursor(0, 1);
lcd.print("H ");
hr[1] = EEPROM.read(4);
lcd.print(hr[1]);
lcd.print(" : ");
lcd.print("M ");
minuto[1] = EEPROM.read(5);
if (minuto[1] == 255) {
minuto[1] = 0;
}
lcd.print(minuto[1]);
break;

case 5://====================================
relogio();
lcd.setCursor(0, 0);
lcd.print("Programacao 3");
lcd.setCursor(0, 1);
lcd.print("H ");
hr[2] = EEPROM.read(6);
lcd.print(hr[2]);
lcd.print(" : ");
lcd.print("M ");
minuto[2] = EEPROM.read(7);
if (minuto[2] == 255) {
minuto[2] = 0;
}
lcd.print(minuto[2]);
break;

case 6://====================================
relogio();
lcd.setCursor(0, 0);
lcd.print("Programacao 4");
lcd.setCursor(0, 1);
lcd.print("H ");
hr[3] = EEPROM.read(8);
lcd.print(hr[3]);
lcd.print(" : ");
lcd.print("M ");
minuto[3] = EEPROM.read(9);
if (minuto[3] == 255) {
minuto[3] = 0;
}
lcd.print(minuto[3]);
break;

case 7://====================================
relogio();
lcd.setCursor(0, 0);
lcd.print("Programacao 5");
lcd.setCursor(0, 1);
lcd.print("H ");
hr[4] = EEPROM.read(10);
lcd.print(hr[4]);
lcd.print(" : ");
lcd.print("M ");
minuto[4] = EEPROM.read(11);
if (minuto[4] == 255) {
minuto[4] = 0;
}
lcd.print(minuto[4]);
break;
}
}
//===========================================
//=======================RTC(Real Time Clock)
void relogio() {
unsigned long currentMillis = millis();

if (currentMillis - previousMillis > interval) {
previousMillis = currentMillis;

DateTime now = rtc.now(); //get the current date-time
uint32_t ts = now.getEpoch();

hrNow = now.hour();
minNow = now.minute();
segNow = now.second();

if (old_ts == 0 || old_ts != ts) {
old_ts = ts;
Serial.print(now.year(), DEC);
Serial.print('/');
Serial.print(now.month(), DEC);
Serial.print('/');
Serial.print(now.date(), DEC);
Serial.print(' ');
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.print(now.minute(), DEC);
Serial.print(':');
Serial.print(now.second(), DEC);
Serial.print(' ');
Serial.print(weekDay[now.dayOfWeek()]);
Serial.println();
Serial.print("Seconds since Unix Epoch: ");
Serial.print(ts, DEC);
Serial.println();

}

}
}

//==========================================================
//============================================== CheckButton
char CheckButton() {
if (aMenu != digitalRead(bMenu)) {
aMenu = !aMenu;
if (aMenu) return bMenu0; else return bMenu;
} else if (aHora != digitalRead(bHora)) {
aHora = !aHora;
if (aHora) return bHora0; else return bHora;
} else if (aMinuto != digitalRead(bMinuto)) {
aMinuto = !aMinuto;
if (aMinuto) return bMinuto0; else return bMinuto;
} else
return 0;
}

//================================================================
//============================================= Definição das Porções por tempo
void porcao() {
if (por == 1 && segNow < 1) {
digitalWrite(smotor, LOW);
}
if (por == 2 && segNow <= 1) {
digitalWrite(smotor, LOW);
}
if (por == 3 && segNow < 2) {
digitalWrite(smotor, LOW);
}
if (por == 4 && segNow < 3) {
digitalWrite(smotor, LOW);
}
if (por == 5 && segNow < 4) {
digitalWrite(smotor, LOW);
}
}

//================================================================
//============================================= FUNÇÃO Gravação na EEPROM
void GravaEprom(int intPosicao, int intValor) {
EEPROM.write(intPosicao, intValor);
}

int LeEprom(int intPosicao) {
return EEPROM.read(intPosicao);
}

esse é meu codigo preciso acionar o motor, quando o os valores hrNow e minNow forem consecutivamente iguais a hr[]e minuto[].