Hola, tengo un archivo correspondiente a un controlador de un acuario de 500 litros.
Ha estado funcionando durante años (5 o 6) sin problema.
Hace unos días he visto que el reloj estaba desconfigurado, por lo cual los diferentes mecanismos que controlan el acuario estaban desfasados.
Al intentar volver a compilar y subir me sale una hora extraña (89:189:00) y probé en cambiar la tarjeta mega, cambie el reloj, cambie de tft, testee los relay que son ocho y están bien y sigue con el problema porque cuando quieres volver a subir cuando termina se queda parpadeando.
subo un video? o subo el código
Su publicacion se MUEVE a su ubicacion actual ya que es mas adecuada.
Hola UKHeliBob disculpa el ERROR me equivoque al poner el verdadero problema que es este:
`Hola, tengo un archivo correspondiente a un controlador de un acuario de 500 litros.
Ha estado funcionando durante años (5 o 6) sin problema.
Hace unos días he visto que el reloj estaba desconfigurado, por lo cual los diferentes mecanismos que controlan el acuario estaban desfasados.
Al intentar volver a compilar y subir me sale una hora extraña (89:189:00) y probé en cambiar la tarjeta mega, cambie el reloj, cambie de tft, testee los relay que son ocho y están bien y sigue con el problema porque cuando quieres volver a subir cuando termina se queda parpadeando. Cita
Conviene que subas el código.
Ten en cuenta que si el código tiene 5 o 6 años hay posibilidades de que hayan cambiado las librerías, por decir lo menos.
Se me ocurre que tal vez te convenga compilarlo con una versión de la IDE de aquellos años.
Saludos
Saludos Gatul gracias por esos datos lo mas seguro que tengas mucha razón.
aquí el código
// Controlador de Acuario. Controla un filtro Externo biológico de 2000 litros/hora instalado en debajo del acuario,
// que lleva intercalado en la salida un filtro ultravioleta, un Solenoide (electroimán) que abre una válvula de
// CO2, una Electro Bomba de agua que funciona introduciendo agua filtrada cada 2 horas, dos bombas peristálticas
// que administran fertilizante 4 veces al día, un calentador del agua bajo la grava, un par de ventiladores de PC para
// mantener la temperatura de la cabina donde está instalado el Arduino y el resto de componentes, una salida de 12v
// para encender manualmente dos ventiladores pequeños que enfrían el agua cuando la temperatura supera los 26 grados.
// La mayoría de los mecanismos llevan en el frente del gabinete interruptores (7) para apagar manualmente c/mecanismo.
// Los componentes del circuito son : Arduino Mega, RTC DS3231, Display TFT de 2,5', Una fuente de alimentación
// de 12v DC 30A (Externa, alimenta además un sistema Arduino -independiente- de iluminación del acuario), 5 Relés optoacoplados,
// 3 Mosfet IRF520, 2 Reductores de voltaje, uno a 5v DC para la alimentación Relés y Mosfet, otro a 7v DC para alimentar
// al Arduino Mega, un transformador 220v AC a 24v DC para la Electrobomba de agua.
// Los Relés tienen lógica inversa, en HIGH o 1 están apagados, en LOW o 0 están encendidos.
// Todos los circuitos están colocados dentro de un gabinete que lleva en el frente el display y los 7 interruptores.
// El esquema del circuito en: https://imgur.com/4vogAEZ y Fotos en:https://imgur.com/5lHIXwC https://imgur.com/XxmBI3Q
// https://imgur.com/mCTAdXp https://imgur.com/I0X5K1V https://imgur.com/zHrl1yT
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <TFT_HX8357.h>
#include <SoftwareSerial.h>
#include "RTClib.h"
#include <TimeLib.h>
#include <Wire.h>
#include <OneWire.h>
#include <DS18B20.h>
TFT_HX8357 tft = TFT_HX8357();
SoftwareSerial mySerial(18, 19);
uint16_t startAddr = 0x0000;
uint16_t lastAddr;
uint16_t TimeIsSet = 0xaa55;
const byte ONEWIRE_PIN = 2; const byte SENSORS_NUM = 2;
const byte sensorsAddress[SENSORS_NUM][8] PROGMEM =
{0x28, 0xFF, 0x7C, 0x3B, 0xB5, 0x16, 0x5, 0x28,
0x28, 0xFF, 0x28, 0x13, 0x47, 0x16, 0x3, 0xD1};
OneWire onewire(ONEWIRE_PIN); DS18B20 sensors(&onewire);
const byte Filtro2000 = 12, EnfriadoresAgua = 11, SolenoideCO2 = 10, Ventiladores = 9;
const byte FiltroUV = 8, ElectroBomba = 7, Peristalticas = 6, Pin_Calentador = 5;
const byte InterruptorFiltro2000 = 54, InterruptorEnfriadoresAgua = 55, InterruptorCO2 = 56, InterruptorVentiladores = 57;
const byte InterruptorFiltroUV = 58, InterruptorBombaAgua = 59, InterruptorPeristalticas = 60, InterruptorCalentador = 61;
bool CircuitoFrio = 0, Temp_Agua_Normal = 1, ActivarRelojManual = false, Es_RelojManual = true;
float TCircuitos = 0, TAgua = 0;
const float Umbral_Inf_Vent = 26.00, Umbral_Sup_Vent = 30.00; //Enciende ventiladores cuando llega a 30º y apaga al llegar a 26º
int Umbral_Inf_Agua = 24, Umbral_Sup_Agua = 25; //Enciende el calentador cuando baja de 24º y apaga a los 25º
unsigned long MillisPrevias1, MillisPrevias2, MillisPrevias3, MillisPrevias4, MillisPrevias5;
unsigned long MillisPrevias6, MillisPrevias7, MillisPrevias8, MillisPrevias9;
int xFiltro2000, xEnfriadores, xSolenoide, xCalentadores, xFiltroUV, xElectroBomba, xPeristalticas;
int EstadoSwitch2000, EstadoSwitchEnfriadoresAgua, EstadoSwitchUV, EstadoSwitchCO2, EstadoSwitchBombaAgua, EstadoSwitchPeristalticas, EstadoSwitchCalentador;
RTC_DS3231 rtc;
byte Hora, Minutos, Segundos, Avance = 14, AnchoBarra = 7, AltoBarra = 20;
//···············Definición de colores, más en http://www.barth-dev.de/online/rgb565-color-picker/······················
#define NEGRO 0x0000
#define BLANCO 0xFFFF
#define ROJO 0xF800
#define VERDE 0x07E0
#define CYAN 0x07FF
#define VIOLETA 0xFCFD
#define AZUL 0x000F
#define AMARILLO 0xF7A0
#define CELESTE 0x028A
//···················································································································
void setup ()
{
while(!Serial); Serial.begin(115200);
Wire.begin(); sensors.begin(); sensors.request();
mySerial.begin(115200); tft.init(); tft.setRotation(1); tft.fillScreen(AZUL);
if (mySerial.available()) { Serial.write(mySerial.read()); }
if (Serial.available()) { mySerial.write(Serial.read()); }
//rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));//Descomentar para poner la hora del compilador
MillisPrevias1 = MillisPrevias2 = MillisPrevias3 = MillisPrevias4 = MillisPrevias5 = millis();
MillisPrevias6 = MillisPrevias7 = MillisPrevias8 = MillisPrevias9 = millis();
xFiltro2000 = xEnfriadores = xSolenoide = xCalentadores = xFiltroUV = xElectroBomba = xPeristalticas = 343;
for (int x = 5; x < 13; x++) { pinMode(x, OUTPUT); digitalWrite(x, 1); }
pinMode(13,OUTPUT); digitalWrite(13, 0);
for (int x = 54; x < 62; x++) { pinMode(x, INPUT); digitalWrite(x, 0); }
MenuPrincipal();
}
//············································································································
void loop () {}
//············································································································
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
ControlFiltro2000(); //Controla el Relé del Filtro de 2000 L/h (NC)
ControlEnfriadoresAgua(); //Controla el Relé de los enfriadores (NC)
ControlUV(); //Controla el Relé del Filtro Ultravioleta (NA)
ControlCO2(); //Controla el Relé del Solenoide de CO2 (NA)
ControlVentiladores(); //Controla el Mosfet que activa los ventiladores de la cabina de circuitos
ControlBombaAgua(); //Controla el transformador de 220v a 24v de la Bomba de Agua (NA)
ControlPeristalticas(); //Controla el Mosfet que activa las bombas peristálticas de 12v DC
ControlCalentador(); //Controla el Relé que apaga el calentador (NC)
}
}
//············································································································
void Interruptores() //Chequea el estado de los interruptores, Cero es ON, Uno es OFF
{
EstadoSwitch2000 = digitalRead(InterruptorFiltro2000);
EstadoSwitchEnfriadoresAgua = digitalRead(InterruptorEnfriadoresAgua);
EstadoSwitchUV = digitalRead(InterruptorFiltroUV);
EstadoSwitchCO2 = digitalRead(InterruptorCO2);
EstadoSwitchBombaAgua = digitalRead(InterruptorBombaAgua);
EstadoSwitchPeristalticas = digitalRead(InterruptorPeristalticas);
EstadoSwitchCalentador = digitalRead(InterruptorCalentador);
PuertoSerie();//Muestra un informe de estado por el Puerto Serial
}
//············································································································
void ControlFiltro2000() //Relé NC, Interruptor NA
{
if(EstadoSwitch2000 == 0) //Si el intrruptor del filtro grande está en ON
{
digitalWrite (Filtro2000, 1); //Lógica inversa, apagado (Rele NC) Filtro Funcionando
if (millis() - MillisPrevias1 >= 260)
{
MillisPrevias1 = millis();
tft.fillRect(xFiltro2000,45,AnchoBarra,AltoBarra,ROJO); //Barritas verticales
xFiltro2000 = xFiltro2000 + Avance; //Avanza 16 píxeles
if (xFiltro2000 > 477) //Si llegaron las barritas al final
{
tft.fillRect(343,40,135,25,AZUL); //Borra la línea de Barras rojas
xFiltro2000 = 343; //Reinicia la x inicial
}
}
}
else
{
tft.fillRect(343,40,135,25,AZUL); //Borra la línea de Barras
digitalWrite(Filtro2000, 0); //Interruptor cerrado (etiqueta en OFF), encendido Relé, apagado el Filtro (NC)
xFiltro2000 = 343; //Reinicia la x inicial
}
}
//············································································································
void ControlEnfriadoresAgua() //Relé NA, Interruptor NA
{
if (EstadoSwitchEnfriadoresAgua == 0) //El interruptor de los ventiladores del Agua está en ON
{
digitalWrite (EnfriadoresAgua, 0); //lógica inversa, encendido (Rele NA) Ventiladores del agua funcionando
if (millis() - MillisPrevias2 >= 280)//millis diferentes (Se desfasan las barras de progresión de los otros mecanismos)
{
MillisPrevias2 = millis();
tft.fillRect(xEnfriadores,76,AnchoBarra,AltoBarra,ROJO); //Barritas de progresión
xEnfriadores = xEnfriadores + Avance; //Avanza 16 píxeles
if (xEnfriadores > 477) //Llegaron al margen derecho
{
tft.fillRect(343,71,135,25,AZUL); //Borra la línea de Barras rojas
xEnfriadores = 343; //coordenada x inicial para las barras de progresión
}
}
}
else
{
tft.fillRect(343,71,135,25,AZUL); //Borra la línea de Barras
digitalWrite (EnfriadoresAgua, 1); //Interruptor cerrado (etiqueta en OFF), apagado Relé, apagados los Ventiladores del Agua (NC)
xEnfriadores = 343; //coordenada x inicial para las barras de progresión
}
}
//···············································································································
void ControlUV() //Relé NA, Interruptor NA
{
if (((Hora > 15 && Hora <= 17) || (Hora > 21 && Hora <= 23) || (Hora > 3 && Hora <= 5) || (Hora > 7 && Hora <= 9)) && EstadoSwitchUV == 0 && EstadoSwitch2000 == 0)
{
digitalWrite(FiltroUV, 0);//Encendido
if (millis() - MillisPrevias3 >= 300)
{
MillisPrevias3 = millis();
tft.fillRect(xFiltroUV,231,AnchoBarra,AltoBarra,ROJO); //Barritas verticales
xFiltroUV = xFiltroUV + Avance; //Avanza 16 píxeles
if (xFiltroUV > 477)
{
tft.fillRect(343,226,135,25,AZUL); //Borra la línea de Barras
xFiltroUV = 343;
tft.fillRect(343,231,AnchoBarra,AltoBarra,ROJO);
}
}
}
else
{
tft.fillRect(343,226,135,25,AZUL); //Borra la línea de Barras
digitalWrite(FiltroUV, 1); //Apaga el filtro UV
xFiltroUV = 343;
}
}
//············································································································
void ControlCO2() //Relé NA, Interruptor NA
{
if (((Hora >= 10 && Hora < 20)) && EstadoSwitchCO2 == 0 && EstadoSwitch2000 ==0)//Hora de encender el CO2, Interr en ON
{
digitalWrite(SolenoideCO2, 0); //Solenoide Encendido (Relé NA)
if (millis() - MillisPrevias4 >= 320)
{
MillisPrevias4 = millis();
tft.fillRect(xSolenoide,200,AnchoBarra,AltoBarra,ROJO); //Barritas verticales
xSolenoide = xSolenoide + Avance; //Avanza 16 píxeles
if (xSolenoide > 477)
{
tft.fillRect(343,200,135,20,AZUL); //Borra la línea de Barras
xSolenoide = 343;
tft.fillRect(343,200,AnchoBarra,AltoBarra,ROJO);
}
}
}
else
{
tft.fillRect(343,200,135,20,AZUL); //Borra la línea de Barras
digitalWrite(SolenoideCO2, 1); //Solenoide desconectado
xSolenoide = 343;
}
}
//············································································································
void ControlVentiladores()//Controla los Ventiladores de la cabina de circuitos (NO LOS ENFRIADORES DEL AGUA)
{
if (millis() - MillisPrevias5 >= 500)
{
MillisPrevias5 = millis();
if (sensors.available()) { sensors.request(); }
TCircuitos = sensors.readTemperature(FA(sensorsAddress[0]));
if (TCircuitos > 50 || TCircuitos < 10) {TCircuitos = 0;}
if (CircuitoFrio == 0 && TCircuitos >= Umbral_Sup_Vent) // >= 30
{ CircuitoFrio = 1; digitalWrite (Ventiladores, 0); } // Encender ventiladores
if (CircuitoFrio == 1 && TCircuitos <= Umbral_Inf_Vent) // <= 26
{ CircuitoFrio = 0; digitalWrite (Ventiladores, 1); } // Apagar ventiladores
if (CircuitoFrio == 0 && TCircuitos <= Umbral_Inf_Vent)
{ digitalWrite (Ventiladores, 1); }
if (CircuitoFrio == 1 && TCircuitos >= Umbral_Inf_Vent)
{ digitalWrite (Ventiladores, 0); }
tft.setTextSize(3);
if (TCircuitos > 50 || TCircuitos == 0) {tft.setTextColor(ROJO, AZUL);}
else {tft.setTextColor(VERDE, AZUL);}
tft.setCursor(350,134); tft.print(TCircuitos); tft.fillRect(440,134,38,AltoBarra,AZUL);
tft.drawLine(478,2,478,478,CELESTE); tft.drawLine(478,3,478,478,CELESTE);//línea vertical 34
}
}
//···············································································································
void ControlCalentador() //Controlado con Relé NC y un Interruptor externo normalmente en "ON" (EstadoSwitchCalentador == 0)
{
if (millis() - MillisPrevias9 >= 400)
{
BarrasCalentador(); //Dibuja barras de progresión cuando el calentador está en funcionamiento
MillisPrevias9 = millis();
if (sensors.available()) { sensors.request(); }
TAgua = sensors.readTemperature(FA(sensorsAddress[1]));
if (EstadoSwitchCalentador == 0)
{
if (Temp_Agua_Normal == 0 && TAgua < Umbral_Inf_Agua) //Temperatura del agua menor de 24º
{ Temp_Agua_Normal = 1; digitalWrite(Pin_Calentador, 1); } //Calentador encendido, Relé apagado
if (Temp_Agua_Normal == 1 && TAgua < Umbral_Sup_Agua) //Temperatura del agua menor de 25º
{ digitalWrite(Pin_Calentador, 1); } //Calentador encendido, Relé apagado
if (Temp_Agua_Normal == 1 && TAgua >= Umbral_Sup_Agua) //Temperatura del agua llega a 26.00º
{ Temp_Agua_Normal = 0; digitalWrite(Pin_Calentador, 0); } //Calentador apagado, Relé encendido
}
else
{ digitalWrite(Pin_Calentador, 0); } //Calentador manualmente apagado, Relé encendido
tft.setTextSize(3);
if (TAgua > 26 || TAgua == 0) {tft.setTextColor(ROJO, AZUL);}
else {tft.setTextColor(VERDE, AZUL);}
tft.setCursor(350,103); tft.print(TAgua); tft.fillRect(440,103,38,AltoBarra,AZUL);
}
}
//···············································································································
void BarrasCalentador()
{
if (digitalRead(Pin_Calentador) == 1 && EstadoSwitchCalentador == 0) // El pin del Calentador está en alta y el Interruptor en ON
{
if (millis() - MillisPrevias6 >= 340)
{
MillisPrevias6 = millis();
tft.fillRect(xCalentadores,169,AnchoBarra,AltoBarra,ROJO); //Barritas verticales
xCalentadores = xCalentadores + Avance; //Avanza 16 píxeles
if (xCalentadores > 477)
{
tft.fillRect(343,164,135,25,AZUL); //Borra la línea de Barras
xCalentadores = 343;
tft.fillRect(343,169,AnchoBarra,AltoBarra,ROJO);
}
}
}
else
{
tft.fillRect(343,164,135,25,AZUL); //Borra la línea de Barras
xCalentadores = 343;
}
}
//···············································································································
void ControlBombaAgua()//Relé NA, Interruptor NA, abre la Electro Bomba de agua 12 veces al día, 1 minuto
{
if /*(( Hora % 2 == 0) && Minutos < 1 && EstadoSwitchBombaAgua == 0)//Horas pares, 1 min 12 veces/día, Interruptor en ON*/
( Minutos == 0 && Segundos < 45 && EstadoSwitchBombaAgua == 0)//45 segundos cada hora, Interruptor en ON
{
digitalWrite(ElectroBomba, 0);
if (millis() - MillisPrevias7 >= 360)
{
MillisPrevias7 = millis();
tft.fillRect(xElectroBomba,262,AnchoBarra,AltoBarra,ROJO); //Barritas verticales
xElectroBomba = xElectroBomba + Avance; //Avanza 16 píxeles
if (xElectroBomba > 477)
{
tft.fillRect(343,257,135,25,AZUL); //Borra la linea de Barras
xElectroBomba = 343;
tft.fillRect(343,262,AnchoBarra,AltoBarra,ROJO);
}
}
}
else
{
digitalWrite(ElectroBomba, 1);
tft.fillRect(343,257,135,25,AZUL); //Borra la línea de Barras
xElectroBomba = 343;
}
}
//···············································································································
void ControlPeristalticas() //Bombas Peristálticas de 12v conectadas a Relé NA, Interruptor NA
{
if (((Hora==0||Hora==6||Hora==12||Hora==18) && Minutos==10 && Segundos<15 ) && EstadoSwitchPeristalticas == 0)
{
digitalWrite(Peristalticas, 0);
if (millis() - MillisPrevias7 >= 380)
{
MillisPrevias7 = millis();
tft.fillRect(xPeristalticas,293,AnchoBarra,AltoBarra,ROJO); //Barritas verticales
xPeristalticas = xPeristalticas + Avance; //Avanza 16 píxeles
if (xPeristalticas > 477)
{
tft.fillRect(343,288,135,25,AZUL); //Borra la línea de Barras
xPeristalticas = 343;
tft.fillRect(343,293,AnchoBarra,AltoBarra,ROJO);
}
}
}
else
{
tft.fillRect(343,288,135,25,AZUL); //Borra la línea de Barras
digitalWrite (Peristalticas, 1);
xPeristalticas = 343;
}
}
//···············································································································
void ActualizaElReloj()
{
if (ActivarRelojManual) //Si true carga parámetros de tiempo de acuerdo a un cronómetro de la función RelojManual()
//Se cambia su valor al principio al declarar la variable
{
RelojManual();
}
else //Normalmente utiliza el RTC DS3231
{
DateTime now = rtc.now();
Hora = now.hour();
Minutos = now.minute();
Segundos = now.second();
}
}
//············································································································
void PuertoSerie()//Muestra el estado de los dispositivos por el Puerto Serie cada 5 segundos
{
if (millis() - MillisPrevias8 >= 5000)
{
MillisPrevias8 = millis();
Serial.println("ESTADO DE LOS INTERRUPTORES:");
if (EstadoSwitch2000 == 0){Serial.println("Filtro Grande: ON");}
else{Serial.println("Filtro Grande: OFF");}
if (EstadoSwitchEnfriadoresAgua == 0){Serial.println("Ventiladores para enfriar el Agua: ON");}
else{Serial.println("Ventiladores para enfriar el Agua: OFF");}
if (EstadoSwitchUV == 0){Serial.println("Filtro UV: ON");}
else{Serial.println("Filtro UV: OFF");}
if (EstadoSwitchCO2 == 0){Serial.println("Solenoide de CO2: ON");}
else{Serial.println("Solenoide de CO2: OFF");}
if (EstadoSwitchBombaAgua == 0){Serial.println("Bomba de Agua: ON");}
else{Serial.println("Bomba de Agua: OFF");}
if (EstadoSwitchPeristalticas == 0){Serial.println("Peristálticas: ON");}
else{Serial.println("Peristálicas: OFF");}
if (EstadoSwitchCalentador == 0){Serial.println("Calentador: ON");}
else{Serial.println("Calentador: OFF");}
Serial.println("*****************************");
if (digitalRead(Filtro2000) == 1){Serial.println("Filtro Grande Funcionando");}
else {Serial.println("Filtro Grande Apagado");}
if (digitalRead(EnfriadoresAgua) == 1){Serial.println("Enfriadores del Agua Funcionando");}
else {Serial.println("ENfriadores del Agua Apagados");}
if (digitalRead(FiltroUV) == 0){Serial.println("Filtro UV Funcionando");}
else {Serial.println("Filtro UV Apagado");}
if (digitalRead(SolenoideCO2) == 0){Serial.println("Solenoide de CO2 Funcionando");}
else {Serial.println("Solenoide de CO2 Apagado");}
Serial.print("Temp. de los Circuitos: ");Serial.print(TCircuitos);Serial.println("º");
if (digitalRead(Ventiladores) == 0){Serial.println("Ventiladores Funcionando");}
else {Serial.println("Ventiladores Apagados");}
if (digitalRead(ElectroBomba) == 0){Serial.println("Electro Bomba de Agua Funcionando");}
else {Serial.println("Electro Bomba de Agua Apagada");}
if (digitalRead(Peristalticas) == 0){Serial.println("Bombas Peristálticas Funcionando");}
else {Serial.println("Bombas Peristálticas Apagadas");}
Serial.print("Temperatura del Agua: ");Serial.print(TAgua);Serial.println("º");
Serial.print("Variable EstadoSwitchCalentador: "); Serial.println(EstadoSwitchCalentador);
Serial.print("Variable Temp_Agua_Normal: "); Serial.println(Temp_Agua_Normal);
if (digitalRead(Pin_Calentador) == 1){Serial.println("Calentador Funcionando (hasta 24.99º)");}
else {Serial.println("Calentador Apagado");}
Serial.println("*****************************");
if (Hora < 10) {Serial.print("0");}
Serial.print(Hora);
Serial.print(":");
if (Minutos < 10) {Serial.print("0");}
Serial.print(Minutos);
Serial.print(":");
if (Segundos < 10) {Serial.print("0");}
Serial.println(Segundos);
Serial.println("*****************************");
}
}
//···················································································································
void RelojManual() //"Cronómetro" que reemplaza al RTC para comprobar el funcionamiento de los diferentes mecanismos
{
//ActivarRelojManual=true;
if (Es_RelojManual)
{
Es_RelojManual = false; //Entra una sola vez
Hora = 0, Minutos = 0, Segundos = 0;
}
Segundos++;
if (Segundos == 60)
{
Segundos =0;
Minutos++;
}
if (Minutos == 60)
{
Minutos = 0;
Hora++;
if (Hora == 24)
{
Hora = 0;
Minutos = 0;
Segundos = 0;
}
}
}
//···················································································································
void DibujaRelojDigital()
{
tft.setTextColor(AMARILLO, AZUL); tft.setTextSize(3); tft.setCursor(170,7);
if (Hora < 10) {tft.print("0");}
tft.print(Hora);
tft.print(":");
if (Minutos < 10) {tft.print("0");}
tft.print(Minutos);
tft.print(":");
if (Segundos < 10) {tft.print("0");}
tft.print(Segundos);
}
//··············································································································
void DibujaMenu()
{
tft.fillRect(0,0,480,360,AZUL);
tft.setTextSize(1);
tft.setTextColor(BLANCO, AZUL);
tft.drawString("Filtro Externo 2000 L / h --------",5,40,4);
tft.drawString("Enfriadores para el Agua ------", 5,71,4);
tft.drawString("Temperatura del Agua ----------",5,102,4);
tft.drawString("Temperatura de Circuitos -----",5,133,4);
tft.drawString("Calentador del Agua ------------",5,164,4);
tft.drawString("Solenoide de CO2 ---------------",5,195,4);
tft.drawString("Filtro Ultravioleta -----------------",5,226,4);
tft.drawString("Electrobomba de Agua --------",5,257,4);
tft.drawString("Bombas Peristalticas -----------",5,288,4);
for (int x = 35; x < 480; x = x + 31)
{ tft.drawLine(1,x,479,x,CELESTE); }//Cuadrícula roja
tft.drawRect(0,0,479,320,CELESTE);//x, y, ancho, alto, Rojo
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
[/code]
En una primera mirada, si usas una Mega (que tiene 4 puertos serie hardware) no uses SoftwareSerial, no tiene sentido y, de hecho, es un despropósito.
Afortunadamente tu placa es Mega porque si fuese un Due esto
while(!Serial); Serial.begin(115200);
impediría que tu programa inicie porque consultas el estado del puerto antes de inicializarlo.
Por suerte Serial() siempre devuelve true en los Uno / Nano / Mega.
Lo correcto es que primero la inicies y luego esperes a que se complete la inicialización. De todos modos, en Mega es innecesario, solo se inicia con begin() y listo.
Sigo mirando a ver que más encuentro pero te adelanto que hay muchas cosas que se podrían mejorar.
Por ejemplo, en lugar de
if (EstadoSwitch2000 == 0) {
Serial.println("Filtro Grande: ON");
}
else {
Serial.println("Filtro Grande: OFF");
}
haría
Serial.print("Filtro Grande: ");
if (EstadoSwitch2000 == 0) {
Serial.println("ON");
}
else {
Serial.println("OFF");
}
Se puede abreviar pero por claridad lo dejo así.
primero que nada agradecerte gatul por lo que estas haciendo, y es verdad que seguro que sera mejorable porque esto fue creado con muy pocos conocimientos y 0 en base de programación. pero es eso de querer es poder y una vez mas Gracias y si se puede mejorar que mejor para toda la familia Arduino XD
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.