Simplificar el código con una función pero no lo logro

Hola a todos.
Tengo funionando un Arduino Mega en un gabinete con un display para controlar 7 mecanismos de un acuario.





LLeva ya bastante tiempo funcionando sin problemas, hay una función para cada uno de los mecanismos, que cuando cada uno de ellos está funcionando muestra unas barritas de progresión, y como básicamente se repiten los mismos pasos en cada función, intento crear una que recibiendo un par de parámetros dibuje en el display las barras de progresión, pero llevo varios días intentando y no lo logro, pongo el sketch que está actualmente funcionando y luego a continuación el sketch en el que intento simplificar con la función “DibujaBarras()”. El segundo Sketch en el que llevo varios días trabajando tiene más comentarios que en el primero.

La imagen en el display de las barras de progresión básicamente consiste en comenzar a dibujar pequeños rectángulos verticales, comenzando siempre en la misma coordenada X, para ir “avanzando” al dibujar nuevos rectángulos hasta llegar al margen derecho del display, borrando luego las barritas para recomenzar.

)
Como la coordenada inicial es siempre la misma para cualquier mecanismo (en este caso el píxel 343) la función solo tiene que recibir dos datos, el primero con el nombre del mecanismo o lo que es lo mismo la coordenada Y, y el segundo con los cambios progresivos en la coordenada X. Al final de la función, según el mecanismo, se actualiza el valor de la coordenada X de cada uno de ellos.

Como la longitud exceden el límites de caracteres para poder postearlo, pongo ambos como archivos adjuntos.

Controlador_de_Acuario.ino (21.3 KB)

Prueba_Controlador_Acuario.ino (19.8 KB)

Y caules son las lineas que hay que simplificar?

Hola Surbyte, pues dentro de las funciones que controlan cada mecanismo, hay un if (MillisPreviasX >=…) a partir del cual se dibujan en el display las barras de progresión.
El tema es crear una función que recibiendo las coordenadas X e un Y dibuje las barras de progresión de cada mecanismo.
En el primer sketch se observan dentro de cada uno de las 7 funciones que controlan los mecanismos, en el segundo sketch casi al final del sketch está la función DibujaBarras() que es la que no funciona, solo dibuja la primera barra del primer dispositivo y ahí se queda.

Bueno ahora veo tu DibujaBarras en el nuevo código y empieza con un error

void DibujaBarras(char Dispositivo, int Xinicial)  

if (Dispositivo == "Filtro200")  {

me remito a lo que quiero explicar.
Defines como parámetro un char o sea que Dispositivo se carga con "F" y no con "Filtro200"

Y aunque lo definieras bien, jamas puedes comparar un array de chars como lo has hecho.
Eso si es posible con String.
void DibujaBarras(String Dispositivo, int Xinicial)
asi que comienza con ese cambio.

Puedes ganar en claridad y velocidad si evaluas un numero en vez de char o string usando switch:

#define Filtro200 1
#define Filtro700 2
#define FiltroUV  3
// ...................todos los demas

// luego substituyes por switch ,mas claro que if ,if-else

void DibujaBarras(int Dispositivo, int Xinicial)                  //Dibuja barras de progresión de dispositivos activos
{
  switch (Dispositivo) {
  case  Filtro200 :
    // statements
    break;
  case Filtro700 :
    // statements
    break;
  case FiltroUV :
    // statements
    break;
  default:
    // statements
    break;
  }
}

// lamada a funcion:
DibujaBarras(Filtro700,xFiltro700);

Gracias jose por tus comentarios, llegado el caso lo probaré, lo de utilizar #define me obligaría a cambiar los nombres de muchas variables en las cuales están incluidos los nombres de cada mecanismo como EstadoFiltro700, InterruptorFiltro700, ControlFiltro700, pero bueno, igualmente podría utilizar un número para identificar cada mecanismo.

He modificado la función utilizando string y sigue sin funcionar, solo dibuja la primera barrita y ahí se queda.
La función ahora mismo es esta:

void DibujaBarras(String Dispositivo, int Xinicial)                  //Dibuja barras de progresión de dispositivos activos
{
  int CoordenadaX, CoordenadaY;
  if (Dispositivo == "Filtro2000")
    {   
      if (millis() - MillisPrevias1 >= 200)//millis diferentes (Se desfasan las barras de progresión de los otros mecanismos)
          { MillisPrevias1 = millis();  CoordenadaX = Xinicial; CoordenadaY = 50; }
    }
  else if   (Dispositivo == "Filtro700")    
    {
      if (millis() - MillisPrevias2 >= 220)//millis diferentes (Se desfasan las barras de progresión de los otros mecanismos)
        { MillisPrevias2 = millis();  CoordenadaX = Xinicial; CoordenadaY = 81; }  
    }
  else if   (Dispositivo == "FiltroUV")    
    {
      if (millis() - MillisPrevias3 >= 240)
        { MillisPrevias3 = millis();  CoordenadaX = Xinicial; CoordenadaY = 236;  }
    }
  else if   (Dispositivo == "SolenoideCO2")    
    {
      if (millis() - MillisPrevias4 >= 260)
        { MillisPrevias4 = millis();  CoordenadaX = Xinicial; CoordenadaY = 205;  }   
    }
  else if   (Dispositivo == "Ventiladores")    
    {
      if (millis() - MillisPrevias6 >= 280)
          { MillisPrevias6 = millis();  CoordenadaX = Xinicial; CoordenadaY = 174;  }
    }
  else if   (Dispositivo == "ElectroBomba")    
    {
      if (millis() - MillisPrevias7 >= 300)
        { MillisPrevias7 = millis();  CoordenadaX = Xinicial; CoordenadaY = 267;  }
    }
  else if   (Dispositivo == "Peristalticas")    
    {
      if (millis() - MillisPrevias8 >= 320)
        { MillisPrevias8 = millis();  CoordenadaX = Xinicial; CoordenadaY = 298;  }
    }
  tft.fillRect(CoordenadaX,CoordenadaY,10,15,ROJO);  //Barritas verticales
  CoordenadaX = CoordenadaX + 16;
  if (CoordenadaX > 477)                    //Si llegaron las barritas al final
    { 
      CoordenadaX = 343;
      tft.fillRect(CoordenadaX,CoordenadaY-10,137,25,AZUL);
      tft.fillRect(CoordenadaX,CoordenadaY,10,15,ROJO);
      tft.drawLine(479,34,479,479,0xC000);//Redibuja el margen derecho
    }
  if      (Dispositivo == "Filtro2000")      { xFiltro2000    = CoordenadaX;  }
  else if (Dispositivo == "Filtro700")       { xFiltro700     = CoordenadaX;  }
  else if (Dispositivo == "FiltroUV")        { xFiltroUV      = CoordenadaX;  }
  else if (Dispositivo == "SolenoideCO2")    { xSolenoide     = CoordenadaX;  }
  else if (Dispositivo == "Ventiladores")    { xVentiladores  = CoordenadaX;  }
  else if (Dispositivo == "ElectroBomba")    { xElectroBomba  = CoordenadaX;  }
  else if (Dispositivo == "Peristalticas")   { xPeristalticas = CoordenadaX;  }
}

y por ejempo una de las funciones que la invoca (son todas básicamente iguales):

void ControlFiltro700()       //Relé NC, Interruptor NA
{
  if (Estado700 == 0) //El interruptor del filtro pequeño está en ON
    {      
      digitalWrite (Filtro700, 1);              //lógica inversa, apagado (Rele NC) Filtro funcionando
      DibujaBarras("Filtro700",xFiltro700);     //Dibuja Barras de progresión
    }
  else
    {
      tft.fillRect(343,71,137,25,AZUL);        //"Borran" las barras de progresión
      digitalWrite (Filtro700, 0);             //Interruptor cerrado (etiqueta en OFF), encendido Relé, apagado el Filtro (NC)
    }
}

La posibilidad de poner un Switch como dice Jose es buena, ya que ni bien encuentre el dispositivo que queres representar ejecuta el código y sale de la función gracias al Break.

Otra cosa que podes hacer es generar una función que se ejecute en el loop, trabajando con flags y una variable que indique el tiempo en que se inicio cada dispositivo.

Declara unsigned long para establecer el tiempo en que cada uno de los dispositivos se inicia

unigned long millis_dispositivo1, millis_dispositivo2, ......

otro unsigned long para determinar la duracion de cada dispositivo

unsigned long dispositivo1_duracionms, dispositivo2_duracionms, ...

y Boolean como flag para saber si estan o no activos.

boolean dispositivo1_encendido, dispositivo 2_encendido, ....

Luego, cada vez que inicias un dispositivo modificas el valor del flag a 1 y cargas en cada variable de los dispositivos el tiempo en que fue encendido.

millis_dispositivo1 = millis();
dispositivo1_encendido = 1;

y generas una función que repase el estado de todos los dispositivos y si estan encendidos que grafiquen una barra proporcional al tiempo que trascurrido. Para hacer esto debes saber que longitud maxima queres utilizar para graficar la barra... vamos a suponer que esta distancia es "long_x".
y tenes establecido el tiempo que durara encendido cada dispositivo... entonces dividís long_x por cada duracion y sabes cuanto tiempo tiene que pasar para llenar un pixel del tft... de esa manera podemos poner esto:

void dibujarbarras(){
int tiempoxpixel;
unsigned long tiempo_transcurrido;
int total_pixel;
if (dispositivo1_encendido == 1){
tiempoxpixel = dispositivo1_duracionms/long_x;
tiempo_transcurrido = millis() - millis_dispositivo1;
total_pixel = tiempo_transcurrido/tiempoxpixel;
tft.fillRect(xDispositivo1,yDispostivo1,total_pixel,15,ROJO);
}
else{
tft.fillRect(xDispositivo1,yDispositivo1,long_x,15,AZUL);
}
if (dispositivo2_encendido == 1){
tiempoxpixel = dispositivo2_duracionms/long_x;
tiempo_transcurrido = millis() - millis_dispositivo2;
total_pixel = tiempo_transcurrido/tiempoxpixel;
tft.fillRect(xDispositivo2,yDispostivo2,total_pixel,15,ROJO);
}
else{
tft.fillRect(xDispositivo2,yDispositivo2,long_x,15,AZUL);
}
.........

Me pude explicar masomenos?

es una idea... el código hay que trabajarlo un poquito y adaptarlo, no serivira un copy paste! :smiley:

Cualquier cosa estoy aqui!

un abrazo!!!!

EDIT: Habria que considerar el hecho de que se resetee el valor de millis()...se tendria que validar esa información... sino puede dar error al graficar algunas de las barras 1 vez cada cierta cantidad de días.

, lo de utilizar #define me obligaría a cambiar los nombres de muchas variables en las cuales están incluidos los nombres de cada mecanismo como EstadoFiltro700, InterruptorFiltro700, ControlFiltro700, pero bueno, igualmente podría utilizar un número para identificar cada mecanismo.

no creo que afecte ,en cualquier caso puedes usar cualquier nombre,de hecho ,se usan mayusculas para constantes:

#define FILTRO200 1
#define FILTRO700 2
#define FILTROUV  3

o tambien

#define Filtro_200 1
#define Filtro_700 2
#define Filtro_UV  3

Creo que además estoy explicando mal el objetivo, esto es un vídeo

Vídeo del display con las barritas de progresión

Algo muy importante no hay Filtro200 sino Filtro2000 asi que no arrastremos mas ese error!!

Te envié privado para que edites el enlace del último post o bien adjuntes y hagas lo mismo para que se visualice la imagen.

Y cual es la razón del desfazaje que tienes en cada uno de los if de DibujaBarras?

Te consulto porque Ningun MillisPrevias, fue inicializado salvo cuando se ejectua esa tarea.

Ahora siguiendo la idea de José porque no pones todo esto en un array o una estructura y simplificas todo usando los ID 1…N que Jose te indicó
Mira que fácil sería.

Esto

  int CoordenadaX, CoordenadaY;
  if (Dispositivo == "Filtro2000") {   
      if (millis() - MillisPrevias1 >= 200) { 
          MillisPrevias1 = millis();  
          CoordenadaX = Xinicial; 
          CoordenadaY = 50; 
      }
  }
  else if (Dispositivo == "Filtro700")    
    {
      if (millis() - MillisPrevias2 >= 220)//millis diferentes (Se desfasan las barras de progresión de los otros mecanismos)
        { MillisPrevias2 = millis();  
          CoordenadaX = Xinicial; 
          CoordenadaY = 81; }  
    }
  else if   (Dispositivo == "FiltroUV")    
    {
      if (millis() - MillisPrevias3 >= 240)
        { MillisPrevias3 = millis();  
          CoordenadaX = Xinicial; 
          CoordenadaY = 236;  }
    }
  else if   (Dispositivo == "SolenoideCO2")    
    {
      if (millis() - MillisPrevias4 >= 260)
        { MillisPrevias4 = millis();  
          CoordenadaX = Xinicial; 
          CoordenadaY = 205;  }   
    }
  else if   (Dispositivo == "Ventiladores")    
    {
      if (millis() - MillisPrevias6 >= 280)
          { MillisPrevias6 = millis();  
            CoordenadaX = Xinicial; 
            CoordenadaY = 174;  }
    }
  else if   (Dispositivo == "ElectroBomba")    
    {
      if (millis() - MillisPrevias7 >= 300)
        { MillisPrevias7 = millis();  
          CoordenadaX = Xinicial; 
          CoordenadaY = 267;  }
    }
  else if   (Dispositivo == "Peristalticas")    
    {
      if (millis() - MillisPrevias8 >= 320)
        { MillisPrevias8 = millis();  
          CoordenadaX = Xinicial; 
          CoordenadaY = 298;  }
    }

pasa a esto

En globales cree una structura que TE ADVIERTO esta empezando a crecer porque veo mucho para cambiar y simplficiar
La estructura y su asignacion de valores que reemplaza a muchas variables

// Definiciones de _jose_
#define FILTRO2000       1
#define FILTRO700       2
#define FILTROUV        3
#define SolenoideCO2    4
#define Ventiladores    5
#define ElectroBomba    6
#define Peristalticas   7
struct _config = {
    int intervalo;
    int coordY;
    unsigned long MillisPrevias;  // variable reservado para guardar millis()
};

_config config[7] = {{200,  50, 0UL},   // Filtro200    - MillisPrevias1
                     {220,  81, 0UL},   // Filtro700    - MillisPrevias2
                     {240, 236, 0UL},   // FiltroUV     - MillisPrevias3
                     {260, 205, 0UL},   // SolenoideCO2 - MillisPrevias4
                     {280, 174, 0UL},   // ventiladores - MillisPrevias5
                     {300, 267, 0UL},   // ElectroBomba - MillisPrevias6 
                     {320, 298, 0UL}    // Peristalticas- MillisPrevias7
};
void DibujaBarras(byte Dispositivo, int Xinicial)                  //Dibuja barras de progresión de dispositivos activos
{
  int CoordenadaX, CoordenadaY;

  if (millis() - config[Dispositivo].MillisPrevias  >= config[Dispositivo].intervalo) { 
      config[Dispositivo].MillisPrevias = millis();  
      CoordenadaX = Xinicial; 
      CoordenadaY = config[Dispositivo].coordY;
  }
  
  tft.fillRect(CoordenadaX,CoordenadaY,10,15,ROJO);  //Barritas verticales
  CoordenadaX = CoordenadaX + 16;
  if (CoordenadaX > 477) {                   //Si llegaron las barritas al final
      CoordenadaX = 343;
      tft.fillRect(CoordenadaX,CoordenadaY-10,137,25,AZUL);
      tft.fillRect(CoordenadaX,CoordenadaY,10,15,ROJO);
      tft.drawLine(479,34,479,479,0xC000);//Redibuja el margen derecho
    }
  switc(Dispositivo) {
      case 1:  xFiltro200     = CoordenadaX;
               break;
      case 2:  xFiltro700     = CoordenadaX;
               break;
      case 3:  xFiltroUV      = CoordenadaX;
               break;
      case 4:  xSolenoide     = CoordenadaX;
               break;
      case 5:  xVentiladores  = CoordenadaX;
               break;
      case 6:  xElectroBomba  = CoordenadaX;
               break;
      case 7:  xPeristalticas = CoordenadaX;
               break;
}

Todo esto puede estar en otras estructuras tmb

const byte Filtro2000 = 12, Filtro700 = 11, SolenoideCO2 = 10, Ventiladores = 9;
const byte FiltroUV = 8, ElectroBomba = 7, Peristalticas = 6, Calentador = 5;
const byte InterruptorFiltro2000 = 54, InterruptorFiltro700 = 55, InterruptorCO2 = 56, InterruptorVentiladores = 57;
const byte InterruptorFiltroUV = 58, InterruptorBombaAgua = 59, InterruptorPeristalticas = 60, InterruptorCalentador = 61;
bool EstadoVentilador = 0, ActivarRelojManual = false, Es_RelojManual = true;
float TCircuitos = 0, TAgua = 0;
const float UmbralInferior = 26,  UmbralSuperior = 30;  //Para ventiladores del gabinete (encienden a 30º y apagan a 26º)

int xFiltro2000 = 343, xFiltro700 = 343, xSolenoide = 343, xVentiladores = 343, xFiltroUV = 343;
int xElectroBomba = 343, xPeristalticas = 343;
int Estado2000, Estado700, EstadoUV, EstadoCO2, EstadoBombaAgua, EstadoPeristalticas, EstadoCalentador;
RTC_DS3231 rtc;

Tal vez algunas no pero la mayoría si.

EDITO: Olvidé cambiar la inicializacion de MillisPrevias en el setup. Borra todos los MillisPreviasX por esto

  for (int i = 0; i<7; i++)
       config[i].MillisPrevias = milllis();

Prueba_Controlador_Acuario.ino (19.5 KB)

Como siempre y ante todo gracias por los consejos.

Surbyte, en la línea struct _config = { me dá un error al compilar (expected unqualified-id before ‘=’ token):

#define FILTRO2000      1
#define FILTRO700       2
#define FILTROUV        3
#define SolenoideCO2    4
#define Ventiladores    5
#define ElectroBomba    6
#define Peristalticas   7

struct _config = {   <<<<EN ESTA LINEA APARECE EL ERROR AL COMPILAR
    int intervalo;
    int coordY;
    unsigned long MillisPrevias;  // variable reservado para guardar millis()
};

_config config[7] = {{200,  50, 0UL},   // Filtro2000   - MillisPrevias1
                     {220,  81, 0UL},   // Filtro700    - MillisPrevias2
                     {240, 236, 0UL},   // FiltroUV     - MillisPrevias3
                     {260, 205, 0UL},   // SolenoideCO2 - MillisPrevias4
                     {280, 174, 0UL},   // ventiladores - MillisPrevias5
                     {300, 267, 0UL},   // ElectroBomba - MillisPrevias6 
                     {320, 298, 0UL}    // Peristalticas- MillisPrevias7
};

Me equivoqué debe ir asi

struct _config {   
    int intervalo;
    int coordY;
    unsigned long MillisPrevias;  // variable reservado para guardar millis()
};

Bien, corregidos los errores de compilación.

Ahora me toca estudiar un poco - mucho para entender los cambios, de manera de poder utilizarlos en futuros proyectos.
Lo mismo experimentar un poco con las otras sugerencias de los compañeros.

Gracias a todos.
Un saludo a todos

Prueba_Controlador_Acuario.ino (19.4 KB)

Empieza por aca estructuras en Arduino

Verás que no es complicado.

Es una forma tipo matriz que permite relacionar varios tipos de variables diferentes, como un todo.
Además le puedes dar la capacidad de armar un vector de estructuras como yo hice.

Asi que

struct _config {   
    int intervalo;
    int coordY;
    unsigned long MillisPrevias;  // variable reservado para guardar millis()
};

La estructura se llama _config, nombre raro no? Pero como lo que quiero usar luego es el nombre config a secas uso el recurso que he aprendido de los buenos programadores con el _ y con eso hablo de dos cosas distintas. Suena complicado pero no lo es.

Solo cuando haces esto

_config config; es que tienes una variable del tipo como se ha definido _config.
si yo hago

_config config[7]; he creado un vector de estructuras.

cada elemento de la estructura se accede via .nombre asi que

config[0].intervalo = 20;

asigna 20 la variable interna intevalo del elemento 0 de la variable config.

Podrias hacerlo con matrices, si, pero no puedes en una matriz mezclar diferentes tipos de variables como puedes hacer con una estructura.

Bueno si tienes mas dudas lee lo de Prometec que estará seguramente mejor que mi explicación.

Continuando con la simplificación del código me encuentro con una incoherencia en lo que tienes escrito.

Mira esto

const byte Filtro2000     = 12, 
           Filtro700      = 11, 
           SolenoideCO2   = 10, 
           Ventiladores   = 9;
const byte FiltroUV       = 8, 
           ElectroBomba   = 7, 
           Peristalticas  = 6, 
           Calentador     = 5;
const byte InterruptorFiltro2000    = 54, 
           InterruptorFiltro700     = 55, 
           InterruptorCO2           = 56, 
           InterruptorVentiladores  = 57;
const byte InterruptorFiltroUV      = 58, 
           InterruptorBombaAgua     = 59, 
           InterruptorPeristalticas = 60, 
           InterruptorCalentador    = 61;

Yo he reubicado las cosas para entenderarlas en contexto y acá apareció un elemento que no tenía antes que es ElectroBomba e InterruptorBombaAgua

O sea un 8vo elemento, que criterio seguimos, lo agrego como un 8vo elemento?

Hola Surbyte, estás en todas, JAJA.

Gracias por la orientación, ya tengo trabajo para varios días, porque supongo que una vez "digerido", tendré más de un programa (y dos y tres...) para mejorar.

Con respecto al pin de la ElectroBomba ya está definido al principio (pin 7, es el que activa el Relé que enciende el solenoide que controla una válvula de agua 5 minutos cada 6 horas -es el equivalente a un río en la naturaleza-) y el pin que lee el estado del solenoide es el 59 que es el InterruptorBombaAgua.

O sea que está incluido, a menos que haya entendido mal tu pregunta (podría muy bien ser así, jeje).

Un saludo desde Tenerife.

Pues ahora si, he comenzado a entrar en el tema de OOP y ya lo arreglo yo mismo, de paso cuando entienda mejor el tema.
De todas formas podemos dar por resuelto el post.

Pero no sabes como habia simplificado más aun tu programa!!

Al menos permiteme darte como he encarado el resto y lo evaluas con tiempo.

Asi estaba quedando la estructura

#define FILTRO2000      1
#define FILTRO700       2
#define FILTROUV        3
#define SolenoideCO2    4
#define Ventiladores    5
#define ElectroBomba    6
#define Peristalticas   7
#define Calentador      8

struct _config = {
    int intervalo;
    int coordY;
    unsigned long MillisPrevias;  // variable reservado para guardar millis()
    byte pin;
    byte interruptor;
    bool estado;
    int x;
};

_config config[8] = {{200,  50, 0UL, 12, 54, false, 343},   // Filtro2000   - MillisPrevias1
                     {220,  81, 0UL, 11, 55, false, 343},   // Filtro700    - MillisPrevias2
                     {240, 236, 0UL,  8, 58, false, 343},   // FiltroUV     - MillisPrevias3
                     {260, 205, 0UL, 10, 56, false, 343},   // SolenoideCO2 - MillisPrevias4
                     {280, 174, 0UL,  9, 57, false, 343},   // ventiladores - MillisPrevias5
                     {300, 267, 0UL,  7, 59, false, 343},   // ElectroBomba - MillisPrevias6 
                     {320, 298, 0UL,  6, 60, false, 343},   // Peristalticas- MillisPrevias7
                     {  0,   0, 0UL,  5, 61, false, 343}    // Calentador
};

Como verás ya absorbe el pin con el que comandas los Relés, a contiinuación, el pin del interruptor, seguido su estado cuando lo leas cosa que haras con un simple for(), las variables x como p.ej xFiltro2000 que pones a 343.

Bueno tu código se reduce muchísmo porque salvo un caso especial en general son tareas mas o menos parecidas con algunos detalles peculiares como ocurre siempre.

Asi cambió Interruptores()

void Interruptores() { //Chequea los 7 interruptores del gabinete normalmente en ON https://imgur.com/5lHIXwC
{                         
  for (byte i= 0; i<7; i++) {
      config[i].estado = digitalRead(config[i].interruptor);
  }
}

y asi iba con tu procedimiento void MenuPrincipal()

//············································································································
void MenuPrincipal(){
  DibujaMenu();
  while(1)  {
      ActualizaElReloj();     //Actualiza el valor de las variables Horas, Minutos y Segundos
      DibujaRelojDigital();   //El reloj digital del Display del frontal de la cabina con los circuitos
      //Interruptores();        //Chequea el estado de los 7 interruptores
      for (byte i= 0; i<7; i++) {
          config[i].estado = digitalRead(config[i].interruptor);
          switch(i) {
              case 1: //Controla el Relé del Filtro de 2000 L/h (NC)     
                      if (config[i].estado == 0) {  //Si el interruptor del filtro grande está en ON  
                          digitalWrite (config[i].pin, HIGH);                //Lógica inversa, apagado (Rele NC) Filtro Funcionando
                          DibujaBarras("Filtro2000",config[i].x);      //Dibuja las Barras de progresión cuando el filtro está funcionando
                      }
                      else  {
                          tft.fillRect(343,40,137,25,AZUL);             //"Borra" las barras de progresión
                          digitalWrite(config[i].pin, LOW);                  //Interruptor cerrado (etiqueta en OFF), encendido Relé, apagado el Filtro (NC)
                      } 
                      break;
              case 2: // Controla el Relé del Filtro de 700 L/h (NC)
                      if (config[i].estado == 0) { //El interruptor del filtro pequeño está en ON
                          digitalWrite (config[i].pin, HIGH);              //lógica inversa, apagado (Rele NC) Filtro funcionando
                          DibujaBarras("Filtro700",config[i].x);     //Dibuja Barras de progresión
                      }
                      else {
                          tft.fillRect(343,71,137,25,AZUL);        //"Borran" las barras de progresión
                          digitalWrite(config[i].pin, LOW);             //Interruptor cerrado (etiqueta en OFF), encendido Relé, apagado el Filtro (NC)
                      }
                      break;
              case 3: // Controla el Relé del Filtro Ultravioleta (NA)    
                      if (((Hora > 12 && Hora < 18) || (Hora > 18 && Hora < 23)) && config[i].estado == 0 && config[FILTRO700].estado == 0) {
                          digitalWrite (config[i].pin, LOW);  // Encendido
                          DibujaBarras("FiltroUV",config[i].x); // Dibuja Barras de progresión
                      }
                      else {
                          digitalWrite(config[i].pin, HIGH);  // Apaga el filtro UV
                          tft.fillRect(343,226,137,25,AZUL);
                      }
                      break;

no esta completo pero seguia intentando eliminar cosas

Uauuu!!
Supongo que te has enganchado al tema :slight_smile: :slight_smile: :slight_smile: :slight_smile: :slight_smile:

He comenzado a leer los artículos de Prometec, y evidentemente se me abre un nuevo capítulo en la programación de Arduino.

Veré hasta dónde podré llegar...

Lo que ocurre es que uno debe primero comprender que estas haciendo y solo pusiste un código y asi descolgado... lleva tiempo entenderlo.
Al principio no se visualiza y de golpe dices, porqué no de este modo y bueno, se abre el abanico y resulta que casi todo puede meterse en la misma bolsa y terminó de ese modo cubriendo todo.

Aun no lo cerré pero te aseguro que la simplificación es fantástica. Si por ejemplo agregaras esas posiciones que luego usas para graficar, sería mas simple aún.