CGM

#include <TimerOne.h>             // Biblioteca do timer1
//   #include <LiquidCrystal_I2C.h>
//   LiquidCrystal_I2C lcd(0x38,  2, 1, 0, 7, 6, 5, 4, 3, POSITIVE);  // Set the LCD I2C address
#include <LiquidCrystal.h>
#include <Limits.h>

const int temperatura  = 0;
int pinoativaluz = 2; //Pino ligado ao acionamento da lampada
int pinopir = 3; //Pino ligado ao sensor
int acionamento; //Variavel para guardar valor do sensor
int ConRegre = 30; //variavel com o valor definido de 30 segundos
int ConRegreReg = ConRegre; //receble valor de referencia
int percentc1 = 100;
int percentc2 = 100;
int percentc3 = 100;
int percentc4 = 100;
int val1 = 100;
int val2 = 25;
int val3 = 25;
int val4 = 25;
int motorPin = A3;

#define bMenu 5 // Os pinos analógicos podem ser
#define bChange 4 // usados como digitais, bastando
#define bUp 13 // referenciá-los por A0, A1..
#define bDown 6
#define bMenu0 90 // Valor de referência que a
#define bChange0 91 // função CheckButton() passa
#define bUp0 92 // indicando que um botão foi
#define bDown0 93 // solto
boolean aMenu, aChange, aUp, aDown; // Grava o ultimo valor lidos nos botões.
const int sensorTemp = 0;
int valorSensorTemp = 0;
int menorValorTemp  = INT_MAX;

// Utilizado pela função Checkbutton p/ identificar quando há uma alteração no estado do pino dos botões

char state = 1; // variável que guarda posição atual do menu

LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // Declaração do objeto tipo lcd

byte seta_direita[8] = {
  B00000,
  B00100,
  B00010,
  B11111,
  B00010,
  B00100,
  B00000,
  B00000
};

byte seta_esquerda[8] = {
  B00000,
  B00100,
  B01000,
  B11111,
  B01000,
  B00100,
  B00000,
  B00000
};
byte seta_abaixo[8] = {
  B00000,
  B00100,
  B00100,
  B10101,
  B01110,
  B00100,
  B00000,
  B00000
};
byte seta_acima[8] = {
  B00000,
  B00100,
  B01110,
  B10101,
  B00100,
  B00100,
  B00000,
  B00000
};

//----------------------------------
void callback()       // Cada vez que "estoura" o timer 1 chama esta rotina
{
  ConRegre--;
  if (ConRegre <= 0) ConRegre = 0;    // Se chegar em zero, fica em zero
}
//----------------------------------
void setup()
{
  Timer1.initialize(1000000);         // initialize timer1, and set a 1 second period
  Timer1.attachInterrupt(callback);   // attaches callback() as a timer overflow interrupt
  lcd.createChar(1, seta_direita);   // vai criar novos caracteres
  lcd.createChar(2, seta_esquerda);
  lcd.createChar(3, seta_abaixo);
  lcd.createChar(4, seta_acima);
  lcd.begin(16, 2); // Iniciando a biblioteca do LCD
  lcd.print("INICIANDO... ");
  delay(5000);
  pinMode(bMenu, INPUT); // Botões
  pinMode(bChange, INPUT);
  pinMode(bUp, INPUT);
  pinMode(bDown, INPUT);
  pinMode(A5, OUTPUT);
  digitalWrite(bMenu, HIGH); // Aciona o pull-up interno
  digitalWrite(bChange, HIGH); // dos botões
  digitalWrite(bUp, HIGH);
  digitalWrite(bDown, HIGH);
  pinMode(pinoativaluz, OUTPUT); //Define pino como saida
  pinMode(pinopir, INPUT); //Define pino sensor como entrada
  digitalWrite(A5, HIGH); //Comuta para o controle digital digital
  digitalWrite(pinoativaluz, HIGH);
  pinMode(motorPin, OUTPUT);
  analogWrite(motorPin, 24);

}
//----------------------------------
void loop()
{
  acionamento = digitalRead(pinopir); //Le o valor do sensor
  if (acionamento != 0)
  {
    digitalWrite(pinoativaluz, HIGH); //aciona a luz se estiver desligada
    ConRegre = ConRegreReg; // reseta o contador para o valor definido pela variável ConRegreReg
  }
  if (ConRegre <= 0)
  {
    digitalWrite(pinoativaluz, LOW); // desliga a luz ao final da contagem
  }

  //  CalcTemp;
  ////////////////////////////////////////////////////cod. sensor
  switch (state) {
    case 1: //MENU 1 - CONTROLE (LIGADO/DESLIGADO)
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          digitalWrite(A5, LOW);
          lcd.setCursor(0, 1);
          lcd.print("DESLIGADO    ");
          break;
        case bDown:
          lcd.clear();
          Set_state(2);
          break;
        case bChange:
          lcd.clear();
          digitalWrite(A5, HIGH);
          lcd.setCursor(0, 1);
          lcd.print("LIGADO       ");
          break;
        default:
          Set_state(1);
          if (digitalRead(A5) == 1)
          {
            lcd.setCursor(0, 1);
            lcd.print("LIGADO       ");
          }
      }
      break;
    case 2: //ILUMINACAO
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          Set_state(3);
          break;
        case bDown:
          lcd.clear();
          Set_state(5);
          break;
        case bUp:
          lcd.clear();
          Set_state(1);
          break;
        default:
          Set_state(2);
      }
      break;
    case 3: //ILUMINACAO - CONFIGURA TEMPO
      switch (CheckButton())
      {
        case bMenu:
          lcd.clear();
          Set_state(4);
          break;
        case bChange:
          lcd.clear();
          Set_state(2);
          break;
        case bDown:
          if (ConRegreReg >= 0) {
            ConRegreReg = ConRegreReg - 30;
            ConRegre = ConRegreReg;
            break;
          case bUp:
            ConRegreReg = ConRegreReg + 30;
            ConRegre = ConRegreReg;
            break;
          default:
            Set_state(3);
          }
      }
      break;
    case 4: //ILUMINACAO - MONITORACAO
      switch (CheckButton())
      {
        case bMenu:
          lcd.clear();
          Set_state(2);
          break;
        case bChange:
          lcd.clear();
          Set_state(3);
          break;
        default:
          Set_state(4);
      }
      break;
    case 5: //CARGA
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          Set_state(6);
          break;
        case bDown:
          lcd.clear();
          Set_state(1);
          break;
        case bUp:
          lcd.clear();
          Set_state(2);
          break;
        default:
          Set_state(5);
      }
      break;
    case 6: //CARGA - 1
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          Set_state(7);
          break;
        case bChange:
          lcd.clear();
          Set_state(5);
          break;
        case bUp:
          if (val1 <= 100) {
            lcd.clear(); val1++;
            delay(100);
            analogWrite(motorPin, val1);
          }

          break;
        case bDown:
          if (val1 > 0) {
            lcd.clear(); val1--;
            delay(100);
            analogWrite(motorPin, val1);
          }
          break;
        default:
          Set_state(6);
      }
      break;
    case 7: //CARGA - 2
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          Set_state(8);
          break;
        case bChange:
          lcd.clear();
          Set_state(6);
          break;
        case bDown:
          if (val2 <= 24) {
            lcd.clear(); val2++;
            delay(100);
          }
          break;
        case bUp:
          if (val2 <= 24) {
            lcd.clear(); val2++;
            delay(100);
          }
          break;
        default:
          Set_state(7);
      }
      break;
    case 8: //CARGA - 3
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          Set_state(9);
          break;
        case bChange:
          lcd.clear();
          Set_state(7);
          break;
        case bDown:
          if (val3 <= 24) {
            lcd.clear(); val3++;
            delay(100);
          }
          break;
        case bUp:
          if (val3 <= 24) {
            lcd.clear(); val3++;
            delay(100);
          }
          break;
        default:
          Set_state(8);
      }
      break;
    case 9: //CARGA - 4
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          Set_state(10);
          break;
        case bChange:
          lcd.clear();
          Set_state(8);
          break;
        case bDown:
          if (val4 <= 24) {
            lcd.clear(); val4++;
            delay(100);
          }
          break;
        case bUp:
          if (val4 <= 24) {
            lcd.clear(); val4++;
            delay(100);
          }
          break;
        default:
          Set_state(9);
      }
      break;
    case 10: //ILUMINACAO
      switch (CheckButton()) {
        case bMenu:
          lcd.clear();
          Set_state(5);
          break;
        case bDown:
          lcd.clear();
          Set_state(1);
          break;
        case bUp:
          lcd.clear();
          Set_state(2);
          break;
        default:
          Set_state(10);
      }
      break;
    default: ;
  }
}
//----------------------------------
char CheckButton()
{
  if (aMenu != digitalRead(bMenu))
  {
    aMenu = !aMenu;
    if (aMenu) return bMenu0;
    else return bMenu;
  }
  else if (aChange != digitalRead(bChange))
  {
    aChange = !aChange;
    if (aChange) return bChange0;
    else return bChange;
  }
  else if (aUp != digitalRead(bUp))
  {
    aUp = !aUp;
    if (aUp) return bUp0;
    else return bUp;
  }
  else if (aDown != digitalRead(bDown))
  {
    aDown = !aDown;
    if (aDown) return bDown0;
    else return bDown;
  }
  else
    return 0;
}
//---------------------------------
void Set_state(char index)
{
  state = index; // Atualiza a variável state para a nova tela
  switch (state)  // verifica qual a tela atual e exibe o conteúdo correspondente
  {
    case 1: //==================== state 1
      lcd.setCursor(0, 0);
      lcd.print("CONTROLE     ");
      lcd.write(3);
      lcd.write(2);
      lcd.write(1);
      break;
    case 2: //==================== state 2
      lcd.setCursor(0, 0);
      lcd.print("ILUMINACAO   ");
      lcd.setCursor(13, 0);
      lcd.write(4);
      lcd.write(3);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print("T. CONF:");
      lcd.print(ConRegreReg);
      lcd.print("s");
      break;
    case 3: //==================== state 3
      lcd.setCursor(0, 0);
      lcd.print("CONF. TEMPO ");
      lcd.setCursor(12, 0);
      lcd.write(4);
      lcd.write(3);
      lcd.write(2);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print("TEMPO: ");
      lcd.print(ConRegreReg);
      lcd.print("s      ");
      break;
    case 4: //==================== state 4
      lcd.setCursor(0, 0);
      lcd.print("MONIT. TEMPO    ");
      lcd.setCursor(14, 0);
      lcd.write(2);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print("TEMPO: ");
      lcd.print(ConRegre);
      lcd.print("s");
      break;
    case 5: //==================== state 5
      lcd.setCursor(0, 0);
      lcd.print("CARGAS");
      lcd.setCursor(13, 0);
      lcd.write(4);
      lcd.write(3);
      //      lcd.write(2);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print("CONFIGURACAO");
      break;
    case 6: //==================== state 6
      percentc1 = val1 * 100 / 100;
      lcd.setCursor(0, 0);
      lcd.print("CARGA 1");
      lcd.setCursor(12, 0);
      lcd.write(4);
      lcd.write(3);
      lcd.write(2);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print(percentc1, DEC);  // mostra o valor de "variavel"
      lcd.print(" %   ");

      break;
    case 7: //==================== state 7
      percentc2 = val2 * 100 / 25;
      lcd.setCursor(0, 0);
      lcd.print("CARGA 2");
      lcd.setCursor(12, 0);
      lcd.write(4);
      lcd.write(3);
      lcd.write(2);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print(percentc2, DEC);  // mostra o valor de "variavel"
      lcd.print(" %   ");
      break;
    case 8: //==================== state 8
      percentc3 = val3 * 100 / 25;
      lcd.setCursor(0, 0);
      lcd.print("CARGA 3");
      lcd.setCursor(12, 0);
      lcd.write(4);
      lcd.write(3);
      lcd.write(2);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print(percentc3, DEC);  // mostra o valor de "variavel"
      lcd.print(" %   ");
      break;
    case 9: //==================== state 9
      percentc4 = val4 * 100 / 25;
      lcd.setCursor(0, 0);
      lcd.print("CARGA 4");
      lcd.setCursor(12, 0);
      lcd.write(4);
      lcd.write(3);
      lcd.write(2);
      lcd.write(1);
      lcd.setCursor(0, 1);
      lcd.print(percentc4, DEC);  // mostra o valor de "variavel"
      lcd.print(" %   ");
      break;
    case 10: //==================== state 10

      lcd.clear();  //limpa o display do LCD.
      lcd.setCursor(0, 0);
      lcd.print("TEMPERATURA     ");
      lcd.setCursor(0, 1);
      //lcd.print(atualizaTemperatura);             //-------------------- Comentei
      atualizaTemperatura();                        //-------------------- Chama rotina de temperatura
      lcd.print(menorValorTemp);                    // Imprime menor valor
      lcd.write(B11011111); //Simbolo de graus celsius
      lcd.print("C");
      lcd.setCursor(13, 1);
      lcd.print("< >");
      delay(300);
      break;
    default:;
  }
}

void atualizaTemperatura() {
      menorValorTemp  = INT_MAX; //Inicializando com o maior valor int possível
      for (int i = 1; i <= 8; i++) {
        valorSensorTemp = analogRead(sensorTemp);   //Lendo o valor do sensor de temperatura.
        valorSensorTemp *= 0.54 ;  //Transformando valor lido no sensor de temperatura em graus celsius aproximados.
        if (valorSensorTemp < menorValorTemp) {  //Mantendo sempre a menor temperatura lida
          menorValorTemp = valorSensorTemp;
        }
 //       lcd.print(menorValorTemp);                          // Imprime menor valor
        delay(10);
      }
}