Aquí está mi versión con máquina de estados. Aunque de entrada es más complicado y enrevesado de hacer con una máquina de estados, en cuanto quieres hacer más cosas la máquina de estado te lo simplifica mucho.
#include "max6675.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20 , 4);
// 0x27 0x3F , 0x20 , 0x38 , 16 , 2 20 , 4
const byte CANTIDAD_CICLOS = 2; // Cantidad de ciclos intermedios que se quiere
const int MAXIMO_CALENTANDO = 39.0; // Temperatura hasta que se ha de calentar en los ciclos intermedios
const int MINIMO_ENFRIANDO = 36.0; // Temperatura hasta que se ha de enfriar en los ciclos intermedios
const int MAXIMO_CALENTANDO_FINAL_A = 40.0; // Temperatura hasta que se ha de calentar al final (opción A)
const int MAXIMO_CALENTANDO_FINAL_B = 42.0; // Temperatura hasta que se ha de calentar al final (opción B)
const int MINIMO_ENFRIANDO_FINAL = 29.0; // Temperatura hasta que se ha de enfriar para apagar el ventilador
const unsigned long INTERVALO_ENTRE_LECTURAS = 2500UL; // Milisegundos que han de transcurrir entre cada lectura de la temperatura
const bool FLECHAS = true; // Cambia las "animaciones" dependiedo de si se define true o false
// Definición de los pines usados
const byte THERMO_DO = 6; // Pines a los que está conectado el sensor de termperatura
const byte THERMO_CS = 5;
const byte THERMO_CLK = 4;
const byte PIN_SELECTOR_TEMPERATURA = 10; // Pin de selector de temperatura final (opción A o B)
const byte PIN_RELE_CALENTADOR = 12; // Pin al que está conectado el relé del calentador
const byte PIN_RELE_VENTILADOR = 13; // Pin al que está conectado el relé del ventilador
// Lo siguiente lo he respetado del código original porque no tengo claro qué es lo que se está haciendo con ello
const byte vccPin = 3;
const byte gndPin = 2;
const byte gndPinf = 8;
const byte vccPinr = 9;
const byte VALOR_RELE_ACTIVADO = LOW; // Valor que ha de tener el pin para que se active el relé
const byte VALOR_RELE_APAGADO = !VALOR_RELE_ACTIVADO; // Esta definición no hay que tocarla nunca, se ha de modificar la de VALOR_RELE_ACTIVADO si fuera necesario
MAX6675 thermocouple(THERMO_CLK, THERMO_CS, THERMO_DO);
float temperatura = 20; // Almacena el valor de la temperatura
unsigned long instanteAnterior = 0; // Para controlar las pausas en la máquina de estados
unsigned long instanteAnteriorTemperatura = 0; // Para controlar el tiempo transcurrido desde la última lectura de temperatura
unsigned long instanteAnteriorCaracter = 0; // Para controlar el tiempo de la animación de los caractéres
byte ciclo = 0; // Lleva la cuenta del ciclo en que se encuentra
byte pasoCaracter = 0; // Para controlar en que paso está de la animación de los caractéres (todos tienen cuato pasos)
int temperaturaCalentamientoFinal = 0; // Almacena el valor de la temperatura del calentamiento final que vale según la posición del delector de temperatura
int temperaturaCalentamientoFinalAnterior = 0; // Tan solo es para ver si ha cambiado el valor de temperaturaCalentamientoFinal. Si es así, actualiza su visualización en el LCD
// Definición del enumerado y de la variable que guarda en qué estado se encuentra la máquina de estado
enum estado_t {
ESTADO_INICIAL,
ESTADO_PRESENTACION,
ESTADO_CALENTANDO,
ESTADO_ENFRIANDO,
ESTADO_CALENTANDO_FINAL,
ESTADO_ENFRIANDO_FINAL,
ESTADO_FINAL
} estado = ESTADO_INICIAL;
// Definiciones de los caractéres para la animación
byte cararterSubir[4][8] = {
{
B00100,
B01110,
B11011,
B10001,
B00100,
B01110,
B11011,
B10001
}
, {
B01110,
B11011,
B10001,
B00100,
B01110,
B11011,
B10001,
B00100
}
, {
B11011,
B10001,
B00100,
B01110,
B11011,
B10001,
B00100,
B01110
}
, {
B10001,
B00100,
B01110,
B11011,
B10001,
B00100,
B01110,
B11011
}
};
byte cararterBajar[4][8] = {
{
B10001,
B11011,
B01110,
B00100,
B10001,
B11011,
B01110,
B00100
}
, {
B00100,
B10001,
B11011,
B01110,
B00100,
B10001,
B11011,
B01110
}
, {
B01110,
B00100,
B10001,
B11011,
B01110,
B00100,
B10001,
B11011
}
, {
B11011,
B01110,
B00100,
B10001,
B11011,
B01110,
B00100,
B10001
}
};
byte cararterCalentar[4][8] = {
{
B00001,
B01001,
B10010,
B10010,
B01001,
B01001,
B10100,
B01110
}
, {
B01000,
B10010,
B10010,
B01001,
B01001,
B10010,
B00110,
B01110
}
, {
B00010,
B10010,
B01001,
B01001,
B10010,
B10010,
B01100,
B01110
}
, {
B10000,
B01001,
B01001,
B10010,
B10010,
B01001,
B00101,
B01110
}
};
byte cararterEnfriar[4][8] = {
{
B00000,
B00110,
B11001,
B00000,
B10011,
B01100,
B00100,
B01110
}
, {
B00000,
B10011,
B01100,
B00000,
B11001,
B00110,
B00100,
B01110
}
, {
B00000,
B11001,
B00110,
B00000,
B01100,
B10011,
B00100,
B01110
}
, {
B00000,
B01100,
B10011,
B00000,
B00110,
B11001,
B00100,
B01110
}
};
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
pinMode(PIN_RELE_CALENTADOR, OUTPUT);
digitalWrite(PIN_RELE_CALENTADOR, VALOR_RELE_APAGADO);
pinMode(PIN_RELE_VENTILADOR, OUTPUT);
digitalWrite(PIN_RELE_VENTILADOR, VALOR_RELE_APAGADO);
pinMode(PIN_SELECTOR_TEMPERATURA, INPUT);
// Lo siguiente lo he respetado del código original porque no tengo claro qué es lo que se está haciendo con ello
pinMode(vccPin, OUTPUT);
digitalWrite(vccPin, HIGH);
// Lo siguiente lo he respetado del código original porque no tengo claro qué es lo que se está haciendo con ello
pinMode(gndPin, OUTPUT);
digitalWrite(gndPin, LOW);
// Lo siguiente lo he respetado del código original porque no tengo claro qué es lo que se está haciendo con ello
pinMode(vccPinr, OUTPUT);
digitalWrite(vccPinr, HIGH);
// Lo siguiente lo he respetado del código original porque no tengo claro qué es lo que se está haciendo con ello
pinMode(gndPinf, OUTPUT);
digitalWrite(gndPinf, LOW);
}
void loop() {
unsigned long instanteActual = millis();
bool refrescarLCD = false;
bool refrescarTemperaturaFinal = false;
if ((instanteActual - instanteAnteriorCaracter) >= 250UL) {
instanteAnteriorCaracter = instanteActual;
pasoCaracter = (pasoCaracter + 1) % 4;
if (FLECHAS) {
lcd.createChar(0, cararterSubir[pasoCaracter]);
lcd.createChar(1, cararterBajar[pasoCaracter]);
}
else {
lcd.createChar(0, cararterCalentar[pasoCaracter]);
lcd.createChar(1, cararterEnfriar[pasoCaracter]);
}
}
if ((instanteActual - instanteAnteriorTemperatura) >= INTERVALO_ENTRE_LECTURAS) {
instanteAnteriorTemperatura = instanteActual;
temperatura = thermocouple.readCelsius();
refrescarLCD = true;
}
temperaturaCalentamientoFinal = (digitalRead(PIN_SELECTOR_TEMPERATURA) ? MAXIMO_CALENTANDO_FINAL_A : MAXIMO_CALENTANDO_FINAL_B);
if (temperaturaCalentamientoFinal != temperaturaCalentamientoFinalAnterior) {
temperaturaCalentamientoFinalAnterior = temperaturaCalentamientoFinal;
refrescarLCD = true;
refrescarTemperaturaFinal = true;
}
switch (estado) {
case ESTADO_INICIAL :
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(F("D. Marmo Servicios")); // Mensaje a desplegar
lcd.setCursor(0, 2);
lcd.print(F(" Secadora Do 6 ")); // Mensaje 2 a desplegar
refrescarLCD = false;
instanteAnterior = instanteActual;
estado = ESTADO_PRESENTACION;
break;
case ESTADO_PRESENTACION :
refrescarLCD = false;
if ((instanteActual - instanteAnterior) >= 3000UL) {
digitalWrite(PIN_RELE_VENTILADOR, VALOR_RELE_ACTIVADO);
digitalWrite(PIN_RELE_CALENTADOR, VALOR_RELE_ACTIVADO);
lcd.clear();
if (CANTIDAD_CICLOS == 0) {
estado = ESTADO_CALENTANDO_FINAL;
lcd.setCursor(0, 3);
}
else {
ciclo = 1;
estado = ESTADO_CALENTANDO;
lcd.setCursor(1, 2);
lcd.print(MAXIMO_CALENTANDO);
lcd.write(223);
lcd.print('/');
lcd.print(MINIMO_ENFRIANDO);
lcd.write(223);
lcd.setCursor(14, 1);
lcd.print(MAXIMO_CALENTANDO);
lcd.write(223);
lcd.setCursor(0, 2);
}
lcd.write(0);
lcd.setCursor(1, 3);
lcd.print(temperaturaCalentamientoFinal);
lcd.write(223);
lcd.print('/');
lcd.print(MINIMO_ENFRIANDO_FINAL);
lcd.write(223);
refrescarLCD = true;
}
break;
case ESTADO_CALENTANDO :
if (temperatura >= MAXIMO_CALENTANDO) {
digitalWrite(PIN_RELE_CALENTADOR, VALOR_RELE_APAGADO);
estado = ESTADO_ENFRIANDO;
lcd.setCursor(0, 2);
lcd.write(' ');
lcd.setCursor(8, 2);
lcd.write(1);
lcd.setCursor(14, 1);
lcd.print(MINIMO_ENFRIANDO);
lcd.write(223);
}
break;
case ESTADO_ENFRIANDO :
if (temperatura <= MINIMO_ENFRIANDO) {
digitalWrite(PIN_RELE_CALENTADOR, VALOR_RELE_ACTIVADO);
if (ciclo >= CANTIDAD_CICLOS) {
estado = ESTADO_CALENTANDO_FINAL;
lcd.setCursor(2, 1);
lcd.print(F(" "));
lcd.setCursor(0, 3);
}
else {
ciclo++;
estado = ESTADO_CALENTANDO;
lcd.setCursor(14, 1);
lcd.print(MAXIMO_CALENTANDO);
lcd.write(223);
lcd.setCursor(0, 2);
}
lcd.write(0);
lcd.setCursor(8, 2);
lcd.write(' ');
}
break;
case ESTADO_CALENTANDO_FINAL :
if (temperatura >= temperaturaCalentamientoFinal) {
digitalWrite(PIN_RELE_CALENTADOR, VALOR_RELE_APAGADO);
estado = ESTADO_ENFRIANDO_FINAL;
lcd.setCursor(0, 3);
lcd.write(' ');
lcd.setCursor(8, 3);
lcd.write(1);
lcd.setCursor(14, 1);
lcd.print(MINIMO_ENFRIANDO_FINAL);
lcd.write(223);
}
break;
case ESTADO_ENFRIANDO_FINAL :
if (temperatura <= MINIMO_ENFRIANDO_FINAL) {
digitalWrite(PIN_RELE_CALENTADOR, VALOR_RELE_APAGADO);
digitalWrite(PIN_RELE_VENTILADOR, VALOR_RELE_APAGADO);
estado = ESTADO_FINAL;
lcd.clear();
lcd.setCursor(3, 2);
lcd.print(F("FIN DE PROCESO"));
refrescarLCD = true;
refrescarTemperaturaFinal = false;
}
case ESTADO_FINAL :
// No hace nada
break;
}
if (refrescarLCD) {
bool mostrarPasos = false;
char subeBaja = ' ';
lcd.setCursor(1, 0);
switch (estado) {
case ESTADO_INICIAL :
case ESTADO_PRESENTACION :
case ESTADO_FINAL :
refrescarTemperaturaFinal = false;
break;
case ESTADO_CALENTANDO :
lcd.print(F("CALENTANDO"));
subeBaja = 0;
mostrarPasos = true;
break;
case ESTADO_ENFRIANDO :
lcd.print(F("ENFRIANDO "));
mostrarPasos = true;
subeBaja = 1;
break;
case ESTADO_CALENTANDO_FINAL :
lcd.print(F("CALENTANDO"));
subeBaja = 0;
lcd.setCursor(14, 1);
lcd.print(temperaturaCalentamientoFinal);
lcd.write(223);
break;
case ESTADO_ENFRIANDO_FINAL :
lcd.print(F("ENFRIANDO "));
subeBaja = 1;
break;
}
if (refrescarTemperaturaFinal) {
lcd.setCursor(1, 3);
lcd.print(temperaturaCalentamientoFinal);
}
if (mostrarPasos) {
lcd.setCursor(3 - (ciclo / 10), 1);
lcd.print(ciclo);
lcd.print('/');
lcd.print(CANTIDAD_CICLOS);
lcd.print('x');
}
// Mostrar temperatura
lcd.setCursor(13, 0);
if ((temperatura < 200) && (temperatura > -99)) {
if ((temperatura < 100) && (temperatura > -10)) {
lcd.write(' ');
}
if ((temperatura < 10) && (temperatura >= 0)) {
lcd.write(' ');
}
lcd.print(temperatura);
}
else {
lcd.print(F(" --.--"));
}
lcd.write(223);
lcd.setCursor(17, 1);
lcd.write(subeBaja);
}
}
La definición y uso de las constantes vccPin, gndPin, gndPinf y vccPinr las «he respetado» porque no tengo claro qué es lo que hacer con ellas. Todo lo demás creo que poco se parece al código que tenías. Pero eso es normal cuando pasas a máquinas de estado
En todo mi código no hay ni un solo for ni while. No quiero decir con esto que no se usen cuando se emplean máquinas de estado. Sí se pueden usar, pero para «cosas puntuales».
El programa no tiene ningún Serial.print() ya que muestra en todo momento en el LCD lo que está haciendo. Muestra algo por el estilo a esto:
CALENTANDO 29.72º
1/2x 39º*
*39º/36º
42º/29º
Indica si se está calentando o enfriando (CALENTANDO en el ejemplo). Arriba a la derecha la temperatura tomada por el sensor (29.72º). Justo debajo la temperatura que se quiere alcanzar (39º). El asterisco de al lado no es realmente un asterisco, es un carácter animado según se esté calentando o enfriando, pero eso sólo se puede ver en el LCD. El 1/2 indica que está en ciclo uno de dos. El 39º/36º son las temperaturas a la que se ha de calentar y enfriar en cada ciclo. El asterisco al lado del 39º es el carácter animado que indica que es esa la temperatura que se está tratando de alcanzar actualmente. Y por último el 42º/29º son las temperaturas a las que se ha de dar el último calentón y a la que se ha de dejar enfriar para apagar el ventilador. Pero todo esto se ve mejor en el LCD con el programa funcionando.
Si la lectura de la temperatura registrada por el sensor es superior o igual a los 200º, inferior o igual a -99º o da un NaN (no es un número) por algún error, se muestra --.--º como lectura de la temperatura.
En principio lo que has de ajustar según tus necesidades son las constantes:
const byte CANTIDAD_CICLOS = 2; // Cantidad de ciclos intermedios que se quiere
const int MAXIMO_CALENTANDO = 39.0; // Temperatura hasta que se ha de calentar en los ciclos intermedios
const int MINIMO_ENFRIANDO = 36.0; // Temperatura hasta que se ha de enfriar en los ciclos intermedios
const int MAXIMO_CALENTANDO_FINAL_A = 40.0; // Temperatura hasta que se ha de calentar al final (opción A)
const int MAXIMO_CALENTANDO_FINAL_B = 42.0; // Temperatura hasta que se ha de calentar al final (opción B)
const int MINIMO_ENFRIANDO_FINAL = 29.0; // Temperatura hasta que se ha de enfriar para apagar el ventilador
const unsigned long INTERVALO_ENTRE_LECTURAS = 2500UL; // Milisegundos que han de transcurrir entre cada lectura de la temperatura
const bool FLECHAS = true; // Cambia las "animaciones" dependiedo de si se define true o false
-
CANTIDAD_CICLOSdetermina el número de veces que se han de alcanzar la temperatura máxima y mínima de los ciclos antes de pasar a alcanzar la temperatura máxima final. Puede ser cualquier valor entre cero y 99. Si es cero, no aparecerá en el LCD ni el número de ciclos ni los valores de las temperaturas máxima y mínima de los ciclos. Tan sólo aparecerá la temperatura máxima final y la temperatura mínima a la que se ha de apagar. -
MAXIMO_CALENTANDOes la temperatura máxima que se ha de alcanzar en los ciclos al calentar. -
MINIMO_ENFRIANDOes la temperatura mínima que se ha de alcanzar en los ciclos en el enfriado. -
MAXIMO_CALENTANDO_FINAL_AyMAXIMO_CALENTANDO_FINAL_Bson las dos temperaturas que se pueden seleccionar con el conmutador a la que ha de llegar en el calentamiento final. -
MINIMO_ENFRIANDO_FINALes la temperatura a la que se ha de llegar para finalizar el proceso y apagar el ventilador en el enfriamiento final. -
INTERVALO_ENTRE_LECTURASindica cada cuántos milisegundos se ha de tomar una muestra de temperatura. Es aconsejable ponerle el sufijo UL a ese número, para indicarle al compilador que esunsigned longporque por defecto trata los literales numéricos comointy nos podríamos llevar una sorpresa si la cantidad de milisegundos fuera mayor a 65535. Supongo que no será este el caso, pero es bueno acostumbrarse a ponerlo. -
FLECHASlos caracteres animados que indican si se está calentando o enfriando serán otros dependiendo de si se indica untrueo unfalseen la definición de esta constante. Prueba a cambiar el valor y ya me dirás si finalmente has dejado las flechas o has preferido «los otros». Siempre podrás cambiar el código y definir otras animaciones. Lo que está puesto a fuego que son 4 los «pasos» de cada animación.
Lo creas o no, esta es la versión «rápida» y sin muchas florituras (aunque algunas hay). Creo que la versión «buena» debería de permitir que se pudieran configurar las temperaturas desde el mismo Arduino, sin tener que estar modificando, compilando y cargando el programa al Arduino cada vez que vas a cambiar las temperaturas. Yo quitaría el conmutador que tienes para seleccionar entre las dos temperaturas máximas finales y le pondría tres pulsadores. Uno para incrementar el valor de cada temperatura, otro para decrementar y un tercero para «avanzar» a la siguiente temperatura. No hace falta más, ni tan siquiera para «volver» a la anterior. Bastaría con pulsar varias veces hasta «pasar» por todas y «volver» a la primera cíclicamente. Pero si se quiere se pueden poner más pulsadores con más funcionalidades. Quien dice que son para configurar las temperaturas, también sirven para cambiar el número de ciclos a realizar. Así como para indicar que empiece el proceso una vez configurado o que lo interrumpa por si se quiere empezar de nuevo o cambiar algún parámetro. Y ya, para hacerlo más cómodo aún, que pueda guardar en la EEPROM al menos los últimos valores configurados para tenerlos ya al encender el Arduino. Aunque yo no me quedaría ahí, sino que también se puedan guardar varias configuraciones distintas en la EEPROM.
Una cosa que el programa no tiene en cuenta es qué hacer si hay un error de lectura de la temperatura. Esta versión tan sólo muestra --.--º en la esquina superior derecha. Creo que tal vez debería de al menos apagar el calentador en el caso de que estuviera calentando. El ventilador no creo que haga falta pararlo. Y en el caso de volver a recuperar el valor de la temperatura, entonces continuar con lo que estaba haciendo y encender el calentador sólo si tiene que calentar.
Otra posible mejora creo que sería el añadir otro sensor para obtener la temperatura ambiente. Ya que creo recordar que dijiste que la temperatura a la que ha de finalizar todo el proceso ha de ser unos ocho grados por encima de la temperatura ambiente. En tal caso no haría falta configurarla para nada. Tal vez, en su lugar, poder configurar si son ocho u otro valor los grados por encima de la temperatura ambiente a la que se ha de terminar el proceso. Eso sí, el sensor ha de estar en un lugar adecuado para tomar lo que se ve a considerar «temperatura ambiente».
Pido perdón por tan extensa respuesta… Y aún así creo que me dejo cosas sin comentar. Además de por no haber comentado mucho el código. Pero no puedo dedicarle tanto tiempo como quisiera y tengo ganas de saber si te va bien.
Cualquier duda, pregunta, sugerencia, queja, crítica, idea, consejo, desvarío, consideración, alternativa, lamento o lo que sea: será bienvenida 
.