Resolución del sensor

International Español Software
1

Buenos días, como están. Les quiero preguntar lo siguiente. Con esta fracción de código resumida del Sensor DS18B20 funciona con dos dígitos para la unidad y 2 dígitos en los decimales ( ej 21,25) y el aumento o disminución de temperatura va de a 0.25 o sea 21.25 / 21.50 / 21.75. La pregunta es cómo se hace para usar solamente 1 decimal y que aumente o disminuya de 1 en 1. (ej 21.3) Estuve viendo la librería del Dallas y creo que viene por este lado "sensors.setResolution(9);" pero no doy en la tecla y puedo dejarlo con un solo decimal. Como se haría eso? Muchas gracias por su tiempo.

#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 9

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

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

void setup() {
  sensors.begin();
}

void loop() {

   
  /////////////////////////////////////////////////////
  /// **************** BLOQUE 1 AGUA *****************///
  /////////////////////////////////////////////////////

  if ( secuencia == 1 ) {
    if ( entrada == 1 ) {
      entrada = 2;
      lcd.setCursor(0, 0);
      lcd.print("1 -AGUA DE LAVADO- 2");
 
    }
    sensors.requestTemperatures();
    Sensor_Agua = sensors.getTempCByIndex(0);
    lcd.setCursor(15, 2);
    lcd.print(Sensor_Agua);
2

Quizá te valga el post 12 de este enlace:
https://forum.arduino.cc/t/round-function/85089/12?u=danx3
Saludos.

1 Like
3 
sensors.setResolution(9);

Eso le dice que use 9 bits que son en realidad 512 pasos del rango dinámico del sensor
10 bits son 1024
11 bits son 2048
12 bits son 4096
Entonces... ponerlo en baja resolución hace mas rápida la conversion pero yo no recommiendo usarlo por debajo de 10 bits. En tu caso, hasta lo pondria en 12 o sea lo dejo por defecto y luego decido que quiero ver para lo cual puedes usar la sugerencia de @DanX3 o otra alernativas como por ejemplo dtostrf

1 Like
4

Hi,
Si es que quires printear solamente un decimal entonces anadale al comando de printear al lcd un 1. Adjunto el sketch como hacerlo. Siempre y cuando es lo que entendi que quieres hacer. Sino ignora la sugerencia,

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:
 lcd.print(Sensor_Agua,1);
}
1 Like
6

Muchas gracias, eso es lo que quiero hacer y también encontré en este post Temperature sensor DS18B20 does not show the detail decimal measurements y en el que sugirió DanX3

7

La solución fue esta

sensors.requestTemperatures();
sensors.setResolution(12); // con esto logro que aumente o disminuya de a 1 (20.1 / 20.2 / 20.3)
Sensor_Agua = sensors.getTempCByIndex(0);
lcd.setCursor(16, 1);
lcd.print(Sensor_Agua,1); // con esto logro que en lugar de verse así 20.10 Pueda verse 20.1

Muchas gracias

8

Buenos días, les consulto esta dificultad que estoy teniendo. Puede ser que al usar

sensors.setResolution(12); // con esto logro que aumente o disminuya de a 1 (20.1 / 20.2 / 20.3)
Sensor_Agua = sensors.getTempCByIndex(0);

haga interferencia el Buzzer cuando suena (como con una pequeña descarga)?

9

Estaría bueno saber de qué buzzer estás hablando ya que hasta ahora nunca lo has mencionado y en el código tampoco figura.

Saludos

10

Según que código uses para leer el DS18B20, puede ser o no bloqueante. Si es bloqueante como la mayoría de las librerías a 12 bits hablas de 750mseg de pausa asi que si esa es tu interferencia, la respuesta es que puede ser.
Ahora interferencia es otra cosa tal como yo la entiendo.

1 Like
11

Un módulo de buzzer pasivo HW-508

12

Puede ser que sea lo que estas diciendo. Me podrás orientar como resolverlo o por donde puedo buscar?
En realidad deduzco que es eso, porque en el código comento (//) inhabilitando la parte del sensor y suena bien

13

Cambia la resolución a 11 bits y dime si mejora. Y si lo hace baja a 10 bits y entonces quedará confirmado.
Mientras te busco la librería no bloqueante para los Dallas y podras volver a 12 bits.

1 Like
14

@nandozu lo que te quise decir es que subas el código completo porque hasta ahora, en los fragmentos que has subido, no hemos visto nada relacionado con un buzzer (ni ningún pin de salida, de hecho).

Saludos

15

Aaaa bien. Acá está el código completo

#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_de_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 Calentar_Recircular = false; // EN MACERADO
boolean INICIO_MACERADO = true;// EN Macerado
boolean INICIO_HERVIDO = true;// EN Hervido
boolean INICIO = 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_de_Macerado, OUTPUT);
  pinMode(Rele_heladera_Frio, OUTPUT);
  pinMode(Rele_heladera_Calor, OUTPUT);

  digitalWrite(Rele_Resistencia_de_Macerado, 1);
  digitalWrite(Rele_Bomba_de_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;
    Calentar_Recircular = 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(9, 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();
    sensors.setResolution(12);
    Sensor_Agua = sensors.getTempCByIndex(0);
    lcd.setCursor(16, 2);
    lcd.print(Sensor_Agua, 1);

    if ( Sensor_Agua <= 21) {
      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, 150);
    }

    if (teclaA_Cronometro == 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("0");
      }
      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;
      teclaA_Cronometro = 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();
    sensors.setResolution(12);

    /////////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 <= 21) {
        lcd.setCursor( 9, 1);
        lcd.print("CAL");
        noTone (Buzzer_2);
      }
      else {
        digitalWrite (led1_Agua_Macerado_y_Lavado, HIGH);
        lcd.setCursor(9, 1);
        lcd.print("OK ");
        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
      teclaB_Macerado = false;
    }
    //if (teclaB_Macerado == true  ||  Calentar_Recircular == true) {
    if (Calentar_Recircular == true) {
      if (Sensor_Mosto <= 25) {
        digitalWrite (led3_Calentado_Recirculado, HIGH);
        digitalWrite(Rele_Resistencia_de_Macerado, LOW);
        digitalWrite(Rele_Bomba_de_Macerado, LOW);
      } else if (Sensor_Mosto >= 26) {
        digitalWrite(led3_Calentado_Recirculado, LOW);
        digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
        digitalWrite (Rele_Bomba_de_Macerado, HIGH);
      }
      //teclaB_Macerado = false;
    }

    if (teclaA_Cronometro == 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(12, 2);
      if (hora < 10)
      {
        lcd.print("0");
      }
      lcd.print(hora);
      lcd.print(":");
      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("  ");
      }
    }
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 3 MACERADO PARTE 2  *****************/////
    /////////////////////////////////////////////////////////
    if ( tecla == '3') {
      secuencia = 3;
      entrada = 1;
      teclaA_Cronometro = false;
      //      Temp_Macerado_Parte_1.cancel();
      //      Temp_Macerado_Parte_2.timeOut(4000, n1_Macerado);
      //      teclaA_Cronometro = false;
      //      INICIO_MACERADO = true;
      //      digitalWrite(led4_Adiciones_Tardias, LOW);
      //      digitalWrite(led3_Calentado_Recirculado, LOW);
      //      digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
      //      digitalWrite (Rele_Bomba_de_Macerado, HIGH);
      //      noTone(Buzzer_1);
      //      lcd.clear ();

    }
  }

  else if ( secuencia == 3 ) { //
    if ( entrada == 1 ) {
      entrada = 2;
      INICIO = false; //para cancelar INICIO en Parte 1  A  -- AGUA DE LAVADO
      Temp_Macerado_Parte_1.cancel();
      //Temp_Macerado_Parte_2.timeOut(4000, n1_Macerado);
      digitalWrite(led4_Adiciones_Tardias, LOW);
      digitalWrite(led3_Calentado_Recirculado, LOW);
      digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
      digitalWrite (Rele_Bomba_de_Macerado, HIGH);
      noTone(Buzzer_1);
      lcd.clear ();
      lcd.setCursor(0, 0);
      lcd.print("3 -AGUA DE LAVADO- 4");
      lcd.setCursor(0, 2);
      lcd.print("-MACERADO-");

    }
    sensors.requestTemperatures();
    sensors.setResolution(12);

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

    if (INICIO_MACERADO == true) {//// Se cancela con Tecla D
      if (Sensor_Agua <= 22) {
        lcd.setCursor( 9, 1);
        lcd.print("CAL");
        noTone (Buzzer_2);
      }
      else {
        digitalWrite (led1_Agua_Macerado_y_Lavado, HIGH);
        lcd.setCursor(9, 1);
        lcd.print("OK ");
        tone (Buzzer_2, 150);
      }
    }
//    if (tecla == 'D') { // para agua de lavado buzzer 2
//      INICIO_MACERADO = false;
//      noTone (Buzzer_2);
//    }
    /////////CONTROL DE TEMPERATURA DEL MOSTO///////
    Sensor_Mosto = sensors.getTempCByIndex(1);
    lcd.setCursor(16, 3);
    lcd.print(Sensor_Mosto, 1);

    if (Sensor_Mosto <= 25) {
      digitalWrite (led3_Calentado_Recirculado, HIGH);
      digitalWrite(Rele_Resistencia_de_Macerado, LOW);
      digitalWrite(Rele_Bomba_de_Macerado, LOW);
    } else if (Sensor_Mosto >= 26) {
      digitalWrite(led3_Calentado_Recirculado, LOW);
      digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
      digitalWrite (Rele_Bomba_de_Macerado, HIGH);
    }
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 4 MASH OUT  *****************/////
    /////////////////////////////////////////////////////////
    if ( tecla == '4') {                // test
      secuencia = 4;
      entrada = 1;
    }
  }

  else if ( secuencia == 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_de_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();
      sensors.setResolution(12);
      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_de_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_de_Macerado, HIGH);
      }
    }

    //////////////////////////////////////////////////////////
    // **************** BLOQUE 5  HERVIDO PARTE 1  *****************/////
    /////////////////////////////////////////////////////////
    if ( tecla == '5') {                // test
      secuencia = 5;
      entrada = 1;
    }
  }
  else if ( secuencia == 5 ) {
    if ( entrada == 1 ) {
      entrada = 2;
      digitalWrite (Rele_Resistencia_de_Macerado, HIGH);
      digitalWrite (Rele_Bomba_de_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");

    }
    sensors.requestTemperatures();
    sensors.setResolution(12);
    Sensor_Hervido = sensors.getTempCByIndex(2);
    lcd.setCursor(16, 2);
    lcd.print(Sensor_Hervido, 1);


    if (INICIO_HERVIDO == true) {
      if (Sensor_Hervido <= 25 ) {
        lcd.setCursor( 9, 1);
        lcd.print("CAL");
        digitalWrite(led2_Hervido, LOW);
      } else  {
        lcd.setCursor( 9, 1);
        lcd.print( "HIR");
        digitalWrite(led2_Hervido, HIGH);
        Temp_Hervido_Parte_1.timeOut(10000, n4_Adiciones_Tardias_Hervido);// de 0 a 50 min
        INICIO_HERVIDO = false;
      }
    }
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 6  HERVIDO PARTE 2  *****************/////
    /////////////////////////////////////////////////////////
    if ( tecla == '6') {
      secuencia = 6;
      entrada = 1;
    }
  }

  else if ( secuencia == 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, 1);
      lcd.print( "HIR");
      digitalWrite(led2_Hervido, HIGH);
      Temp_Hervido_Parte_2.timeOut(10000, n3_Hirviendo);

    }
    sensors.requestTemperatures();
    sensors.setResolution(12);
    Sensor_Hervido = sensors.getTempCByIndex(2);
    lcd.setCursor(16, 2);
    lcd.print(Sensor_Hervido, 1);

    //////////////////////////////////////////////////////////
    // **************** BLOQUE 7 WHIRLPOOL *****************/////
    /////////////////////////////////////////////////////////
    if ( tecla == '7') {

      secuencia = 7;
      entrada = 1;

    }
  }
  else if ( secuencia == 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");
    }
    sensors.requestTemperatures();
    sensors.setResolution(12);
    Sensor_Hervido = sensors.getTempCByIndex(2);
    lcd.setCursor(16, 2);
    lcd.print(Sensor_Hervido, 1);

    //////////////////////////////////////////////////////////
    // **************** BLOQUE 8 FERMENTACION PARTE 1 *****************/////
    /////////////////////////////////////////////////////////

    if ( tecla == '8') {                // test volver a empezar
      secuencia = 8;
      entrada = 1;
    }
  }

  else if ( secuencia == 8 ) {         // fin
    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();
    sensors.setResolution(12);
    Sensor_Fermentacion = sensors.getTempCByIndex(3);
    lcd.setCursor(16, 3);
    lcd.print(Sensor_Fermentacion, 1);

    //////////////////////////////////////////////////////////
    // **************** BLOQUE 9 FERMENTACION  INICIO*****************/////
    /////////////////////////////////////////////////////////
    if ( tecla == '9') {                // test volver a empezar
      secuencia = 9;
      entrada = 1;
    }
  }
  else if ( secuencia == 9 ) {         // fin
    if ( entrada == 1 ) {
      entrada = 2;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("9  -FERMENTACION-  2");
      intervaloFermentacion.interval( 200000, Nuevo_dia);
    }
    sensors.requestTemperatures();
    sensors.setResolution(12);
    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);
    }



    // VER QUE HACER
    //////////////////////////////////////////////////////////
    // **************** BLOQUE 10 FIN*****************/////
    /////////////////////////////////////////////////////////

    if ( tecla == '2') {                // test volver a empezar
      secuencia = 1;
      entrada = 1;
      lcd.clear();
      digitalWrite(Rele_heladera_Frio, 1);
      digitalWrite(Rele_heladera_Calor, 1);
      digitalWrite (led7_Heladera_Frio, 0);
      digitalWrite (led8_Heladera_Calor, 0);
    }
  }
}
/////////////////////// void Adiciones Tardias Macerado ///////////////////
void n2_Adiciones_Tardias_Macerado() {
  lcd.setCursor(0, 3);
  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++;
}
16

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