Dos buzzer pasivos simultaneos

International Español Software
1

Buenos días. Desde hace un tiempo estoy con un proyecto, y me encuentro con la dificultad de hacer sonar dos buzzer al mismo tiempo.
En una pagina de Luis Llamas encontré esto:

  • La función Tone emplea el Timer 2, por lo que mientras este funcionando no podremos usar las en los pines 3 y 11 en Arduino Nano y Uno (pines 9 y 10 en Arduino Mega).
  • No podemos usar la función tone() en dos pines de forma simultánea. Deberemos apagar el tono con la funcion noTone() antes de poder usarlo en otro pin.
  • Los rangos de la función tone son de 31 Hz a 65535 Hz.

Esto es así o hay alguna amanera que lo pueda resolver??

2

Si. Crea o busca otra funcion Tone que use otro Timer distinto de Timer2

1 Like
3

Puedes usar esta librería

Seguramente hay otras.

Saludos

1 Like
4

Buenas tardes, les consulto nuevamente, sin saber si esta consulta requiere un nuevo tema, una nueva pregunta, o la puedo hacer aquí (ya que en parte se trata del buzzer.) cualquier cosa me avisan
La situación que no se resolver es la siguiente:
En el apartado Macerado Parte 1 B lo que necesito hacer es que Cuando presiono tecla B llame al timeOut he inicie el cronómetro. El punto está que cuando suena el buzzer del time Out y quiero cancelarlo puedo hacerlo pero no me anda el cronómetro y cuando me anda el cronómetro no puedo cancelar el buzzer. La explicación lógica la entiendo y esta en teclaB_Macerado = false; pero no me puedo dar cuenta como armar para que funcione.
Me podrán orientar como resolverlo. Por lo pronto gracias

#include <LiquidCrystal.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Keypad.h>
#include <TimeOut.h>

#define Buzzer_1 30
#define Buzzer_2 31

#define ONE_WIRE_BUS 9

#define Rele_Resistencia_de_Macerado 51
#define Rele_Bomba_1_Recirculado_Macerado 52
#define Rele_heladera_Frio 50
#define Rele_heladera_Calor 53

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

const int led1_Agua_Macerado_y_Lavado = 40;
const int led3_Calentado_Recirculado = 41;
const int led2_Hervido = 42;
const int led4_Adiciones_Tardias = 43;
const int led5_Macerado_ON = 44;
const int led6_Macerado_OFF = 45;
const int led7_Heladera_Frio = 46;
const int led8_Heladera_Calor = 47;
const int led9_Mash_Out = 48;

boolean teclaA_Cronometro = false; // EN CRONÓMETRO
boolean teclaB_Macerado = false; // EN MACERADO
boolean teclaC_MashOut = false; // EN MASH OUT
boolean INICIO_MACERADO = true;// EN Macerado
boolean INICIO_HERVIDO = true;// EN Hervido
boolean INICIO = true;
boolean InicioCronometro = true;
boolean MaceradoCronometro = true;



TimeOut Temp_Macerado_Parte_1;
TimeOut Temp_Macerado_Parte_2;
TimeOut Temp_Hervido_Parte_1;
TimeOut Temp_Hervido_Parte_2;

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {22, 24, 26, 28};
byte colPins[COLS] = {23, 25, 27, 29};

Keypad teclado = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int secuencia;
int entrada;

float Sensor_Agua;         //sensors.getTempCByIndex(0);
float Sensor_Mosto;        //sensors.getTempCByIndex(1);
float Sensor_Hervido;      //sensors.getTempCByIndex(2);
float Sensor_Fermentacion; //sensors.getTempCByIndex(3);

/// CRONOMETRO/CONTADOR///
unsigned long tiempoactual = 0;
int segundos = 0;
int minutos = 0;
int hora = 0;

/// FERMENTACION///
int  Dia = 0;
float Temperatura_xdia[] = {24, 24, 24, 25, 26, 20, 21, 21, 18, 13, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
float MenosMargenTemp = 0.4;
float MasMargenTemp = 0.4;
Interval intervaloFermentacion;


void setup() {

  lcd.begin( 20, 4);
  lcd.setCursor(7, 0);
  lcd.print("-ANVER-");
  lcd.setCursor(1, 2);
  lcd.print("British Golden Ale");
  delay (2000);
  lcd.clear();

  pinMode(led1_Agua_Macerado_y_Lavado , OUTPUT);
  pinMode(led2_Hervido , OUTPUT);
  pinMode(led3_Calentado_Recirculado , OUTPUT);
  pinMode(led4_Adiciones_Tardias , OUTPUT);
  pinMode(led5_Macerado_ON , OUTPUT);
  pinMode(led6_Macerado_OFF , OUTPUT);
  pinMode(led7_Heladera_Frio , OUTPUT);
  pinMode(led8_Heladera_Calor , OUTPUT);
  pinMode(led9_Mash_Out, OUTPUT);

  pinMode(Buzzer_1, OUTPUT);
  pinMode(Buzzer_2, OUTPUT);

  pinMode(Rele_Resistencia_de_Macerado, OUTPUT);
  pinMode(Rele_Bomba_1_Recirculado_Macerado, OUTPUT);
  pinMode(Rele_heladera_Frio, OUTPUT);
  pinMode(Rele_heladera_Calor, OUTPUT);

  digitalWrite(Rele_Resistencia_de_Macerado, 1);
  digitalWrite(Rele_Bomba_1_Recirculado_Macerado, 1);
  digitalWrite(Rele_heladera_Frio, 1);
  digitalWrite(Rele_heladera_Calor, 1);



  sensors.begin();

  secuencia = 1;
  entrada = 1;
}

void loop() {

  TimeOut::handler();

  char tecla = teclado.getKey ();

  if (tecla == 'A') { // Inicio Cronómetro
    teclaA_Cronometro = true;
  }
  if (tecla == 'B') { // Inicio Macerado
    teclaB_Macerado = true;

  }
  if (tecla == 'C') { // Inico Mash Out
    teclaC_MashOut = true;
  }
  if (tecla == 'D') { // para agua de lavado buzzer 2
    INICIO = false;
    noTone (Buzzer_2);
    digitalWrite (led1_Agua_Macerado_y_Lavado, LOW);
    lcd.setCursor(2, 1);
    lcd.print("             ");
  }
  /////////////////////////////////////////////////////
  /// **************** BLOQUE 1 AGUA MACERADO*****************///
  /////////////////////////////////////////////////////

  if ( secuencia == 1 ) {
    if ( entrada == 1 ) {
      entrada = 2;
      lcd.setCursor(0, 0);
      lcd.print("1 -AGUA  MACERADO- 2");

      tiempoactual = 0;
      segundos = 0;
      minutos = 0;
      hora = 0;
    }

    sensors.requestTemperatures();
    Sensor_Agua = sensors.getTempCByIndex(0);
    lcd.setCursor(16, 2);
    lcd.print(Sensor_Agua, 1);

    if ( Sensor_Agua <= 23) {
      lcd.setCursor( 9, 2);
      lcd.print("CAL");
      digitalWrite (led1_Agua_Macerado_y_Lavado, LOW);
      noTone (Buzzer_2);
    }
    else {
      digitalWrite (led1_Agua_Macerado_y_Lavado, HIGH);
      lcd.setCursor(9, 2);
      lcd.print("OK ");
      tone (Buzzer_2, 500);
    }

    if (InicioCronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
      tiempoactual = millis();
      segundos++;
      if (segundos == 60) {
        segundos = 0;
        minutos ++;
      }
      if (minutos == 60) {
        minutos = 0;
        hora ++;
      }
      if (hora == 24) {
        hora = 0;
      }
      lcd.setCursor(0, 2);
      if (hora < 10)
      {
        lcd.print(" ");
      }
      lcd.print(hora);
      lcd.print(":");
      lcd.setCursor(3, 2);
      if (minutos < 10)
      {
        lcd.print("0");
      }
      lcd.print(minutos);
      lcd.print(":");

      lcd.setCursor(6, 2);
      lcd.print (segundos);
      if (segundos < 10)
      {
        lcd.print("  ");
      }
    }

    //////////////////////////////////////////////////////////
    // **************** BLOQUE 2 MACERADO PARTE 1 *****************/////
    /////////////////////////////////////////////////////////

    if ( tecla == '2') {
      secuencia = 2;
      entrada = 1;
      InicioCronometro = false; //tiene que estar acá
    }
  }
  else if ( secuencia == 2 ) { //
    if ( entrada == 1 ) {
      entrada = 2;
      digitalWrite (led1_Agua_Macerado_y_Lavado, LOW);
      noTone(Buzzer_2);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("2 -AGUA DE LAVADO- 3");
      lcd.setCursor(0, 2);
      lcd.print("-MACERADO-");

      tiempoactual = 0;
      segundos = 0;
      minutos = 0;
      hora = 0;
    }
    sensors.requestTemperatures();

    /////////Parte 1  A  -- AGUA DE LAVADO///////
    Sensor_Agua = sensors.getTempCByIndex(0);
    lcd.setCursor(16, 1);
    lcd.print(Sensor_Agua, 1);

    if (INICIO == true) {
      if (Sensor_Agua <= 25) {
        lcd.setCursor( 9, 1);
        lcd.print("CAL");
        noTone (Buzzer_2);
      }
      else {
        digitalWrite (led1_Agua_Macerado_y_Lavado, HIGH);
        lcd.setCursor(2, 1);
        lcd.print("OK Cancel D");
        tone (Buzzer_2, 150); // Apagamos con Tecla D = INICIO = false
        //INICIO = false;
      }
    }

    //////////PARTE 1 B -- MACERADO - ADICIONES TARDIAS 45´///////
    Sensor_Mosto = sensors.getTempCByIndex(1);
    lcd.setCursor(16, 3);
    lcd.print(Sensor_Mosto, 1);

    if (teclaB_Macerado == true) {
      lcd.setCursor(9, 3);
      lcd.print("ON ");
      digitalWrite (led5_Macerado_ON, HIGH);
      Temp_Macerado_Parte_1.timeOut(5000, n2_Adiciones_Tardias_Macerado);// son 45 min
      if (Sensor_Mosto <= 20) {
        digitalWrite (led3_Calentado_Recirculado, HIGH);
        digitalWrite(Rele_Resistencia_de_Macerado, LOW);
        digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
      } else if (Sensor_Mosto >= 26) {
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
      }
      //teclaB_Macerado = false;
      if  (MaceradoCronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
        tiempoactual = millis();
        segundos++;
        if (segundos == 60) {
          segundos = 0;
          minutos ++;
        }
        if (minutos == 60) {
          minutos = 0;
          hora ++;
        }
        lcd.setCursor(15, 2);
        if (minutos < 10)
        {
          lcd.print("0");
        }
        lcd.print(minutos);
        lcd.print(":");

        lcd.setCursor(18, 2);
        lcd.print (segundos);
        if (segundos < 10)
        {
          lcd.print("  ");
        }
      }
      teclaB_Macerado = false;
    }
    
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 3 MACERADO PARTE 2  *****************/////
    /////////////////////////////////////////////////////////
    if ( tecla == '3') {
      secuencia = 3;
      entrada = 1;
      MaceradoCronometro = false; //tiene que estar acá
      //teclaB_Macerado = false;

    }
  }

  else if ( secuencia == 3 ) { //
    if ( entrada == 1 ) {
      entrada = 2;

      //Temp_Macerado_Parte_1.cancel();
      noTone(Buzzer_1);
      digitalWrite(led4_Adiciones_Tardias, LOW);
      digitalWrite(led3_Calentado_Recirculado, LOW);
      digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
      digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
      lcd.clear ();
      lcd.setCursor(0, 0);
      lcd.print("3 -AGUA DE LAVADO- 4");
      lcd.setCursor(0, 2);
      lcd.print("-MACERADO-");
      //Temp_Macerado_Parte_2.timeOut(4000, n1_Macerado);
    }
5

Moderador:
A pesar de que preguntas cosas diversas todas tienen un hilo comun y es la fabricación de cerveza por lo que sería bueno que crees un hilo si quieres en Proyectos y luego te tomes el trabajo de buscar cada hilo que has consultado cronológicamente y continuar ahi para que todos tengamos una idea mas clara de por donde vas.
De ese modo tmb evitas posteos cruzados.

Por el momento sigue acá.

Ahora yendo a tu consulta del post#4 no hace mas que refrendar lo que te digo, porque cuando hay mejor contexto es cuando se puede responder o entender de lo que hablas.
Tienes cronómetros dentro de condicionales.
Para que implementas varios cronometros si solo debes usar millis() y tomar su valor en cada caso?
Una simple funcion que te devuelva hh:mm:ss por lo que veo o que lo muestre en el lcd es suficiente. Tienes repeticion de código que se puede simplificar bastante.

Luego una cosa es medir, otra son las acciones de teclado y por ultimo el control
Yo veo todo junto y resulta dificil entonces entender que esta ocurriendo.
Si separas las cosas se hace mas simple debuggear (encontrar errores).

Si fuera por mi reenfocaría tu código para hacerlo mas facil de seguir, lo que no quiere decir que asi no funcione, digo que esta muy mezclado y se presta a los fallos que mencionas.
Bueno, me puse a hacerlo y me encentro que las funciones/rutinas de timeout no estan presentes.

Primer versión

#include <LiquidCrystal.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Keypad.h>
#include <TimeOut.h>

#define Buzzer_1 30
#define Buzzer_2 31

#define ONE_WIRE_BUS 9

#define Rele_Resistencia_de_Macerado 51
#define Rele_Bomba_1_Recirculado_Macerado 52
#define Rele_heladera_Frio 50
#define Rele_heladera_Calor 53

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

const int led1_Agua_Macerado_y_Lavado = 40;
const int led3_Calentado_Recirculado  = 41;
const int led2_Hervido                = 42;
const int led4_Adiciones_Tardias = 43;
const int led5_Macerado_ON = 44;
const int led6_Macerado_OFF = 45;
const int led7_Heladera_Frio = 46;
const int led8_Heladera_Calor = 47;
const int led9_Mash_Out = 48;

boolean teclaA_Cronometro = false; // EN CRONÓMETRO
boolean teclaB_Macerado = false; // EN MACERADO
boolean teclaC_MashOut = false; // EN MASH OUT
boolean INICIO_MACERADO = true;// EN Macerado
boolean INICIO_HERVIDO = true;// EN Hervido
boolean INICIO = true;
boolean InicioCronometro = true;
boolean MaceradoCronometro = true;



TimeOut Temp_Macerado_Parte_1;
TimeOut Temp_Macerado_Parte_2;
TimeOut Temp_Hervido_Parte_1;
TimeOut Temp_Hervido_Parte_2;

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {22, 24, 26, 28};
byte colPins[COLS] = {23, 25, 27, 29};

Keypad teclado = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int secuencia;
int entrada;

float Sensor_Agua;         //sensors.getTempCByIndex(0);
float Sensor_Mosto;        //sensors.getTempCByIndex(1);
float Sensor_Hervido;      //sensors.getTempCByIndex(2);
float Sensor_Fermentacion; //sensors.getTempCByIndex(3);

/// CRONOMETRO/CONTADOR///
unsigned long tiempoactual = 0;
int segundos = 0;
int minutos = 0;
int hora = 0;

/// FERMENTACION///
int  Dia = 0;
float Temperatura_xdia[] = {24, 24, 24, 25, 26, 20, 21, 21, 18, 13, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
float MenosMargenTemp = 0.4;
float MasMargenTemp = 0.4;
Interval intervaloFermentacion;

void n2_Adiciones_Tardias_Macerado() {
    Serial.println("n2_Adiciones_Tardias_Macerado");
}

void muestroTiempo() {
  char buffer[20];
  
  segundos++;
  if (segundos == 60) {
      segundos = 0;
      minutos ++;
  }
  if (minutos == 60) {
      minutos = 0;
      hora ++;
  }
  if (hora == 24) {
      hora = 0;
  }
  lcd.setCursor(0, 2);
  sprintf(buffer,"%02d:%02d:%02d", horas, minutos, segundos);
  lcd.print(buffer);
}
void midoTemperaturas(){
  sensors.requestTemperatures();
  Sensor_Agua = sensors.getTempCByIndex(0);
}

void setup() {

  lcd.begin( 20, 4);
  lcd.setCursor(7, 0);
  lcd.print("-ANVER-");
  lcd.setCursor(1, 2);
  lcd.print("British Golden Ale");
  delay (2000);
  lcd.clear();

  pinMode(led1_Agua_Macerado_y_Lavado , OUTPUT);
  pinMode(led2_Hervido , OUTPUT);
  pinMode(led3_Calentado_Recirculado , OUTPUT);
  pinMode(led4_Adiciones_Tardias , OUTPUT);
  pinMode(led5_Macerado_ON , OUTPUT);
  pinMode(led6_Macerado_OFF , OUTPUT);
  pinMode(led7_Heladera_Frio , OUTPUT);
  pinMode(led8_Heladera_Calor , OUTPUT);
  pinMode(led9_Mash_Out, OUTPUT);

  pinMode(Buzzer_1, OUTPUT);
  pinMode(Buzzer_2, OUTPUT);

  pinMode(Rele_Resistencia_de_Macerado, OUTPUT);
  pinMode(Rele_Bomba_1_Recirculado_Macerado, OUTPUT);
  pinMode(Rele_heladera_Frio, OUTPUT);
  pinMode(Rele_heladera_Calor, OUTPUT);

  digitalWrite(Rele_Resistencia_de_Macerado, 1);
  digitalWrite(Rele_Bomba_1_Recirculado_Macerado, 1);
  digitalWrite(Rele_heladera_Frio, 1);
  digitalWrite(Rele_heladera_Calor, 1);
  sensors.begin();

  secuencia = 1;
  entrada = 1;
}

void loop() {

  TimeOut::handler();

  midoTemperaturas();
  
  char tecla = teclado.getKey ();
  switch (tecla) {
    case 'A': // Inicio Cronómetro
              teclaA_Cronometro = true;
              break;
    case 'B': // Inicio Macerado
              teclaB_Macerado = true;
              break;
    case 'C': // Inico Mash Out
              teclaC_MashOut = true;            
              break;
    case 'D': // para agua de lavado buzzer 2
              INICIO = false;
              noTone (Buzzer_2);
              digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
              lcd.setCursor(2, 1);
              lcd.print("             ");              
              break;
    case '2': secuencia = 2;
              entrada = 1;
              InicioCronometro = false; //tiene que estar acá
              break;
    case '3': secuencia = 3;
              entrada = 1;
              MaceradoCronometro = false; //tiene que estar acá
              //teclaB_Macerado = false;
              break;

  }
  
  /////////////////////////////////////////////////////
  /// **************** BLOQUE 1 AGUA MACERADO*****************///
  /////////////////////////////////////////////////////
  switch (secuencia) {
      case 1: if ( entrada == 1 ) {
                  entrada = 2;
                  lcd.setCursor(0, 0);
                  lcd.print("1 -AGUA  MACERADO- 2");
                  tiempoactual = 0;
                  segundos  = 0;
                  minutos   = 0;
                  hora      = 0;
              }
              lcd.setCursor(16, 2);
              lcd.print(Sensor_Agua, 1);
          
              if ( Sensor_Agua <= 23) {
                lcd.setCursor( 9, 2);
                lcd.print("CAL");
                digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
                noTone (Buzzer_2);
              }
              else {
                digitalWrite(led1_Agua_Macerado_y_Lavado, HIGH);
                lcd.setCursor(9, 2);
                lcd.print("OK ");
                tone (Buzzer_2, 500);
              }
          
              if (InicioCronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
                tiempoactual = millis();
                muestroTiempo();
              }
              break;
     //////////////////////////////////////////////////////////
     // **************** BLOQUE 2 MACERADO PARTE 1 *****************/////
     /////////////////////////////////////////////////////////
     case 2:  if ( entrada == 1 ) {
                  entrada = 2;
                  digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
                  noTone(Buzzer_2);
                  lcd.clear();
                  lcd.setCursor(0, 0);
                  lcd.print("2 -AGUA DE LAVADO- 3");
                  lcd.setCursor(0, 2);
                  lcd.print("-MACERADO-");
            
                  tiempoactual = 0;
                  segundos = 0;
                  minutos = 0;
                  hora = 0;
              }

          
              /////////Parte 1  A  -- AGUA DE LAVADO///////
              lcd.setCursor(16, 1);
              lcd.print(Sensor_Agua, 1);
          
              if (INICIO == true) {
                  if (Sensor_Agua <= 25) {
                    lcd.setCursor( 9, 1);
                    lcd.print("CAL");
                    noTone (Buzzer_2);
                  }
                  else {
                    digitalWrite(led1_Agua_Macerado_y_Lavado, HIGH);
                    lcd.setCursor(2, 1);
                    lcd.print("OK Cancel D");
                    tone (Buzzer_2, 150); // Apagamos con Tecla D = INICIO = false
                    //INICIO = false;
                  }
              }
          
              //////////PARTE 1 B -- MACERADO - ADICIONES TARDIAS 45´///////
              Sensor_Mosto = sensors.getTempCByIndex(1);
              lcd.setCursor(16, 3);
              lcd.print(Sensor_Mosto, 1);
          
              if (teclaB_Macerado == true) {
                  lcd.setCursor(9, 3);
                  lcd.print("ON ");
                  digitalWrite(led5_Macerado_ON, HIGH);
                  Temp_Macerado_Parte_1.timeOut(5000, n2_Adiciones_Tardias_Macerado);// son 45 min
                  if (Sensor_Mosto <= 20) {
                    digitalWrite(led3_Calentado_Recirculado, HIGH);
                    digitalWrite(Rele_Resistencia_de_Macerado, LOW);
                    digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
                  } else if (Sensor_Mosto >= 26) {
                    digitalWrite(led3_Calentado_Recirculado, LOW);
                    digitalWrite(Rele_Resistencia_de_Macerado, HIGH);
                    digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH);
                  }
                  //teclaB_Macerado = false;
                  if  (MaceradoCronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
                      tiempoactual = millis();
                      muestroTiempo();
                      teclaB_Macerado = false;
                  }
              }
              break;
      //////////////////////////////////////////////////////////
      // **************** BLOQUE 3 MACERADO PARTE 2  *****************/////
      /////////////////////////////////////////////////////////              
      case 3: if ( entrada == 1 ) {
                  entrada = 2;
                  //Temp_Macerado_Parte_1.cancel();
                  noTone(Buzzer_1);
                  digitalWrite(led4_Adiciones_Tardias, LOW);
                  digitalWrite(led3_Calentado_Recirculado, LOW);
                  digitalWrite(Rele_Resistencia_de_Macerado, HIGH);
                  digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH);
                  lcd.clear ();
                  lcd.setCursor(0, 0);
                  lcd.print("3 -AGUA DE LAVADO- 4");
                  lcd.setCursor(0, 2);
                  lcd.print("-MACERADO-");
                  // Temp_Macerado_Parte_2.timeOut(4000, n1_Macerado);
                }
                break;
  }
}

OJO, no he mirado tu problema puntual de cuando presionas B. Ahora lo hago.

1 Like
6

Gracias por responder, me pondré a ver esto que me pasas.
Debo reconocer que me cuesta mucho. Para alguien de profesión psicólogo (que maneja otra lógica) encontrarse con respuestas de tanta liviandad y claridad, a mi me retuerce la cabeza. No es para excusarme, es para agradecer vuestra paciencia. Que con sus aportes, es a su vez, mi forma de aprender.

7

Como dije, no te he resuelto el problema.
Lo que si he comenzado a hacer es mostrarlo de otro modo lo que hace mas fácil encontrar errores.
Tal vez aprovechando tu visión profesional dirás : "lo lleva a un lugar donde se siente cómodo y lo comprende". El tema es que justamente lo que siempre promulgamos.
El uso de máquinas de estados. Te recomiendo que vayas a Documentación y leas al respecto.
Básicamente si tu tarea de fabricar cerveza la desglosas en tares menores encuentras estados a los que solo se llega de un modo.
Eso es lo que la máquina de estados representa y en el proceso resulta mucho mas fácil que tener un loop plagado de pasos, condiciones, lectura de sensores, salidas de reles, etc.
Como dije, lo realizado es solo una aproximación que puede mejorarse. Pero tal vez de la lectura rápida que has hecho te resulte ahora como mas claro que antes.
Bien, veamos si podemos ver porque cuando presionas B y se inicie el cronómetro y aún a pesar del buzzer. Acá resulta que el buzzer funciona en una rutina bloqueante por eso hasta que el termine no se puede hacer mas nada.
Asi que es posible que ese sea el problema. Usar tone(pin, frecuencia)
Veamos si hay alguna alternativa NO Bloqueante. Verás que insisto en este término pero que refleja el por que de que un proceso como el tuyo no funcione.
Nada debe consumir mas tiempo del aceptable. Digamos algunos milisegundos.100tos de mseg no se toleran. No son aceptables.
Tu proceso debe ser veloz, estar listo para que uno presione una tecla, cualquiera y responda a esa tecla no importa donde este.
Para eso aún nos falta trabajo que hacer.

NOTA: encontré la librería non blocking que reeplaza a Tone

1 Like
9

Buenas noches. Bueno, como verán he tomado las sugerencias de ustedes, y debo reconocer que sí, queda mucho más ordenado.
Ahora bien, tengo la dificultad (y creo que es muy parecida al posteo anterior) o sigo con lo mismo, no sabría aclarar. El punto es el siguiente: hago referencia a la parte de "case 5"
Cuando el sensor detecta x temperatura inicia el timeOut y también un cronómetro (un contador). Para que el buzzer del contador deje de sonar tengo que usar la línea INICIO_HERVIDO = false;
pero si la empleo, claramente está, que no funciona el cronómetro. Y creo que una situación similar era si apretaba teclaA para iniciar crónometro, o me funciona el cronómetro o no puedo silenciar el buzzer del timeOut. Cómo lo podría resolver? Por lo pronto muchas gracias.

#include <LiquidCrystal.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Keypad.h>
#include <TimeOut.h>

#define Buzzer_1 30
#define Buzzer_2 31

#define ONE_WIRE_BUS 9

#define Rele_Resistencia_de_Macerado 51
#define Rele_Bomba_1_Recirculado_Macerado 52
#define Rele_heladera_Frio 50
#define Rele_heladera_Calor 53

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

const int led1_Agua_Macerado_y_Lavado = 40;
const int led3_Calentado_Recirculado  = 41;
const int led2_Hervido                = 42;
const int led4_Adiciones_Tardias = 43;
const int led5_Macerado_ON = 44;
const int led6_Macerado_OFF = 45;
const int led7_Heladera_Frio = 46;
const int led8_Heladera_Calor = 47;
const int led9_Mash_Out = 48;

boolean teclaA_Cronometro = false; // EN CRONÓMETRO
boolean teclaB_Macerado = false; // EN MACERADO
boolean teclaC_MashOut = false; // EN MASH OUT
boolean INICIO_MACERADO = true;// EN Macerado
boolean INICIO_HERVIDO = true;// EN Hervido
boolean INICIO = true;
boolean InicioCronometro = true;
boolean MaceradoCronometro = true;

TimeOut Temp_Macerado_Parte_1;
TimeOut Temp_Macerado_Parte_2;
TimeOut Temp_Hervido_Parte_1;
TimeOut Temp_Hervido_Parte_2;

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {22, 24, 26, 28};
byte colPins[COLS] = {23, 25, 27, 29};

Keypad teclado = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int secuencia;
int entrada;

float Sensor_Agua;         //sensors.getTempCByIndex(0);
float Sensor_Mosto;        //sensors.getTempCByIndex(1);
float Sensor_Hervido;      //sensors.getTempCByIndex(2);
float Sensor_Fermentacion; //sensors.getTempCByIndex(3);

/// CRONOMETRO/CONTADOR///
unsigned long tiempoactual = 0;
int segundos = 0;
int minutos = 0;
int hora = 0;

/// FERMENTACION///
int  Dia = 0;
float Temperatura_xdia[] = {24, 24, 24, 25, 26, 20, 21, 21, 18, 13, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
float MenosMargenTemp = 0.4;
float MasMargenTemp = 0.4;
Interval intervaloFermentacion;


/////////////////////// void Adiciones Tardias Macerado ///////////////////
void n2_Adiciones_Tardias_Macerado() {
  lcd.setCursor(13, 2);
  lcd.print ("Ad Tard");
  digitalWrite(led4_Adiciones_Tardias, HIGH);
  tone(Buzzer_1, 200);
}

///////////////// void MACERADO ///////////////////////
void n1_Macerado() {
  lcd.setCursor(9, 3);
  lcd.print ("FIN");
  digitalWrite (led5_Macerado_ON, LOW);
  digitalWrite (led6_Macerado_OFF, HIGH);
  tone(Buzzer_1, 200);
}

////////////////////// void Mash Out //////////////////////////////
void n6_Mash_Out() {
  lcd.setCursor(9, 3);
  lcd.print ("FIN");
  tone(Buzzer_1, 200);
}
/////////////////////// void Hervido PARTE 1 //////////////
void n4_Adiciones_Tardias_Hervido() {
  lcd.setCursor(0, 3);
  lcd.print ("Ad Tard");
  digitalWrite(led4_Adiciones_Tardias, HIGH);
  tone(Buzzer_1, 200);
}
//////////////////////// void Hervido PARTE 2 ///////////////////////////
void n3_Hirviendo() {
  digitalWrite(led2_Hervido, LOW);
  lcd.setCursor(5, 3);
  lcd.print ("FIN HERVIDO");
  tone(Buzzer_1, 200);
}
//////////////////////FERMENTACION//////////////////////
void Nuevo_dia() {
  if ( Dia < 22 )                                               // cambiar a cantidad de dias
    Dia++;
}
//////////////////////CRONOMETRO////////////////////////
void muestroTiempo() {
  char buffer[20];

  segundos++;
  if (segundos == 60) {
    segundos = 0;
    minutos ++;
  }
  if (minutos == 60) {
    minutos = 0;
    hora ++;
  }
  if (hora == 24) {
    hora = 0;
  }
  lcd.setCursor(0, 3);
  sprintf(buffer, "%2d:%02d:%02d", hora, minutos, segundos);
  lcd.print(buffer);
}
void midoTemperaturas() {
  sensors.requestTemperatures();
  Sensor_Agua = sensors.getTempCByIndex(0);
}

void setup() {

  lcd.begin( 20, 4);
  lcd.setCursor(7, 0);
  lcd.print("-ANVER-");
  lcd.setCursor(1, 2);
  lcd.print("British Golden Ale");
  delay (2000);
  lcd.clear();

  pinMode(led1_Agua_Macerado_y_Lavado , OUTPUT);
  pinMode(led2_Hervido , OUTPUT);
  pinMode(led3_Calentado_Recirculado , OUTPUT);
  pinMode(led4_Adiciones_Tardias , OUTPUT);
  pinMode(led5_Macerado_ON , OUTPUT);
  pinMode(led6_Macerado_OFF , OUTPUT);
  pinMode(led7_Heladera_Frio , OUTPUT);
  pinMode(led8_Heladera_Calor , OUTPUT);
  pinMode(led9_Mash_Out, OUTPUT);

  pinMode(Buzzer_1, OUTPUT);
  pinMode(Buzzer_2, OUTPUT);

  pinMode(Rele_Resistencia_de_Macerado, OUTPUT);
  pinMode(Rele_Bomba_1_Recirculado_Macerado, OUTPUT);
  pinMode(Rele_heladera_Frio, OUTPUT);
  pinMode(Rele_heladera_Calor, OUTPUT);

  digitalWrite(Rele_Resistencia_de_Macerado, 1);
  digitalWrite(Rele_Bomba_1_Recirculado_Macerado, 1);
  digitalWrite(Rele_heladera_Frio, 1);
  digitalWrite(Rele_heladera_Calor, 1);
  sensors.begin();

  secuencia = 1;
  entrada = 1;
}

void loop() {

  TimeOut::handler();

  midoTemperaturas();

  char tecla = teclado.getKey ();
  switch (tecla) {
    case 'A': // Inicio Cronómetro
      teclaA_Cronometro = true;
      break;
    case 'B': // Inicio Macerado
      teclaB_Macerado = true;
      break;
    case 'C': // Inico Mash Out
      teclaC_MashOut = true;
      break;
    case 'D': // para agua de lavado buzzer 2
      INICIO = false;
      noTone (Buzzer_2);
      digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
      lcd.setCursor(2, 1);
      lcd.print("             ");
      break;

    case '2': secuencia = 2;
      entrada = 1;
      break;
      
    case '3': secuencia = 3;
      entrada = 1;
      break;

    case '4': secuencia = 4;
      entrada = 1;
      break;

    case '5': secuencia = 5;
      entrada = 1;
      break;

    case '6': secuencia = 6;
      entrada = 1;
      break;

    case '7': secuencia = 7;
      entrada = 1;
      break;

    case '8': secuencia = 8;
      entrada = 1;
      break;

    case '9': secuencia = 9;
      entrada = 1;
      break;
  }

  /////////////////////////////////////////////////////
  /// **************** BLOQUE 1 AGUA MACERADO*****************///
  /////////////////////////////////////////////////////
  switch (secuencia) {
    case 1: if ( entrada == 1 ) {
        entrada = 2;
        lcd.setCursor(0, 0);
        lcd.print("1 -AGUA  MACERADO- 2");
        tiempoactual = 0;
        segundos  = 0;
        minutos   = 0;
        hora      = 0;
      }
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Agua, 1);

      if ( Sensor_Agua <= 23) {
        lcd.setCursor( 9, 2);
        lcd.print("CAL");
        digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
        noTone (Buzzer_2);
      }
      else {
        digitalWrite(led1_Agua_Macerado_y_Lavado, HIGH);
        lcd.setCursor(9, 2);
        lcd.print("OK ");
        tone (Buzzer_2, 500);
      }

      if (teclaA_Cronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
        tiempoactual = millis();
        muestroTiempo();
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 2 MACERADO PARTE 1 *****************/////
    /////////////////////////////////////////////////////////
    case 2:  if ( entrada == 1 ) {
        entrada = 2;
        digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
        noTone(Buzzer_2);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("2 -AGUA DE LAVADO- 3");
        lcd.setCursor(0, 2);
        lcd.print("-MACERADO-");

        tiempoactual = 0;
        segundos = 0;
        minutos = 0;
        hora = 0;
      }
      /////////Parte 1  A  -- AGUA DE LAVADO///////
      lcd.setCursor(16, 1);
      lcd.print(Sensor_Agua, 1);

      if (INICIO == true) {
        if (Sensor_Agua <= 25) {
          lcd.setCursor( 9, 1);
          lcd.print("CAL");
          noTone (Buzzer_2);
        }
        else {
          digitalWrite(led1_Agua_Macerado_y_Lavado, HIGH);
          lcd.setCursor(2, 1);
          lcd.print("OK Cancel D");
          tone (Buzzer_2, 150); // Apagamos con Tecla D = INICIO = false
        }
      }

      //////////PARTE 1 B -- MACERADO - ADICIONES TARDIAS 45´///////
      Sensor_Mosto = sensors.getTempCByIndex(1);
      lcd.setCursor(16, 3);
      lcd.print(Sensor_Mosto, 1);

      if (teclaB_Macerado == true) {
        lcd.setCursor(9, 3);
        lcd.print("ON ");
        digitalWrite(led5_Macerado_ON, HIGH);
        Temp_Macerado_Parte_1.timeOut(10000, n2_Adiciones_Tardias_Macerado);// son 45 min

        if (Sensor_Mosto <= 20) {
          digitalWrite(led3_Calentado_Recirculado, HIGH);
          digitalWrite(Rele_Resistencia_de_Macerado, LOW);
          digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
        } else if (Sensor_Mosto >= 26) {
          digitalWrite(led3_Calentado_Recirculado, LOW);
          digitalWrite(Rele_Resistencia_de_Macerado, HIGH);
          digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH);
        }
        teclaB_Macerado = false;

        if  (teclaA_Cronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
          tiempoactual = millis();
          muestroTiempo();
        }
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 3 MACERADO PARTE 2  *****************/////
    /////////////////////////////////////////////////////////
    case 3: if ( entrada == 1 ) {
        entrada = 2;
        Temp_Macerado_Parte_1.cancel();
        noTone(Buzzer_1);
         digitalWrite(led1_Agua_Macerado_y_Lavado, 0);
        digitalWrite(led5_Macerado_ON, 0);
        digitalWrite(led4_Adiciones_Tardias, LOW);
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite(Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH);
        lcd.clear ();
        lcd.setCursor(0, 0);
        lcd.print("3 -AGUA DE LAVADO- 4");
        lcd.setCursor(0, 2);
        lcd.print("-MACERADO-");
        Temp_Macerado_Parte_2.timeOut(4000, n1_Macerado);
      }
      ////////Parte 2  A  -- AGUA DE LAVADO///////
      Sensor_Agua = sensors.getTempCByIndex(0);
      lcd.setCursor(16, 1);
      lcd.print(Sensor_Agua, 1);

      if (INICIO == true) {
        if (Sensor_Agua <= 25) {
          lcd.setCursor( 9, 1);
          lcd.print("CAL");
          noTone (Buzzer_2);
        }
        else {
          digitalWrite (led1_Agua_Macerado_y_Lavado, HIGH);
          lcd.setCursor(2, 1);
          lcd.print("OK Cancel D");
          tone (Buzzer_2, 150); // Apagamos con Tecla D = INICIO = false
        }
        INICIO = false;
      }
      //////////PARTE 2 B -- MACERADO - ADICIONES TARDIAS 45´///////
      Sensor_Mosto = sensors.getTempCByIndex(1);
      lcd.setCursor(16, 3);
      lcd.print(Sensor_Mosto, 1);

      if (Sensor_Mosto <= 20) {
        digitalWrite (led3_Calentado_Recirculado, HIGH);
        digitalWrite(Rele_Resistencia_de_Macerado, LOW);
        digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
      } else if (Sensor_Mosto >= 26) {
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
      }
      break;

    //////////////////////////////////////////////////////////
    // **************** BLOQUE 4 MASH OUT  *****************/////
    /////////////////////////////////////////////////////////
    case 4: if ( entrada == 1 ) {
        entrada = 2;
        lcd.clear();
        Temp_Macerado_Parte_2.cancel();
        noTone(Buzzer_1);
        digitalWrite (led6_Macerado_OFF, LOW);
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite (led1_Agua_Macerado_y_Lavado, LOW);
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
        lcd.setCursor(0, 0);
        lcd.print("4    -MASH OUT-    5");
        lcd.setCursor(5, 3);
        lcd.print("ON tecla C");
      }
      if (teclaC_MashOut == true) {
        lcd.setCursor(5, 3);
        lcd.print("          ");
        sensors.requestTemperatures();
        Sensor_Mosto = sensors.getTempCByIndex(1);
        lcd.setCursor(16, 2);
        lcd.print(Sensor_Mosto, 1);

        if (Sensor_Mosto < 23) {
          lcd.setCursor( 9, 2);
          lcd.print("CAL");
          digitalWrite(led3_Calentado_Recirculado, HIGH);
          digitalWrite (led9_Mash_Out, LOW);
          digitalWrite(Rele_Resistencia_de_Macerado, LOW);
          digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
        }
        else if (Sensor_Mosto > 25) {
          lcd.setCursor(9, 2);
          lcd.print("ON ");
          digitalWrite (led9_Mash_Out, HIGH);
          digitalWrite(led3_Calentado_Recirculado, LOW);
          digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
          digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
        }
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 5  HERVIDO PARTE 1  *****************/////
    /////////////////////////////////////////////////////////
    case 5: if ( entrada == 1 ) {
        entrada = 2;
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
        digitalWrite (led6_Macerado_OFF, LOW);
        digitalWrite(led3_Calentado_Recirculado, LOW);
        noTone(Buzzer_1);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("5  -HERV PARTE 1-  6");
      }
      Sensor_Hervido = sensors.getTempCByIndex(2);
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Hervido, 1);

      if (INICIO_HERVIDO == true) {
        if (Sensor_Hervido <= 23 ) {
          lcd.setCursor( 9, 2);
          lcd.print("CAL");
          digitalWrite(led2_Hervido, LOW);
        } else  {
          lcd.setCursor( 9, 2);
          lcd.print( "HIR");
          digitalWrite(led2_Hervido, HIGH);
          Temp_Hervido_Parte_1.timeOut(50000, n4_Adiciones_Tardias_Hervido);// de 0 a 50 min
          if  (millis() >= tiempoactual + 1000) {
          tiempoactual = millis();
          muestroTiempo();
        }
          //INICIO_HERVIDO = false;
        }
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 6  HERVIDO PARTE 2  *****************/////
    /////////////////////////////////////////////////////////
    case 6: if ( entrada == 1 ) {
        entrada = 2;
        digitalWrite(led2_Hervido, LOW);
        Temp_Hervido_Parte_1.cancel();
        noTone(Buzzer_1);
        lcd.clear();
        digitalWrite(led4_Adiciones_Tardias, LOW);
        lcd.setCursor(0, 0);
        lcd.print("6  -HERV PARTE 2-  7");
        lcd.setCursor( 9, 2);
        lcd.print( "HIR");
        digitalWrite(led2_Hervido, HIGH);
        Temp_Hervido_Parte_2.timeOut(10000, n3_Hirviendo);
      }
      Sensor_Hervido = sensors.getTempCByIndex(2);
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Hervido, 1);
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 7 WHIRLPOOL *****************/////
    /////////////////////////////////////////////////////////
    case 7: if ( entrada == 1 ) {
        entrada = 2;
        noTone (Buzzer_1);
        Temp_Hervido_Parte_2.cancel();
        digitalWrite(led2_Hervido, 0);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("7    -WHIRPOOL-    8");
      }
      Sensor_Hervido = sensors.getTempCByIndex(2);
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Hervido, 1);

      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 8 FERMENTACION PARTE 1 *****************/////
    /////////////////////////////////////////////////////////
    case 8: if ( entrada == 1 ) {
        entrada = 2;
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("8  -FERMENTACION-  9");
        lcd.setCursor(2, 1);
        lcd.print("PARA INICIAR SIG");
      }
      sensors.requestTemperatures();
      Sensor_Fermentacion = sensors.getTempCByIndex(3);
      lcd.setCursor(16, 3);
      lcd.print(Sensor_Fermentacion, 1);
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 9 FERMENTACION  PARTE 2*****************/////
    /////////////////////////////////////////////////////////
    case 9: if ( entrada == 1 ) {
        entrada = 2;
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("9  -FERMENTACION-  2");
        intervaloFermentacion.interval( 200000, Nuevo_dia);
      }
      sensors.requestTemperatures();
      Sensor_Fermentacion = sensors.getTempCByIndex(3);
      lcd.setCursor(0, 3);
      lcd.print( "Temp Ferment    ");
      lcd.print(Sensor_Fermentacion, 1);

      lcd.setCursor( 0, 1);
      lcd.print( "Dia: ");
      lcd.print( Dia);
      lcd.setCursor( 0, 2);
      lcd.print( "Temp Objetivo   ");
      lcd.print( Temperatura_xdia[Dia], 1 );

      if ( Sensor_Fermentacion <= (Temperatura_xdia[Dia] - MenosMargenTemp)) {
        digitalWrite (led7_Heladera_Frio, 0);
        digitalWrite (led8_Heladera_Calor, 1);
        digitalWrite(Rele_heladera_Frio, 1);
        digitalWrite(Rele_heladera_Calor, 0);
        lcd.setCursor( 13, 1);
        lcd.print( "       ");
      } else if ( Sensor_Fermentacion >= (Temperatura_xdia[Dia] + MasMargenTemp)) {
        digitalWrite (led7_Heladera_Frio, 1);
        digitalWrite (led8_Heladera_Calor, 0);
        digitalWrite(Rele_heladera_Frio, 0);
        digitalWrite(Rele_heladera_Calor, 1);
        lcd.setCursor( 13, 1);
        lcd.print( "       ");
      } else {
        lcd.setCursor( 13, 1);
        lcd.print( "Temp OK");
        digitalWrite (led7_Heladera_Frio, 0);
        digitalWrite (led8_Heladera_Calor, 0);
        digitalWrite(Rele_heladera_Frio, 1);
        digitalWrite(Rele_heladera_Calor, 1);
      }
      break;
  }
}
10

Probaste usar la librería no Bloqueante que te sugerí?
Solo úsala y mira qué ocurre con lo que mencionas, si se mantiene el problema o no.

11

Si y no, la probé pero no la puedo hacer andar. Mejor dicho, puedo lograr que suene pero a medias (en algo le estoy errando).

#include <LiquidCrystal.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Keypad.h>
#include <TimeOut.h>
#include <ezBuzzer.h>

ezBuzzer buzzer (30);

#define ONE_WIRE_BUS 9

#define Rele_Resistencia_de_Macerado 51
#define Rele_Bomba_1_Recirculado_Macerado 52
#define Rele_heladera_Frio 50
#define Rele_heladera_Calor 53

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

const int led1_Agua_Macerado_y_Lavado = 40;
const int led3_Calentado_Recirculado  = 41;
const int led2_Hervido                = 42;
const int led4_Adiciones_Tardias = 43;
const int led5_Macerado_ON = 44;
const int led6_Macerado_OFF = 45;
const int led7_Heladera_Frio = 46;
const int led8_Heladera_Calor = 47;
const int led9_Mash_Out = 48;

boolean teclaA_Cronometro = false; // EN CRONÓMETRO
boolean teclaB_Macerado = false; // EN MACERADO
boolean teclaC_MashOut = false; // EN MASH OUT
boolean INICIO_MACERADO = true;// EN Macerado
boolean INICIO_HERVIDO = true;// EN Hervido
boolean INICIO = true;
boolean InicioCronometro = true;
boolean MaceradoCronometro = true;

TimeOut Temp_Macerado_Parte_1;
TimeOut Temp_Macerado_Parte_2;
TimeOut Temp_Hervido_Parte_1;
TimeOut Temp_Hervido_Parte_2;

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {22, 24, 26, 28};
byte colPins[COLS] = {23, 25, 27, 29};

Keypad teclado = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

int secuencia;
int entrada;

float Sensor_Agua;         //sensors.getTempCByIndex(0);
float Sensor_Mosto;        //sensors.getTempCByIndex(1);
float Sensor_Hervido;      //sensors.getTempCByIndex(2);
float Sensor_Fermentacion; //sensors.getTempCByIndex(3);

/// CRONOMETRO/CONTADOR///
unsigned long tiempoactual = 0;
int segundos = 0;
int minutos = 0;
int hora = 0;

/// FERMENTACION///
int  Dia = 0;
float Temperatura_xdia[] = {24, 24, 24, 25, 26, 20, 21, 21, 18, 13, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
float MenosMargenTemp = 0.4;
float MasMargenTemp = 0.4;
Interval intervaloFermentacion;


/////////////////////// void Adiciones Tardias Macerado ///////////////////
void n2_Adiciones_Tardias_Macerado() {
  lcd.setCursor(13, 2);
  lcd.print ("Ad Tard");
  digitalWrite(led4_Adiciones_Tardias, HIGH);

}

///////////////// void MACERADO ///////////////////////
void n1_Macerado() {
  lcd.setCursor(9, 3);
  lcd.print ("FIN");
  digitalWrite (led5_Macerado_ON, LOW);
  digitalWrite (led6_Macerado_OFF, HIGH);

}

////////////////////// void Mash Out //////////////////////////////
void n6_Mash_Out() {
  lcd.setCursor(9, 3);
  lcd.print ("FIN");

}
/////////////////////// void Hervido PARTE 1 //////////////
void n4_Adiciones_Tardias_Hervido() {
  lcd.setCursor(0, 3);
  lcd.print ("Ad Tard");
  digitalWrite(led4_Adiciones_Tardias, HIGH);

}
//////////////////////// void Hervido PARTE 2 ///////////////////////////
void n3_Hirviendo() {
  digitalWrite(led2_Hervido, LOW);
  lcd.setCursor(5, 3);
  lcd.print ("FIN HERVIDO");

}
//////////////////////FERMENTACION//////////////////////
void Nuevo_dia() {
  if ( Dia < 22 )                                               // cambiar a cantidad de dias
    Dia++;
}
//////////////////////CRONOMETRO////////////////////////
void muestroTiempo() {
  char buffer[20];

  segundos++;
  if (segundos == 60) {
    segundos = 0;
    minutos ++;
  }
  if (minutos == 60) {
    minutos = 0;
    hora ++;
  }
  if (hora == 24) {
    hora = 0;
  }
  lcd.setCursor(0, 3);
  sprintf(buffer, "%2d:%02d:%02d", hora, minutos, segundos);
  lcd.print(buffer);
}
void midoTemperaturas() {
  sensors.requestTemperatures();
  Sensor_Agua = sensors.getTempCByIndex(0);
}

void setup() {

  lcd.begin( 20, 4);
  lcd.setCursor(7, 0);
  lcd.print("-ANVER-");
  lcd.setCursor(1, 2);
  lcd.print("British Golden Ale");
  delay (2000);
  lcd.clear();

  pinMode(led1_Agua_Macerado_y_Lavado , OUTPUT);
  pinMode(led2_Hervido , OUTPUT);
  pinMode(led3_Calentado_Recirculado , OUTPUT);
  pinMode(led4_Adiciones_Tardias , OUTPUT);
  pinMode(led5_Macerado_ON , OUTPUT);
  pinMode(led6_Macerado_OFF , OUTPUT);
  pinMode(led7_Heladera_Frio , OUTPUT);
  pinMode(led8_Heladera_Calor , OUTPUT);
  pinMode(led9_Mash_Out, OUTPUT);

  pinMode(Rele_Resistencia_de_Macerado, OUTPUT);
  pinMode(Rele_Bomba_1_Recirculado_Macerado, OUTPUT);
  pinMode(Rele_heladera_Frio, OUTPUT);
  pinMode(Rele_heladera_Calor, OUTPUT);

  digitalWrite(Rele_Resistencia_de_Macerado, 1);
  digitalWrite(Rele_Bomba_1_Recirculado_Macerado, 1);
  digitalWrite(Rele_heladera_Frio, 1);
  digitalWrite(Rele_heladera_Calor, 1);
  sensors.begin();

  secuencia = 1;
  entrada = 1;
}

void loop() {
  buzzer.loop();

  TimeOut::handler();

  midoTemperaturas();

  char tecla = teclado.getKey ();
  switch (tecla) {
    case 'A': // Inicio Cronómetro
      teclaA_Cronometro = true;
      break;
    case 'B': // Inicio Macerado
      teclaB_Macerado = true;
      break;
    case 'C': // Inico Mash Out
      teclaC_MashOut = true;
      break;
    case 'D': // para agua de lavado buzzer 2
      INICIO = false;
      digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
      lcd.setCursor(2, 1);
      lcd.print("             ");
      break;

    case '2': secuencia = 2;
      entrada = 1;
      break;

    case '3': secuencia = 3;
      entrada = 1;
      break;

    case '4': secuencia = 4;
      entrada = 1;
      break;

    case '5': secuencia = 5;
      entrada = 1;
      break;

    case '6': secuencia = 6;
      entrada = 1;
      break;

    case '7': secuencia = 7;
      entrada = 1;
      break;

    case '8': secuencia = 8;
      entrada = 1;
      break;

    case '9': secuencia = 9;
      entrada = 1;
      break;
  }

  /////////////////////////////////////////////////////
  /// **************** BLOQUE 1 AGUA MACERADO*****************///
  /////////////////////////////////////////////////////
  switch (secuencia) {
    case 1: if ( entrada == 1 ) {
        entrada = 2;
        lcd.setCursor(0, 0);
        lcd.print("1 -AGUA  MACERADO- 2");
        tiempoactual = 0;
        segundos  = 0;
        minutos   = 0;
        hora      = 0;
      }
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Agua, 1);
      
      if ( Sensor_Agua <= 21.5) {
        lcd.setCursor( 9, 2);
        lcd.print("CAL");
        digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);

      }
      else {
        digitalWrite(led1_Agua_Macerado_y_Lavado, HIGH);
        lcd.setCursor(9, 2);
        lcd.print("OK ");
        buzzer.beep (1000);
      }

      if (teclaA_Cronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
        tiempoactual = millis();
        muestroTiempo();
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 2 MACERADO PARTE 1 *****************/////
    /////////////////////////////////////////////////////////
    case 2:  if ( entrada == 1 ) {
        entrada = 2;
        digitalWrite(led1_Agua_Macerado_y_Lavado, LOW);
        //buzzer.stop();
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("2 -AGUA DE LAVADO- 3");
        lcd.setCursor(0, 2);
        lcd.print("-MACERADO-");

        tiempoactual = 0;
        segundos = 0;
        minutos = 0;
        hora = 0;
      }
      /////////Parte 1  A  -- AGUA DE LAVADO///////
      lcd.setCursor(16, 1);
      lcd.print(Sensor_Agua, 1);

      if (INICIO == true) {
        if (Sensor_Agua <= 25) {
          lcd.setCursor( 9, 1);
          lcd.print("CAL");
        }
        else {
          digitalWrite(led1_Agua_Macerado_y_Lavado, HIGH);
          lcd.setCursor(2, 1);
          lcd.print("OK Cancel D");
        }
      }

      //////////PARTE 1 B -- MACERADO - ADICIONES TARDIAS 45´///////
      Sensor_Mosto = sensors.getTempCByIndex(1);
      lcd.setCursor(16, 3);
      lcd.print(Sensor_Mosto, 1);

      if (teclaB_Macerado == true) {
        lcd.setCursor(9, 3);
        lcd.print("ON ");
        digitalWrite(led5_Macerado_ON, HIGH);
        Temp_Macerado_Parte_1.timeOut(10000, n2_Adiciones_Tardias_Macerado);// son 45 min

        if (Sensor_Mosto <= 20) {
          digitalWrite(led3_Calentado_Recirculado, HIGH);
          digitalWrite(Rele_Resistencia_de_Macerado, LOW);
          digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
        } else if (Sensor_Mosto >= 26) {
          digitalWrite(led3_Calentado_Recirculado, LOW);
          digitalWrite(Rele_Resistencia_de_Macerado, HIGH);
          digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH);
        }
        teclaB_Macerado = false;

        if  (teclaA_Cronometro == true  &&  (millis() >= tiempoactual + 1000)  ) {
          tiempoactual = millis();
          muestroTiempo();
        }
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 3 MACERADO PARTE 2  *****************/////
    /////////////////////////////////////////////////////////
    case 3: if ( entrada == 1 ) {
        entrada = 2;
        Temp_Macerado_Parte_1.cancel();

        digitalWrite(led1_Agua_Macerado_y_Lavado, 0);
        digitalWrite(led5_Macerado_ON, 0);
        digitalWrite(led4_Adiciones_Tardias, LOW);
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite(Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH);
        lcd.clear ();
        lcd.setCursor(0, 0);
        lcd.print("3 -AGUA DE LAVADO- 4");
        lcd.setCursor(0, 2);
        lcd.print("-MACERADO-");
        Temp_Macerado_Parte_2.timeOut(4000, n1_Macerado);
      }
      ////////Parte 2  A  -- AGUA DE LAVADO///////
      Sensor_Agua = sensors.getTempCByIndex(0);
      lcd.setCursor(16, 1);
      lcd.print(Sensor_Agua, 1);

      if (INICIO == true) {
        if (Sensor_Agua <= 25) {
          lcd.setCursor( 9, 1);
          lcd.print("CAL");

        }
        else {
          digitalWrite (led1_Agua_Macerado_y_Lavado, HIGH);
          lcd.setCursor(2, 1);
          lcd.print("OK Cancel D");

        }
        INICIO = false;
      }
      //////////PARTE 2 B -- MACERADO - ADICIONES TARDIAS 45´///////
      Sensor_Mosto = sensors.getTempCByIndex(1);
      lcd.setCursor(16, 3);
      lcd.print(Sensor_Mosto, 1);

      if (Sensor_Mosto <= 20) {
        digitalWrite (led3_Calentado_Recirculado, HIGH);
        digitalWrite(Rele_Resistencia_de_Macerado, LOW);
        digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
      } else if (Sensor_Mosto >= 26) {
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
      }
      break;

    //////////////////////////////////////////////////////////
    // **************** BLOQUE 4 MASH OUT  *****************/////
    /////////////////////////////////////////////////////////
    case 4: if ( entrada == 1 ) {
        entrada = 2;
        lcd.clear();
        Temp_Macerado_Parte_2.cancel();

        digitalWrite (led6_Macerado_OFF, LOW);
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite (led1_Agua_Macerado_y_Lavado, LOW);
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
        lcd.setCursor(0, 0);
        lcd.print("4    -MASH OUT-    5");
        lcd.setCursor(5, 3);
        lcd.print("ON tecla C");
      }
      if (teclaC_MashOut == true) {
        lcd.setCursor(5, 3);
        lcd.print("          ");
        sensors.requestTemperatures();
        Sensor_Mosto = sensors.getTempCByIndex(1);
        lcd.setCursor(16, 2);
        lcd.print(Sensor_Mosto, 1);

        if (Sensor_Mosto < 23) {
          lcd.setCursor( 9, 2);
          lcd.print("CAL");
          digitalWrite(led3_Calentado_Recirculado, HIGH);
          digitalWrite (led9_Mash_Out, LOW);
          digitalWrite(Rele_Resistencia_de_Macerado, LOW);
          digitalWrite(Rele_Bomba_1_Recirculado_Macerado, LOW);
        }
        else if (Sensor_Mosto > 25) {
          lcd.setCursor(9, 2);
          lcd.print("ON ");
          digitalWrite (led9_Mash_Out, HIGH);
          digitalWrite(led3_Calentado_Recirculado, LOW);
          digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
          digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
        }
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 5  HERVIDO PARTE 1  *****************/////
    /////////////////////////////////////////////////////////
    case 5: if ( entrada == 1 ) {
        entrada = 2;
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_1_Recirculado_Macerado, HIGH);
        digitalWrite (led6_Macerado_OFF, LOW);
        digitalWrite(led3_Calentado_Recirculado, LOW);

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("5  -HERV PARTE 1-  6");
      }
      Sensor_Hervido = sensors.getTempCByIndex(2);
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Hervido, 1);

      if (INICIO_HERVIDO == true) {
        if (Sensor_Hervido <= 23 ) {
          lcd.setCursor( 9, 2);
          lcd.print("CAL");
          digitalWrite(led2_Hervido, LOW);
        } else  {
          lcd.setCursor( 9, 2);
          lcd.print( "HIR");
          digitalWrite(led2_Hervido, HIGH);
          Temp_Hervido_Parte_1.timeOut(50000, n4_Adiciones_Tardias_Hervido);// de 0 a 50 min
          if  (millis() >= tiempoactual + 1000) {
            tiempoactual = millis();
            muestroTiempo();
          }
          //INICIO_HERVIDO = false;
        }
      }
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 6  HERVIDO PARTE 2  *****************/////
    /////////////////////////////////////////////////////////
    case 6: if ( entrada == 1 ) {
        entrada = 2;
        digitalWrite(led2_Hervido, LOW);
        Temp_Hervido_Parte_1.cancel();

        lcd.clear();
        digitalWrite(led4_Adiciones_Tardias, LOW);
        lcd.setCursor(0, 0);
        lcd.print("6  -HERV PARTE 2-  7");
        lcd.setCursor( 9, 2);
        lcd.print( "HIR");
        digitalWrite(led2_Hervido, HIGH);
        Temp_Hervido_Parte_2.timeOut(10000, n3_Hirviendo);
      }
      Sensor_Hervido = sensors.getTempCByIndex(2);
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Hervido, 1);
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 7 WHIRLPOOL *****************/////
    /////////////////////////////////////////////////////////
    case 7: if ( entrada == 1 ) {
        entrada = 2;

        Temp_Hervido_Parte_2.cancel();
        digitalWrite(led2_Hervido, 0);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("7    -WHIRPOOL-    8");
      }
      Sensor_Hervido = sensors.getTempCByIndex(2);
      lcd.setCursor(16, 2);
      lcd.print(Sensor_Hervido, 1);

      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 8 FERMENTACION PARTE 1 *****************/////
    /////////////////////////////////////////////////////////
    case 8: if ( entrada == 1 ) {
        entrada = 2;
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("8  -FERMENTACION-  9");
        lcd.setCursor(2, 1);
        lcd.print("PARA INICIAR SIG");
      }
      sensors.requestTemperatures();
      Sensor_Fermentacion = sensors.getTempCByIndex(3);
      lcd.setCursor(16, 3);
      lcd.print(Sensor_Fermentacion, 1);
      break;
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 9 FERMENTACION  PARTE 2*****************/////
    /////////////////////////////////////////////////////////
    case 9: if ( entrada == 1 ) {
        entrada = 2;
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("9  -FERMENTACION-  2");
        intervaloFermentacion.interval( 200000, Nuevo_dia);
      }
      sensors.requestTemperatures();
      Sensor_Fermentacion = sensors.getTempCByIndex(3);
      lcd.setCursor(0, 3);
      lcd.print( "Temp Ferment    ");
      lcd.print(Sensor_Fermentacion, 1);

      lcd.setCursor( 0, 1);
      lcd.print( "Dia: ");
      lcd.print( Dia);
      lcd.setCursor( 0, 2);
      lcd.print( "Temp Objetivo   ");
      lcd.print( Temperatura_xdia[Dia], 1 );

      if ( Sensor_Fermentacion <= (Temperatura_xdia[Dia] - MenosMargenTemp)) {
        digitalWrite (led7_Heladera_Frio, 0);
        digitalWrite (led8_Heladera_Calor, 1);
        digitalWrite(Rele_heladera_Frio, 1);
        digitalWrite(Rele_heladera_Calor, 0);
        lcd.setCursor( 13, 1);
        lcd.print( "       ");
      } else if ( Sensor_Fermentacion >= (Temperatura_xdia[Dia] + MasMargenTemp)) {
        digitalWrite (led7_Heladera_Frio, 1);
        digitalWrite (led8_Heladera_Calor, 0);
        digitalWrite(Rele_heladera_Frio, 0);
        digitalWrite(Rele_heladera_Calor, 1);
        lcd.setCursor( 13, 1);
        lcd.print( "       ");
      } else {
        lcd.setCursor( 13, 1);
        lcd.print( "Temp OK");
        digitalWrite (led7_Heladera_Frio, 0);
        digitalWrite (led8_Heladera_Calor, 0);
        digitalWrite(Rele_heladera_Frio, 1);
        digitalWrite(Rele_heladera_Calor, 1);
      }
      break;
  }
}

Con esto de noBloqueante me puse a ver y creo que hay otras librerías como EasyBuzzer. Pero también tengo otra dificultad. Suena pero no lo puedo apagar. Lo cual me lleva a pensar que el error esta donde ubico EasyBuzzer.stopBeep() . Seguiré probando.

12

Empieza siempre por los ejemplos.
Si no entiendes el ejemplo menos aplicarlo a tu código.

13

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.