Acuario Norte

 
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Autor Tema: Terrario exterior para Pogona, todo el año?  (Leído 4742 veces)

0 Usuarios y 1 Visitante están viendo este tema.

15-Mayo-2020, 08:05
Respuesta #45
  • Moderador General
  • Veterano
  • *****
  • Mensajes: 2.740

Vaya... no consigo ver donde comienzo el void setup... (Ha de haber void setup???) El void loop lo veo muy claro. Tal vez empieza en el serial? O con el primer void (void LEER_SENSORES)? Pruebo ambas opciones.


EDITO: El sketch literalmente ha explotado  :und:  !. Probado (void LEER_SENSORES) antes y después del voidsetup. Unos 30 errores de aviso, uno por línea de programa, en ambos casos. Entre otros:

-variable or field "LEER_SENSORES" declared void

-error: expected declaration before '}' token (Tantos como líneas, repasados corchetes y no los encuentro...)

-error: "n" does not name a type ("n": Todas las variables)


Hago copia del armaggedon:

Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG Zootecnia Doméstica  04/05/2020  V.1                    //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido


#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada
#define SENSORES 300000 // 5 Minutes

uint64_t tiempodelectura = 0;
int TempNID = 22;  /// Temperatura que querremos en el Nido
int TempINV = 23;  /// Temperatura que querremos en el Invernadero

int SENSORC = 2;                          //sensor DHT22 CLIMA
int SENSORN = 9;                          //sensor DHT22 NIDO
int SENSORLDR = 0;                        //sensor LDR
float TEMPERATURAC;                       //variable temperatura CLIMA
float TEMPERATURAN;                       //variable temperatura NIDO
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO
int LEDFC = 4;                            //LED indicador frío CLIMA
int LEDCC = 3;                            //LED indicador calor CLIMA
int LEDFN = 11;                           //LED indicador frío NIDO
int LEDCN = 10;                           //LED indicador calor NIDO
int LEDLDR = 7;                           //LED indicador LDR iluminación Gral.
int RELECC = 22;                           //Relé alta calor CLIMA
int RELEFC = 24;                           //Relé baja frío CLIMA
int RELELDR = 26;                          //Relé LDR iluminación Gral.
int RELECN = 28;                          //Relé alta calor NIDO
int RELEFN = 30;                          //Relé baja frío NIDO


DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

void setup(){
 
  void LEER_SENSORES{
                                            //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO
 
  }
 
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal baja
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal baja
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal baja
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal baja
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida(OJO!pinA1!)
                                          //NOTA: Entradas analógicas asignan por defecto

  Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea?
  Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea? 
  delay(500);                             //lapso demora 500 miliseg.(1/2 segundo)

 

  void CREPUSCULO{
                                          //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
       Serial.println("LUZ:On");
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.println("LUZ:Off");   
   }
 
  }

  void TEMPERATURA{
     
                                          //MÓDULO TERMOSTATO CLIMA GRAL. INVERNADERO
  if(TEMPERATURAC < TempINV){
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
  }else{
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }   
 
  if(TEMPERATURAC > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
  }else{
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  } 
 

                                          //MÓDULO TERMOSTATO CLIMA NIDO HIBERNÁCULO
  if(TEMPERATURAN < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
  }else{
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }   
 
  if(TEMPERATURAN > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
  }else{
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  } 
 
 }



void loop(){                             
         
    uint64_t now = millis();  /// declaramos la variable now con los millis actuales
     
      if((now - tiempodelectura) > SENSORES) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     LEER_SENSORES();                                    /// ejecutamos la lectura de sensores
     }
     CREPUSCULO();
     TEMPERATURA();
   
   }
           
« Última modificación: 15-Mayo-2020, 09:36 por Ramon »



16-Mayo-2020, 15:28
Respuesta #46

jajajajaj tienes todos los void metidos dentro del setup ponlos antes que el setup. Los void siempre van fuera de setup o loop para poder llamarlos desde cualquier lado. Yo como soy autodidacta tengo una manera peculiar de programar (sera por el TOC  :ght:). Te lo pongo a mi manera, a mi no me da errores asi, es que me gusta tenerlo ordenado para que nos sea caos.

Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG Zootecnia Doméstica  04/05/2020  V.1                    //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   INCLUDES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada


//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   PINES                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

int SENSORC = 2;                          //sensor DHT22 CLIMA
int SENSORN = 9;                          //sensor DHT22 NIDO
int SENSORLDR = 0;                        //sensor LDR
int LEDFC = 4;                            //LED indicador frío CLIMA
int LEDCC = 3;                            //LED indicador calor CLIMA
int LEDFN = 11;                           //LED indicador frío NIDO
int LEDCN = 10;                           //LED indicador calor NIDO
int LEDLDR = 7;                           //LED indicador LDR iluminación Gral.
int RELECC = 22;                           //Relé alta calor CLIMA
int RELEFC = 24;                           //Relé baja frío CLIMA
int RELELDR = 26;                          //Relé LDR iluminación Gral.
int RELECN = 28;                          //Relé alta calor NIDO
int RELEFN = 30;                          //Relé baja frío NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  VARIABLES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

float TEMPERATURAC;                       //variable temperatura CLIMA
float TEMPERATURAN;                       //variable temperatura NIDO
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO
DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CONFIGURACION                                  ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

uint64_t tiempodelectura = 0;
int TempNID = 22;  /// Temperatura que querremos en el Nido
int TempINV = 23;  /// Temperatura que querremos en el Invernadero
#define SENSORES 300000 // 5 Minutes

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  SENSORES                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

 void LEER_SENSORES{
                                            //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO
    Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea?
  Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea? 

  }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CREPUSCULO                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

  void CREPUSCULO{
                                          //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
       Serial.println("LUZ:On");
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.println("LUZ:Off");   
   }
 
  }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                               TEMPERATURA                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

    void TEMPERATURA{
     
                                          //MÓDULO TERMOSTATO CLIMA GRAL. INVERNADERO
  if(TEMPERATURAC < TempINV){
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
  }else{
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }   
 
  if(TEMPERATURAC > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
  }else{
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  } 
 

                                          //MÓDULO TERMOSTATO CLIMA NIDO HIBERNÁCULO
  if(TEMPERATURAN < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
  }else{
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }   
 
  if(TEMPERATURAN > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
  }else{
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  } 
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                     SETUP                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝


void setup(){
 
 
 
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal baja
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal baja
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal baja
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal baja
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida(OJO!pinA1!)
                                          //NOTA: Entradas analógicas asignan por defect
 
 }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                    LOOP                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void loop(){                             
         
    uint64_t now = millis();  /// declaramos la variable now con los millis actuales
     
      if((now - tiempodelectura) > SENSORES) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     LEER_SENSORES();                                    /// ejecutamos la lectura de sensores
     }
     CREPUSCULO();
     TEMPERATURA();
   
   }
Para que lo tengas mas claro, porque la traducción lleva a error el setup no es una configuración sino es una configuración inicial, es decir, esa parte del sketch solo se ejecuta una sola vez que es cuando se enciende.
« Última modificación: 16-Mayo-2020, 15:37 por korneto »


21-Mayo-2020, 09:19
Respuesta #47
  • Moderador General
  • Veterano
  • *****
  • Mensajes: 2.740

Hola Korneto! Pues entre tu TOC y mi supuesto TDA formaríamos un buen equipo  :ght:

Te escribí creo que el lunes pero tuvimos que actualizar el foro y perdimos el mensaje.  :alas:

Necesito saber si el sketch te está funcionando con Arduino IDE. Te explico, lo he copiado y pegado directamente en un archivo nuevo a estrenar. A la hora de compilar se vuelven a desatar los mismos demonios, mismos mensajes de error que tuve en sendas pruebas anteriores, tanto antes como después del SETUP.

La cuestión es que no he podido integrarlo tampoco por partes para intentar aislar el problema principal y estoy llegando a la conclusión de que tal vez hayas utilizado un compilador diferente a IDE... (Ya no se qué pensar...)

De hecho, empiezo a creer que no me admite la instrucción VOID en ningún tramo del sketch ya sea antes, dentro o después del SETUP pues así me lo confirma el informe de errores, que es inmenso.

Sobre los errores tipográficos, repasados hasta la saciedad, desde el reconocimiento de funciones hasta los corchetes y todo está correcto: No reconoce las variables y da errores en VOID.

Empiezo a plantearme comenzar el proyecto de nuevo y desde cero (No tengo plazo, el bicho ya vive fuera sin control alguno y el clima ya le es favorable) porque basándome en el sketch que hice y que ya funciona básicamente, todo intento de mejora (temporizar con millis, eliminar decimal en temperatura, Etc..) resulta un mar de errores.

Tengo que ponerme con la soldadura del LCD y liarme con el protocolo i2C. Pronto recibiré los RTC y deberé instalarlos. Tal vez sea el momento de hacer ambas cosas antes del sketch, en un archivo nuevo y en blanco para luego tratar de crearlo de cero basándome en las instrucciones de tiempo de la librería del RTC, por buscar otra vía...

Un saludo!




22-Mayo-2020, 13:35
Respuesta #48
  • Moderador General
  • Veterano
  • *****
  • Mensajes: 2.740

Hola otra vez! He soldado el módulo i2C a la pantalla LCD, sin lupa y con un soldador del chino ( :whi:) y ya que estaba, he aprovechado para probarla en el sketch del demonio. Por una vez, en honor a la verdad y porque rectificar es de sabios, esto si que ha funcionado a la primera... en contra de mis anteriores afirmaciones  :nos:




Con todo, creo que aprovecharé para rehacerlo entero cuando lleguen los relojes RTC... Pasito a pasito!



22-Mayo-2020, 13:53
Respuesta #49

Pues si que estaba puñetero de encontrar  :nos:

declare mal los void puse void TEMPERATURA{} y tiene que ser void TEMPERATURA(){}, a mayores, he cambiado los pines por #define así no hay que asignarles un tipo de variable que también daba error.

Al final del void TEMPERATURA faltaba también un { que es el que hacia fallar a setup y loop. Te lo dejo arreglado, en principio en mi Arduino IDE 1.8.12 y placa Uno funcionaria perfectamente, aunque no esta testado en placa ya que no tengo la Uno.

Cuéntame si funciona así me quedo tranquilo

Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG Zootecnia Doméstica  04/05/2020  V.1                    //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   INCLUDES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada


//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   PINES                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#define SENSORC 2                          //sensor DHT22 CLIMA
#define SENSORN 9                          //sensor DHT22 NIDO
#define SENSORLDR 0                        //sensor LDR
#define LEDFC 4                            //LED indicador frío CLIMA
#define LEDCC 3                            //LED indicador calor CLIMA
#define LEDFN 11                           //LED indicador frío NIDO
#define LEDCN 10                           //LED indicador calor NIDO
#define LEDLDR 7                           //LED indicador LDR iluminación Gral.
#define RELECC 22                           //Relé alta calor CLIMA
#define RELEFC 24                           //Relé baja frío CLIMA
#define RELELDR 26                          //Relé LDR iluminación Gral.
#define RELECN 28                          //Relé alta calor NIDO
#define RELEFN 30                          //Relé baja frío NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  VARIABLES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

float TEMPERATURAC;                       //variable temperatura CLIMA
float TEMPERATURAN;                       //variable temperatura NIDO
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO
DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CONFIGURACION                                  ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

uint64_t tiempodelectura = 0;
int TempNID = 22;  /// Temperatura que querremos en el Nido
int TempINV = 23;  /// Temperatura que querremos en el Invernadero
#define SENSORES 300000 // 5 Minutes

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  SENSORES                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

 void LEER_SENSORES(){
                                            //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO
    Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea?
  Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea? 

  }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CREPUSCULO                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

  void CREPUSCULO(){
                                          //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
       Serial.println("LUZ:On");
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.println("LUZ:Off");   
   }
 
  }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                               TEMPERATURA                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void TEMPERATURA(){
  if(TEMPERATURAC < TempINV){
   
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
  }else{
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }   
 
  if(TEMPERATURAC > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
  }else{
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  }
   
  if(TEMPERATURAN < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
  }else{
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }   
 
  if(TEMPERATURAN > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
  }else{
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  } 
}
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                     SETUP                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝


void setup(){
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal baja
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal baja
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal baja
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal baja
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida(OJO!pinA1!)
                                          //NOTA: Entradas analógicas asignan por defect
 
 }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                    LOOP                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void loop(){                             
         
    uint64_t now = millis();  /// declaramos la variable now con los millis actuales
     
      if((now - tiempodelectura) > SENSORES) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     LEER_SENSORES();                                    /// ejecutamos la lectura de sensores
     }
     CREPUSCULO();
     TEMPERATURA();
   
   }
« Última modificación: 22-Mayo-2020, 13:57 por korneto »


22-Mayo-2020, 15:06
Respuesta #50
  • Moderador General
  • Veterano
  • *****
  • Mensajes: 2.740

Ole tú!!!! Ahora no puedo meterme a fondo pero:

-Compilado con 0 errores!

-Los termostatos parecen funcionar correctamente.

-El crepuscular funciona perfectamente.

-El temporizado funciona, lo he cambiado a 3000 (3seg.) para poder comprobarlo (Ahora no tengo tiempo)

-No puedo monitorizar los resultados ni el funcionamiento de los termostatos porque el monitor serie está disparado y tan solo aparece escrita la línea de la "Luz" (No le da tiempo a escribir el resto, creo) pero variando los SET de temperatura el comportamiento parece coherente. Ya miraré de temporizar el monitor serie.

El ciclo va a todo trapo, muuuucho más rápido! Perfecto!

Muchas gracias otra vez. Si esta noche puedo, me pongo. Sino ya mañana. Eres un crack!  :dedit:



22-Mayo-2020, 18:39
Respuesta #51

Nada hombre es un placer, lo que si podrías hacer es modificar el serial.print por serial.printf creo que quedara mas limpio y ahorraras algunos mb.
Tienes que cambiar todos los Serial.print de el void TEMPERATURA por esto.


  Serial.printf("<<<  CLIMA  >>>      TEMPERATURA : %u ºC     HUMEDAD : %u %", TEMPERATURAC, HUMEDADC);
  Serial.printf("<<<  NIDO   >>>      TEMPERATURA : %u ºC     HUMEDAD : %u %", TEMPERATURAN, HUMEDADN);

Así en vez de 10 lineas tienes solo 2

Ya me contaras cuando lo pongas que tal funciona y cuando le pongas a eso el LCD muy buen proyecto que va tomando forma


25-Mayo-2020, 12:41
Respuesta #52
  • Moderador General
  • Veterano
  • *****
  • Mensajes: 2.740

Buenassss....

Perdona el retraso pero he tenido un fin de semana por fin movidito, je.

Le he estado echando unas horas y algo he conseguido. Voy a empezar por lo bueno: Tengo tu sketch instalado funcionando a toda velocidad ya con la LCD. Te pongo aquí el código actual pero no le hagas caso aún, ahora te explico:


Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG Zootecnia Doméstica  04/05/2020  V.1                    //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   INCLUDES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd (0x27, 2, 1, 0, 4, 5, 6, 7);

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   PINES                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#define SENSORC 2                          //sensor DHT22 CLIMA
#define SENSORN 9                          //sensor DHT22 NIDO
#define SENSORLDR 0                        //sensor LDR
#define LEDFC 4                            //LED indicador frío CLIMA
#define LEDCC 3                            //LED indicador calor CLIMA
#define LEDFN 11                           //LED indicador frío NIDO
#define LEDCN 10                           //LED indicador calor NIDO
#define LEDLDR 7                           //LED indicador LDR iluminación Gral.
#define LEDABIER 5                         //LED indicador puerta ABIERTA
#define LEDCERRA 6                         //LED indicador puerta CERRADA
#define RELECC 22                          //Relé alta calor CLIMA
#define RELEFC 24                          //Relé baja frío CLIMA
#define RELELDR 26                         //Relé LDR iluminación Gral.
#define RELECN 28                          //Relé alta calor NIDO
#define RELEFN 30                          //Relé baja frío NIDO
#define RELEABRIR 34                       //Relé abrir puerta
#define RELECERRAR 36                      //Relé cerrar puerta

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  VARIABLES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

float TEMPERATURAC;                       //variable temperatura CLIMA
float TEMPERATURAN;                       //variable temperatura NIDO
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO


DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CONFIGURACION                                  ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

uint64_t tiempodelectura = 0;
int TempNID = 23;  /// Temperatura que querremos en el Nido
int TempINV = 24;  /// Temperatura que querremos en el Invernadero
#define SENSORES 30000 //


//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  SENSORES                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

 void LEER_SENSORES(){
                                            //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO

 
 
   Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea?
   Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea? 
   
  }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CREPUSCULO                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

  void CREPUSCULO(){
                                              //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
    Serial.println("LUZ:On");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:On");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");
   
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.println("LUZ:Off");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:Of");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");   
   }
 
  }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                               TEMPERATURA                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void TEMPERATURA(){
  if(TEMPERATURAC < TempINV){
   
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
  }else{
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }   
 
  if(TEMPERATURAC > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
  }else{
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  }
   
  if(TEMPERATURAN < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
  }else{
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }   
 
  if(TEMPERATURAN > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
  }else{
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  } 
}

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                            APERTURA AUTOMATICA                                ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝
                                            //MÓDULO APERTURA/CIERRE PUERTAS
 void APERTURA(){                           //PELIGRO!!!Configurar retardo seguridad relés!!!             
                                            //PELIGRO!!!Temporizar inversión maniobra!!!
  if(dht1.readTemperature() - 2 < TempINV){ //Este módulo NO FUNCIONA ver abajo:                         
    digitalWrite(LEDCERRA, HIGH);           //OK
    digitalWrite(RELECERRAR, LOW);          //RELECERRAR NO ACTÚA
    Serial.println("PUERTA CERRADA");       //OK
    lcd.setCursor(0, 3);
    lcd.print("PUERTA CERRADA");            //OK
  }else{                                    //Preg: Faltará tensión por USB en Arduino?
    digitalWrite(LEDCERRA, LOW);
    digitalWrite(RELECERRAR, HIGH);
  }   
 
  if(dht1.readTemperature() + 2 > TempINV){                              //
    digitalWrite(LEDABIER, HIGH);           //LEDABIER muy poca intensidad!
    digitalWrite(RELEABRIR, LOW);           //RELECERRAR NO ACTÚA
    Serial.println("PUERTA ABIERTA");       //OK
    lcd.setCursor(0, 3);
    lcd.print("PUERTA ABIERTA");
  }else{
    digitalWrite(LEDABIER, LOW);
    digitalWrite(RELEABRIR, HIGH);
  }
  delay(500);                               ///QUITAR para usar millis!!!!!!!!
 }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                     SETUP                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝


void setup(){

  lcd.setBacklightPin(3,POSITIVE);        //
  lcd.setBacklight(HIGH);
  lcd.begin(20, 4);
  lcd.clear();
 
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
 
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal baja
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal baja
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal baja
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal baja
 
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida(OJO!pinA1!)
                                          //NOTA: Entradas analógicas asignan por defect
 
 }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                    LOOP                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void loop(){

   lcd.setCursor(0, 0);                    //Posicionando cursor 1ª línea
   lcd.print("CLIMA ");                    //Imprimir CLIMA
   lcd.print("T:");                        //Imprimir T:
   lcd.print(TEMPERATURAC, 1);             //asignar a impresión variable TªCLIMA
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADC);                    //asignar a impresión variable Hum.CLIMA
   lcd.setCursor(0, 1);                    //Posicionando cursor 2ª línea
   lcd.print("NIDO  ");                    //imprimir NIDO
   lcd.print("T:");                        //imprimir T:
   lcd.print(TEMPERATURAN, 1);             //asignar a impresión variable TªNIDO
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADN);                    //asignar a impresión variable Hum.NIDO
         
    uint64_t now = millis();  /// declaramos la variable now con los millis actuales
     
      if((now - tiempodelectura) > SENSORES) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     LEER_SENSORES();                                    /// ejecutamos la lectura de sensores
     }

     CREPUSCULO();                                   
         
     TEMPERATURA();


Va a tanta velocidad que la LCD vibraba con lo que he intentado aplicar el millis de nuevo sin resultado aprovechando que debo retrasar la maniobra de LDR para no fundir el foco HID... Varias horas intentando configurarlo copiando el ejemplo que me diste pero nada, lo mío no es programar, está claro. Provisionalmente le he puesto un delay de 500.  :mmm:

Te explico, tengo que añadir un tercer void termostato basado en la misma sonda CLIMA (DHT1) para regular la apertura-cierre de puertas. He copiado el mismo sketch del termostato CLIMA y le he añadido una función matemática simple. Se trata de que cuando la temperatura de lectura de sensor sobrepase 2ºC a la temperatura de ajuste, la puerta se abra. Cuando la temperatura de lectura se encuentre 2ºC por debajo del ajuste, se cierre. Todo esto sin entrar en temporizados, claro. Por tanto, un cuarto VOID al que llamo APERTURA.

El caso es que esta parte ya funcionaba en mi sketch original aunque todavía tenía un conflicto porque se solapaban los leds de ABIERTA y CERRADA en el tramo de temperatura intermedio.

Te pongo aquí la parte porque el código ya es un tocho, con los problemas que ahora presenta ya inserto en tu sketch:


Código: [Seleccionar]
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                            APERTURA AUTOMATICA                                ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝
                                            //MÓDULO APERTURA/CIERRE PUERTAS
 void APERTURA(){                           //PELIGRO!!!Configurar retardo seguridad relés!!!             
                                            //PELIGRO!!!Temporizar inversión maniobra!!!
  if(dht1.readTemperature() - 2 < TempINV){ //Este módulo NO FUNCIONA ver abajo:                         
    digitalWrite(LEDCERRA, HIGH);           //OK
    digitalWrite(RELECERRAR, LOW);          //RELECERRAR NO ACTÚA
    Serial.println("PUERTA CERRADA");       //OK
    lcd.setCursor(0, 3);
    lcd.print("PUERTA CERRADA");            //OK
  }else{                                    //Preg: Faltará tensión por USB en Arduino?
    digitalWrite(LEDCERRA, LOW);
    digitalWrite(RELECERRAR, HIGH);
  }   
 
  if(dht1.readTemperature() + 2 > TempINV){                              //
    digitalWrite(LEDABIER, HIGH);           //LEDABIER muy poca intensidad!
    digitalWrite(RELEABRIR, LOW);           //RELECERRAR NO ACTÚA
    Serial.println("PUERTA ABIERTA");       //OK
    lcd.setCursor(0, 3);
    lcd.print("PUERTA ABIERTA");
  }else{
    digitalWrite(LEDABIER, LOW);
    digitalWrite(RELEABRIR, HIGH);
  }
  delay(500);                               ///QUITAR para usar millis!!!!!!!!
 }


Debo decir que con mi programa inicial no había caída de tensión el los leds de la puerta y los relés actuaban aunque los leds se superponían en el tramo de temperaturas intermedio (Histéresis), con lo que debería descartar que el problema sea falta de amperaje en la alimentación por USB. Es de locos!!!!

Resumiendo ya, tengo que buscarme la vida para:

-Retrasar el encendido-apagado del relé de la LDR (VOID CREPÚSCULO) y lo tengo que conseguir yo solito, porque debo:

-Retrasar la maniobra apertura-cierre de puertas (VOID APERTURA)

-Temporizar tanto apertura como cierre en maniobras de 1 o 2 segundos.

El caso es que si pasan los días y no lo consigo, me plantearé suspender el asunto temporalmente y ponerme con otros sketch mucho más simples a modo de tutorial hasta dominarlo.

Por otro lado, en junio me llega el RTC3231 y quizás de no haberme aclarado con el asunto del tiempo pruebe a usar el reloj como temporizador, tal vez alguna librería lo simplifique (O quizás sea el mismo berenjenal, ni idea). Tendré que investigar por ahí ya como último recurso.

Ya para acabar, cuando todo esto esté controlado, aprenderemos eso de las "interrupciones" para instalar la sonda de lluvia que cerrará inmediatamente las puertas.
También me pondré con el sensor UVa-UVb que a priori no creo que plantee mucha historia y si todavía me han quedado ganas y no me he retirado en un asilo, un sensor de presión (Peso) en la bandeja del nido que detecte que el bicho o bichos estén fuera e interrumpa el suministro de calefacción-ventilación en el nido  :ght:

Un saludo!

Ah! EDITO: No he probado todavía la instrucción que me diste para sustituir los serial.print porque voy a tratar de incluir la temperatura de ajuste en las mismas líneas.
« Última modificación: 25-Mayo-2020, 12:48 por Ramon »



25-Mayo-2020, 21:43
Respuesta #53

Como dijo Jack el Destripador..... vamos por partes: (pq hay muchas cosas que no entiendo jajajaja)

LCD

El Lcd te vibra pq tienes puesto escribir las temperaturas en el loop, ya te dije, que el loop lo ejecuta cada milisegundo por lo cual cada milisegundo,basicamente, le estas diciendo que vuelva a escribir todo cada milisegundo... asi que normal que te vibre jajaja. Aprovecha el mismo void de LEER SENSORES y pones ahi lo de escribir la lcd otra cosa que puedes hacer es hacer una cariable que guarde la temperatura y si la temperatura ha cambiado ejecuta la orden de escribir en la pantalla sino ha cambiado no lo hace.

LED DUPLICADOS

Analizando el codigo se me ocurre que en el void TEMPERATURA hay algo que esta mal y creo que ese es el problema de los reles y los leds, si te fijas, le dijimos que si la temperatura era menor que la variable TEMPINV encendiera un led y sino otro... esto es lo que da fallo pq si no es menor ....sera mayor a pelotas y eso ya esta mas abajo programado
Quedaria asi.

Código: [Seleccionar]
void TEMPERATURA(){
  if(TEMPERATURAC < TempINV){ 
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  }
  if(TEMPERATURAC > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }
  if(TEMPERATURAN < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  }
  if(TEMPERATURAN > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }
}


APERTURA

Es normal que no funcione por dos motivos, El primero y mas fundamental es que has programado el void apertura, pero no lo has declarado en el loop asi que no se ejecuta y el segundo es que hay un pequeño error de sintaxis.

quedaria asi

Código: [Seleccionar]
void APERTURA(){                                       
                                         
  if((TEMPERATURAC - 2) < TempINV){                       
    digitalWrite(LEDCERRA, HIGH);           
    digitalWrite(RELECERRAR, LOW);         
    Serial.println("PUERTA CERRADA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA CERRADA");           
  }
  if((TEMPERATURAC + 2) > TempINV){                   
    digitalWrite(LEDABIER, HIGH);         
    digitalWrite(RELEABRIR, LOW);         
    Serial.println("PUERTA ABIERTA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA ABIERTA");
  }
 }

luego en el loop usariamos los millis primero creamos un define como el de sensores en nuestro apartado de configuracion y luego en el loop otro milli

Código: [Seleccionar]
#define APERTURAS 30000 //
uint64_t tiempodelectura2 = 0;

  if((now - tiempodelectura2) > APERTURAS) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura2 = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     APERTURA();                                    /// ejecutamos la lectura de sensores
     }


Asi quedaria el sketch entero...dime si funciona todo ok o lo que sea modificamos. Recuerda que TEMPERATURAC es una Variable Global, es decir, puedes invocarla desde cualquier punto del sketch, asi que, la lee cuando le hemos dicho que la lea y la guarda para ser usada cuando queramos.

Animo y no desesperes que vas progresando muy rapido, a veces los arboles no nos dejan ver el bosque...no seras el primero que borra su sketch de 500 lineas y empieza desde cero todo jajajaja lo digo por experiencia. Para que te hagas una idea el sketch que tengo en la luminaria, solo controla los leds del acuario.... tiene 1200 lineas de codigo  :alas:  este aun va por las 312 y hace mas cosas que el otro de 1200 asi que... ANIMOOOOOO :heart:

Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG Zootecnia Doméstica  04/05/2020  V.1                    //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   INCLUDES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd (0x27, 2, 1, 0, 4, 5, 6, 7);

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   PINES                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#define SENSORC 2                          //sensor DHT22 CLIMA
#define SENSORN 9                          //sensor DHT22 NIDO
#define SENSORLDR 0                        //sensor LDR
#define LEDFC 4                            //LED indicador frío CLIMA
#define LEDCC 3                            //LED indicador calor CLIMA
#define LEDFN 11                           //LED indicador frío NIDO
#define LEDCN 10                           //LED indicador calor NIDO
#define LEDLDR 7                           //LED indicador LDR iluminación Gral.
#define LEDABIER 5                         //LED indicador puerta ABIERTA
#define LEDCERRA 6                         //LED indicador puerta CERRADA
#define RELECC 22                          //Relé alta calor CLIMA
#define RELEFC 24                          //Relé baja frío CLIMA
#define RELELDR 26                         //Relé LDR iluminación Gral.
#define RELECN 28                          //Relé alta calor NIDO
#define RELEFN 30                          //Relé baja frío NIDO
#define RELEABRIR 34                       //Relé abrir puerta
#define RELECERRAR 36                      //Relé cerrar puerta

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  VARIABLES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

float TEMPERATURAC;                       //variable temperatura CLIMA
float TEMPERATURAN;                       //variable temperatura NIDO
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO
int TEMPNOW = 0;

DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CONFIGURACION                                  ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

uint64_t tiempodelectura = 0;
uint64_t tiempodelectura2 = 0;
int TempNID = 23;  /// Temperatura que querremos en el Nido
int TempINV = 24;  /// Temperatura que querremos en el Invernadero
#define SENSORES 30000 //
#define APERTURAS 30000 //


//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  SENSORES                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

 void LEER_SENSORES(){
                                            //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO

 
 
   Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea?
   Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea? 

   if(TEMPERATURAC != TEMPNOW){
    lcd.setCursor(0, 0);                    //Posicionando cursor 1ª línea
   lcd.print("CLIMA ");                    //Imprimir CLIMA
   lcd.print("T:");                        //Imprimir T:
   lcd.print(TEMPERATURAC, 1);             //asignar a impresión variable TªCLIMA
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADC);                    //asignar a impresión variable Hum.CLIMA
   lcd.setCursor(0, 1);                    //Posicionando cursor 2ª línea
   lcd.print("NIDO  ");                    //imprimir NIDO
   lcd.print("T:");                        //imprimir T:
   lcd.print(TEMPERATURAN, 1);             //asignar a impresión variable TªNIDO
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADN);                    //asignar a impresión variable Hum.NIDO
   TEMPNOW = TEMPERATURAC;
   }

   
  }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CREPUSCULO                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

  void CREPUSCULO(){
                                              //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
    Serial.println("LUZ:On");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:On");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");
   
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.println("LUZ:Off");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:Of");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");   
   }
 
  }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                               TEMPERATURA                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void TEMPERATURA(){
  if((TEMPERATURAC - 1) < TempINV){ 
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  }
  if(TEMPERATURAC + 1) > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }
  if(TEMPERATURAN - 1) < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  }
  if(TEMPERATURAN + 1) > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }
}

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                            APERTURA AUTOMATICA                                ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝
                                           
 void APERTURA(){                                       
                                         
  if((TEMPERATURAC - 2) < TempINV){                       
    digitalWrite(LEDCERRA, HIGH);           
    digitalWrite(RELECERRAR, LOW);         
    Serial.println("PUERTA CERRADA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA CERRADA");           
  }
  if((TEMPERATURAC + 2) > TempINV){                   
    digitalWrite(LEDABIER, HIGH);         
    digitalWrite(RELEABRIR, LOW);         
    Serial.println("PUERTA ABIERTA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA ABIERTA");
  }
 }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                     SETUP                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝


void setup(){

  lcd.setBacklightPin(3,POSITIVE);        //
  lcd.setBacklight(HIGH);
  lcd.begin(20, 4);
  lcd.clear();
 
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
 
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal baja
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal baja
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal baja
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal baja
 
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida(OJO!pinA1!)
                                          //NOTA: Entradas analógicas asignan por defect
 
 }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                    LOOP                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void loop(){


         
    uint64_t now = millis();  /// declaramos la variable now con los millis actuales
     
    if((now - tiempodelectura) > SENSORES) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     LEER_SENSORES();                                    /// ejecutamos la lectura de sensores
     }
    if((now - tiempodelectura2) > APERTURA) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura2 = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     APERTURA();                                    /// ejecutamos la lectura de sensores
     }
     CREPUSCULO();                                   
         
     TEMPERATURA();
}
« Última modificación: 25-Mayo-2020, 22:03 por korneto »


27-Mayo-2020, 08:12
Respuesta #54
  • Moderador General
  • Veterano
  • *****
  • Mensajes: 2.740

Buenos días Korneto! Disculpa el retraso.

Antes de nada, agradecer de nuevo tu ayuda una vez más y ya van unas cuantas. No te espantes por todo este ladrillo pero es que el asunto tiene su miga...

Estuve un buen rato repasando las modificaciones que habías hecho por aquello de entenderlo incluso antes de probarlo. Entre otras cosas pude ver la pifia que había hecho con los millis en el voidCREPUSCULO, je...  :whi:

Me he descojonado con lo de los lcdprint bailando samba en el loop! Pues menos mal que los has insertado tú en el voidSENSORES porque lo has hecho mediante un IF (Yo no lo hubiera pillado ni de lejos)

Entiendo que has creado la variable TEMPNOW=TEMPERATURAC para poder negarla mediante el IF. De ese modo el programa se ve obligado a revisar la temp. Y tan solo cuando es false, reescribir en display. Uf! Muy ingenioso. Intenté algo parecido que vi en un tuto que usaba “ESTADO” y luego lo “ponía en duda” en base a true-false.

No sé que copia del sketch te puse en el post anterior, pero en el que tenía trabajando en casa tenía la llamada en voidloop a APERTURA en último lugar, sospecho que al hacer copia faltó esto y el corchete, dos últimas líneas... ni idea.

Después compilé ya el nuevo programa y perfecto. Tan solo un problema de compilación al faltar unos paréntesis en la función suma-resta de los termostatos. Al ser el único error, reconocerlo fue inmediato.

-Termostatos CLIMA y NIDO: OK

-CREPUSCULO: OK

-APERTURA: No funciona de hecho, es un caos. Los relés no actúan (Ninguno de los dos) y los led hacen lo que les parece. Tal y como me pasaba hace dos días, el led de puerta abierta se enciende tan solo a medias: Problema de hardware?

Observa esta foto: He cargado el sketch antiguo en el que de forma desordenada  (Sin hacer los void separadamente para llamarlos en el loop) ya andaba la cosa aunque mal pues encendían los dos led de APERTURA a la vez pero los relés actuaban:





Este era el dichoso sketch que ya viste y después corregiste, bueno reconstruiste sin la parte de APERTURA pues no la conocías. Lo vuelvo a poner aquí porque esto ya se complica :

Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG Zootecnia Doméstica  04/05/2020  V.1                    //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido


#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd (0x27, 2, 1, 0, 4, 5, 6, 7);


int SENSORC = 2;                          //sensor DHT22 CLIMA
int SENSORN = 9;                          //sensor DHT22 NIDO
int SENSORLDR = 0;                        //sensor LDR
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO
int LEDFC = 4;                            //LED indicador frío CLIMA
int LEDCC = 3;                            //LED indicador calor CLIMA
int LEDFN = 11;                           //LED indicador frío NIDO
int LEDCN = 10;                           //LED indicador calor NIDO
int LEDLDR = 7;                           //LED indicador LDR iluminación Gral.
int LEDABIER = 5;
int LEDCERRA = 6;
int RELECC = 22;                          //Relé alta calor CLIMA
int RELEFC = 24;                          //Relé baja frío CLIMA
int RELELDR = 26;                         //Relé LDR iluminación Gral.
int RELECN = 28;                          //Relé alta calor NIDO
int RELEFN = 30;                          //Relé baja frío NIDO
int RELEABRIR = 34;                       //Relé abrir puerta(PENDIENTE)
int RELECERRAR = 36;                      //Relé cerrar puerta(PENDIENTE)
                                          //RELÉ LIBRE: Relé en PIN 32

int ABRIR;
int CERRAR;
                                         
float TEMPERATURAC;                       //lectura temperatura CLIMA
float TEMPERATURAN;                       //lectura temperatura NIDO

/////////////////////////                                         
float SETMINC = 20.0;  //                 //SET: ajuste temp mínima clima                         
float SETMAXC = 20.0;  //                 //SET: ajuste temp máxima clima
float SETMINN = 24.0;  //                 //SET: ajuste temp mínima nido
float SETMAXN = 30.0;  //                 //SET: ajuste temp máxima nido
/////////////////////////
                                         

DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

void setup(){

  lcd.setBacklightPin(3,POSITIVE);        //
  lcd.setBacklight(HIGH);
  lcd.begin(20, 4);
  lcd.clear();
 
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
 
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(LEDLDR, LOW);              //LED LDR (luz) señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal alta(Log,Inv)
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal alta(Log,Inv)
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta(")
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal alta(Log,Inv)
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal alta(Log,Inv)
  digitalWrite(LEDABIER, LOW);            //LED puerta ABIERTA señal baja
  digitalWrite(LEDCERRA, LOW);            //LED puerta CERRADA señal baja
  digitalWrite(RELEABRIR, HIGH);          //relé ABRIR puerta señal alta(Log,Inv)
  digitalWrite(RELECERRAR, HIGH);         //relé CERRAR puerta señal alta(Log,Inv)
 
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(LEDABIER, OUTPUT);              //pin LED puerta ABIERTA es una salida
  pinMode(LEDCERRA, OUTPUT);              //pin LED puerta CERRADA es una salida
  pinMode(RELEABRIR, OUTPUT);             //pin relé en fase ABRIR es una salida
  pinMode(RELECERRAR, OUTPUT);            //pin relé en fase CERRAR es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida
}                                         //NOTA: Entradas analógicas asignan por defecto
void loop(){

  lcd.setCursor(0, 0);                    //Posicionando cursor 1ª línea
  lcd.print("CLIMA ");                    //Imprimir CLIMA
  lcd.print("T:");                        //Imprimir T:
  lcd.print(TEMPERATURAC, 1);             //asignar a impresión variable TªCLIMA
  lcd.print(" HR:");                      //imprimir HR:
  lcd.print(HUMEDADC);                    //asignar a impresión variable Hum.CLIMA
  lcd.setCursor(0, 1);                    //Posicionando cursor 2ª línea
  lcd.print("NIDO  ");                    //imprimir NIDO
  lcd.print("T:");                        //imprimir T:
  lcd.print(TEMPERATURAN, 1);             //asignar a impresión variable TªNIDO
  lcd.print(" HR:");                      //imprimir HR:
  lcd.print(HUMEDADN);                    //asignar a impresión variable Hum.NIDO
                             
                                          //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO

  //////////////////////////////////////////////////
  ABRIR = dht1.readTemperature() + 2 > SETMAXC;   //
  CERRAR = dht1.readTemperature() - 2 < SETMINC;  //
  //////////////////////////////////////////////////
 
                                          //MONITOR SERIE
  Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA
  Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
  Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
  Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
  Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
  Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA 
  delay(500);                             //lapso demora 500 miliseg.(1/2 segundo)
 
                                          //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
  }
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
    Serial.print("LUZ:On");
    Serial.print(" UVa:__");
    Serial.println(" UVb:__");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:On");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");
     
   }else{                                 //sino...
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.print("LUZ:Off");
    Serial.print(" UVa:__");
    Serial.println(" UVb:__");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:Of");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");   
  }                                       //ATENCIÓN: Relés chinos: lógica inversa!
 delay(500);                              //lapso demora 500 miliseg.(1/2 segundo)
 
                                          //MÓDULO TERMOSTATO CLIMA GRAL. INVERNADERO
  if(TEMPERATURAC < SETMINC){             //Activa calefa clima
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
  }else{
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }   
 
  if(TEMPERATURAC > SETMAXC){             //Activa ventilación clima
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
  }else{
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  } 
 
  delay(500);
                                          //MÓDULO TERMOSTATO CLIMA NIDO HIBERNÁCULO
  if(TEMPERATURAN < SETMINN){             //Activa calefa nido
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
  }else{
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }   
 
  if(TEMPERATURAN > SETMAXN){             //Activa ventilación nido
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
  }else{
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  } 
 
  delay(500);
                                          //MÓDULO APERTURA/CIERRE PUERTAS
                                          //PELIGRO!!!Configurar retardo seguridad relés!!!
  if(CERRAR){                             //
    digitalWrite(LEDCERRA, HIGH);
    digitalWrite(RELECERRAR, LOW);
    Serial.println("PUERTA CERRADA");
    lcd.setCursor(0, 3);
    lcd.print("PUERTA CERRADA");
  }else{
    digitalWrite(LEDCERRA, LOW);
    digitalWrite(RELECERRAR, HIGH);
  }   
 
  if(ABRIR){                              //
    digitalWrite(LEDABIER, HIGH);
    digitalWrite(RELEABRIR, LOW);
    Serial.println("PUERTA ABIERTA");
    lcd.setCursor(0, 3);
    lcd.print("PUERTA ABIERTA");
  }else{
    digitalWrite(LEDABIER, LOW);
    digitalWrite(RELEABRIR, HIGH);
  } 
 
  delay(500);
}



Y esta foto es con el último sketch mejorado por ti (Versión actual). Voids declarados previamente y llamados desde el loop. Ya contiene el void APERTURA y su retardo por millis. Ambas fotos hechas esta mañana para intentar descartar un problema de hardware:



Donde: 1> Observa que ninguno de los dos relés de APERTURA trabajan.
           2> El led rojo no debería encenderse y lo hace pero a medias: Corrientes parásitas???  :und:

Si no encuentras nada raro en esta última versión del programa no me quedará otra que:

-Sustituir alimentación USB por fuente externa de 1A mín. (Tengo una ATX de 20A nueva y aburrida. La burra grande, ande o no ande...)

-Descartar haberme cargado el Arduino MEGA rehaciendo todo el hard. (Raro sería, el viejo sketch anda con los mismos pines)

-Ya he descartado un fallo de protoboard pero igualmente la cambiaré (Tengo dos más) y si hace falta iré soldando los componentes porque esto de los cables Dupont es un inconmensurable truño.

Estoy casi casi seguro de que el sketch funciona bien (Va como un tiro) aunque tal vez no se haya probado en condiciones (Hard). De hecho, APERTURA viene a ser lo mismo que los otros dos termostatos eso si, con un retardo en millis. Descuida que no nos quedaremos sin saber qué pasa con la cacharrería, me llevo algo mejor con el hardware que con el software  :hap:

Si puedes por favor, te agradecería que con toda la calma del mundo revises esta última versión. NO TENGO NINGUNA PRISA (Hasta que llegue el invierno y tampoco, ya tengo un controlador analógico por estrenar) de hecho, si quieres que nos tomemos unas vacaciones pues cojonudo.

Un saludo crack y gracias por todas las molestias!






27-Mayo-2020, 09:00
Respuesta #55

Buenos dias Ramon

Vacaciones?? que vaaaa jajajaja llevo 2 meses en ERTE asi que es como unas minivacaciones.

TEMPNOW

Basicamente hemos declarado una variable vacia como TEMPNOW. Al pasar arduino por esa linea le dice que si la temperatura actual es diferente a TEMPNOW escriba en la pantalla y declare TEMPNOW con el valor de la temperatura actual, asi solo se escribe de nuevo si la temperatura actual cambia. Es un recurso muy util para un sin fin de cosas.

APERTURA

Fallo mio , jajajaja, si te fijas al principio declare la variable #define APERTURAS 30000 pero si vas al loop veras que algo falla....   if((now - tiempodelectura2) > APERTURA) { ... le falta la S esto lo hice para que el nombre APERTURA no coincida con el del loop, vamos seria añadirle la S al final.

TRUCO DE LOS ERRORES

Te voy a contar como hago yo cada vez que creo algo nuevo en el sketch, como ya te dije yo he ido aprendiendo a mi manera yo solo asi que el truco es cosecha propia.

Crear un nuevo void temporizado

En el loop

 if((now - tiempodelectura3) > LOQUESEA) {   
          tiempodelectura3 = now;                 
            Serial.print("FUNCIONA");                         
     }

Subo el sketch y miro si en el monitor serie me pone FUNCIONA si es SI sigo si es NO repaso ese poquito de codigo

SIGUIENTE PASO

void LOQUESEA(){

Serial.print("FUNCIONA");
}

En el loop

 if((now - tiempodelectura3) > LOQUESEA) {   
          tiempodelectura3 = now;                 
          LOQUESEA();                       
     }

Vuelvo a subir el codigo y vuelvo a mirar si sale FUNCIONA y asi es como iba poco a poco creando el nuevo codigo, tardas mas , pero es infalible. Actualmente tambien lo uso pero mucho menos, solo cuando no doy encontrado un error en alguna parte entonces lo comento todo y voy poco a poco en esa parte.

De todas maneras, faltaban tambien algunos ) en el sketch  :nos:

Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG Zootecnia Doméstica  04/05/2020  V.1                    //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   INCLUDES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd (0x27, 2, 1, 0, 4, 5, 6, 7);

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   PINES                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#define SENSORC 2                          //sensor DHT22 CLIMA
#define SENSORN 9                          //sensor DHT22 NIDO
#define SENSORLDR 0                        //sensor LDR
#define LEDFC 4                            //LED indicador frío CLIMA
#define LEDCC 3                            //LED indicador calor CLIMA
#define LEDFN 11                           //LED indicador frío NIDO
#define LEDCN 10                           //LED indicador calor NIDO
#define LEDLDR 7                           //LED indicador LDR iluminación Gral.
#define LEDABIER 5                         //LED indicador puerta ABIERTA
#define LEDCERRA 6                         //LED indicador puerta CERRADA
#define RELECC 22                          //Relé alta calor CLIMA
#define RELEFC 24                          //Relé baja frío CLIMA
#define RELELDR 26                         //Relé LDR iluminación Gral.
#define RELECN 28                          //Relé alta calor NIDO
#define RELEFN 30                          //Relé baja frío NIDO
#define RELEABRIR 34                       //Relé abrir puerta
#define RELECERRAR 36                      //Relé cerrar puerta

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  VARIABLES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

float TEMPERATURAC;                       //variable temperatura CLIMA
float TEMPERATURAN;                       //variable temperatura NIDO
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO
int TEMPNOW = 0;

DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CONFIGURACION                                  ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

uint64_t tiempodelectura = 0;
uint64_t tiempodelectura2 = 0;
int TempNID = 23;  /// Temperatura que querremos en el Nido
int TempINV = 24;  /// Temperatura que querremos en el Invernadero
#define SENSORES 30000 //
#define APERTURAS 30000 //


//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  SENSORES                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

 void LEER_SENSORES(){
                                            //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO

 
 
   Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea?
   Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea? 

   if(TEMPERATURAC != TEMPNOW){
    lcd.setCursor(0, 0);                    //Posicionando cursor 1ª línea
   lcd.print("CLIMA ");                    //Imprimir CLIMA
   lcd.print("T:");                        //Imprimir T:
   lcd.print(TEMPERATURAC, 1);             //asignar a impresión variable TªCLIMA
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADC);                    //asignar a impresión variable Hum.CLIMA
   lcd.setCursor(0, 1);                    //Posicionando cursor 2ª línea
   lcd.print("NIDO  ");                    //imprimir NIDO
   lcd.print("T:");                        //imprimir T:
   lcd.print(TEMPERATURAN, 1);             //asignar a impresión variable TªNIDO
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADN);                    //asignar a impresión variable Hum.NIDO
   TEMPNOW = TEMPERATURAC;
   }

   
  }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CREPUSCULO                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

  void CREPUSCULO(){
                                              //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
    Serial.println("LUZ:On");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:On");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");
   
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.println("LUZ:Off");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:Of");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");   
   }
 
  }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                               TEMPERATURA                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void TEMPERATURA(){
  if((TEMPERATURAC - 1) < TempINV){ 
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  }
  if((TEMPERATURAC + 1) > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }
  if((TEMPERATURAN - 1) < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  }
  if((TEMPERATURAN + 1) > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }
}

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                            APERTURA AUTOMATICA                                ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝
                                           
 void APERTURA(){                                       
                                         
  if((TEMPERATURAC - 2) < TempINV){                       
    digitalWrite(LEDCERRA, HIGH);           
    digitalWrite(RELECERRAR, LOW);         
    Serial.println("PUERTA CERRADA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA CERRADA");           
  }
  if((TEMPERATURAC + 2) > TempINV){                   
    digitalWrite(LEDABIER, HIGH);         
    digitalWrite(RELEABRIR, LOW);         
    Serial.println("PUERTA ABIERTA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA ABIERTA");
  }
 }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                     SETUP                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝


void setup(){

  lcd.setBacklightPin(3,POSITIVE);        //
  lcd.setBacklight(HIGH);
  lcd.begin(20, 4);
  lcd.clear();
 
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
 
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal baja
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal baja
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal baja
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal baja
 
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida(OJO!pinA1!)
                                          //NOTA: Entradas analógicas asignan por defect
 
 }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                    LOOP                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void loop(){


         
    uint64_t now = millis();  /// declaramos la variable now con los millis actuales
     
    if((now - tiempodelectura) > SENSORES) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     LEER_SENSORES();                                    /// ejecutamos la lectura de sensores
     }
    if((now - tiempodelectura2) > APERTURAS) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura2 = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     APERTURA();                                    /// ejecutamos la lectura de sensores
     }
     CREPUSCULO();                                   
         
     TEMPERATURA();
}

Ahi esta corregido, aun asi creo que nos puede dar algun problema puesto que TEMPERATURAC es un float y le estamos restando un int, pero vamos a ver si suena la campana asi y sino lo cambiamos


27-Mayo-2020, 13:44
Respuesta #56
  • Moderador General
  • Veterano
  • *****
  • Mensajes: 2.740

Jooooder, esto me recuerda a mi infancia hace muuuchos años. Yo te propongo vacaciones y tu me respondes que de eso nada. Y encima me pones deberes!!!  :ght:


Creo que con tu método paso a paso esta vez lo tendría que pillar, ya va siendo hora. Lo probaré hasta la saciedad a ver si así...

(Tengo una moscarda por aquí dando por saco, espera...         ...se escapó.)

He cargado el programa y tachán! El problema persiste...

He cambiado tanto el LED como la resistencia y los dos jumpers por otros componentes nuevos. Nanai...

He sustituido las variables float por int. Compila sin problemas y cuando lo cargo como es natural, pierdo los decimales de las temperaturas en la LCD pero el problema sigue.

El problema:

1-Los relés correspondientes al actuador lineal RELEABRIR (pin 34) y RELECERRAR (pin 36) declarados ambos como.... mierda, espera!!!!

   Relés ABRIR/CERRAR sin declarar como salida!
   Relés ABRIR/CERRAR sin declarar como HIGH! (Lógica inversa china)

   He o hemos debido traspapelar archivos previos y posteriores a la asignación de voidAPERTURA. Hago prueba... Los relés ya funcionan pero se superponen en las temperaturas próximas a TempINV. Bueno, a menos hemos vuelto al error inicial!

Vuelvo a cambiar float por int... y voy probando en TempINV diversos valores próximos a la lectura del DHT1:

TempINV= 24 / temperatura lectura DHT1= 23. Los dos relés encendidos a la vez pese a que tendrían que actuar uno a -2ºC y el otro a +2ºC respecto a TempINV!


2-Los leds encargados de avisar el estado puerta ABIERTA/CERRADA trabajan a baja tensión (Poca luz) y también están encendidos a la vez.


3-En la LCD imprime PUERTA ABIERTA aún correspondiendo CERRADA

Esto vuelve a oler a hardware ya sea por falta de amperaje (Lo cual no tiene sentido, el otro sketch antiguo lo encendía todo y podía) o alguna corriente parásita. Me estoy volviendo loco  :tongo:

(Ahora sí, me acabo de cargar la moscarda...  :ght:)

Aprovecho para ponerte el sketch con las correcciones de añadir los relés como salida y señal HIGH y el cambio de float por int:

Código: [Seleccionar]
/////////////////////////////////////////////////////////////////////
//                                                                 //
//       CONTROLADOR BIZONAL INVERNADERO PARA REPTILES   V.1       //
//                                                                 //
//     -Control clima general:Termostato 2 relé (alta/baja)        //
//     -Control hibernáculo(nido):Termostato 2 relé ( " )          //
//     -Medición humedad relativa (HR) invernadero y nido          //
//     -Interruptor crepuscular alumbrado general (diurno)         //
//     -Control continuo rendimiento lámpara/tubo UVa/UVb          //
//     -Control horario/estacional de parámetros (Temps./luz)      //
//     -Apertura/cierre progresivo techo invernadero               //
//     -Sensor lluvia cierre total techo invernadero               //
//     -Sensor presencia en hibernáculo (eficiencia energética)    //
//                                                                 //
//     RCG y Korneto para Zootecnia Doméstica  04/05/2020  V.1     //
//                                                                 //
/////////////////////////////////////////////////////////////////////


//Glosario, terminaciones en:
//  ...C: Relativas a Clima invernadero (general)       
//  ...N:    "   a clima Nido (hibernáculo)
//  ..FC:    "   a Frío Clima general
//  ..FN:    "   a Frío Nido
//  ..CC:    "   a Calor Clima
//  ..CN:    "   a Calor Nido

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   INCLUDES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#include <DHT.h>                          //librería DHT
#include <DHT_U.h>                        //librería DHT unificada

#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd (0x27, 2, 1, 0, 4, 5, 6, 7);

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                   PINES                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

#define SENSORC 2                          //sensor DHT22 CLIMA
#define SENSORN 9                          //sensor DHT22 NIDO
#define SENSORLDR 0                        //sensor LDR
#define LEDFC 4                            //LED indicador frío CLIMA
#define LEDCC 3                            //LED indicador calor CLIMA
#define LEDFN 11                           //LED indicador frío NIDO
#define LEDCN 10                           //LED indicador calor NIDO
#define LEDLDR 7                           //LED indicador LDR iluminación Gral.
#define LEDABIER 5                         //LED indicador puerta ABIERTA
#define LEDCERRA 6                         //LED indicador puerta CERRADA
#define RELECC 22                          //Relé alta calor CLIMA
#define RELEFC 24                          //Relé baja frío CLIMA
#define RELELDR 26                         //Relé LDR iluminación Gral.
#define RELECN 28                          //Relé alta calor NIDO
#define RELEFN 30                          //Relé baja frío NIDO
#define RELEABRIR 34                       //Relé abrir puerta
#define RELECERRAR 36                      //Relé cerrar puerta

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  VARIABLES                                    ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

int TEMPERATURAC;                       //variable temperatura CLIMA
int TEMPERATURAN;                       //variable temperatura NIDO
int HUMEDADC;                             //variable humedad CLIMA
int HUMEDADN;                             //variable humedad NIDO
int TEMPNOW = 0;

DHT dht1(SENSORC, DHT22);                 //Asignación sensor CLIMA
DHT dht2(SENSORN, DHT22);                 //Asignación sensor NIDO

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CONFIGURACION                                  ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

uint64_t tiempodelectura = 0;
uint64_t tiempodelectura2 = 0;
int TempNID = 23;  /// Temperatura que querremos en el Nido
int TempINV = 24;  /// Temperatura que querremos en el Invernadero
#define SENSORES 30000 //
#define APERTURAS 30000 //


//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                  SENSORES                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

 void LEER_SENSORES(){
                                            //VARIABLES
  TEMPERATURAC = dht1.readTemperature();  //asignación variable lectura Temp. DHTCLIMA
  HUMEDADC = dht1.readHumidity();         //asignación variable lectura Humed. DHTCLIMA
  TEMPERATURAN = dht2.readTemperature();  //asignación variable lectura Temp. DHTNIDO
  HUMEDADN = dht2.readHumidity();         //asignación variable lectura Humed. DHTNIDO

 
 
   Serial.print("CLIMA ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAC, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADC);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea?
   Serial.print("NIDO  ");                 //imprimir Monitor serie. Sin valor
   Serial.print("Tª:");                    //imprimir Monitor serie. Con valor TªCLIMA
   Serial.print(TEMPERATURAN, 1);          //asignar a impresión variable TªCLIMA
   Serial.print(" HR:");                   //imprimir Monitor serie. Con valor Hum.CLIMA
   Serial.println(HUMEDADN);               //asignar a impresión variable Hum.CLIMA y ¿(ln)fin línea? 

   if(TEMPERATURAC != TEMPNOW){
    lcd.setCursor(0, 0);                    //Posicionando cursor 1ª línea
   lcd.print("CLIMA ");                    //Imprimir CLIMA
   lcd.print("T:");                        //Imprimir T:
   lcd.print(TEMPERATURAC, 1);             //asignar a impresión variable TªCLIMA
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADC);                    //asignar a impresión variable Hum.CLIMA
   lcd.setCursor(0, 1);                    //Posicionando cursor 2ª línea
   lcd.print("NIDO  ");                    //imprimir NIDO
   lcd.print("T:");                        //imprimir T:
   lcd.print(TEMPERATURAN, 1);             //asignar a impresión variable TªNIDO
   lcd.print(" HR:");                      //imprimir HR:
   lcd.print(HUMEDADN);                    //asignar a impresión variable Hum.NIDO
   TEMPNOW = TEMPERATURAC;
   }

   
  }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                CREPUSCULO                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

  void CREPUSCULO(){
                                              //INTERRUPTOR CREPUSCULAR
   if(analogRead(SENSORLDR) < 200){       //si... lectura sensor LDR inferior a...
    digitalWrite(LEDLDR, HIGH);           //...entonces LED LDR señal alta
    digitalWrite(RELELDR, LOW);           //...entonces relé LDR Ilum.Gral. señal baja
    Serial.println("LUZ:On");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:On");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");
   
   }else{                                 //sino... 
    digitalWrite(LEDLDR, LOW);            //...LED LDR señal baja 
    digitalWrite(RELELDR, HIGH);          //relé LDR Ilum.Gral. señal alta
    Serial.println("LUZ:Off");
    lcd.setCursor(0, 2);
    lcd.print("LUZ:Of");
    lcd.print(" UVa:__");
    lcd.print(" UVb:__");   
   }
 
  }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                               TEMPERATURA                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void TEMPERATURA(){
  if((TEMPERATURAC - 1) < TempINV){ 
    digitalWrite(LEDCC, HIGH);
    digitalWrite(RELECC, LOW);
    digitalWrite(LEDFC, LOW);
    digitalWrite(RELEFC, HIGH);
  }
  if((TEMPERATURAC + 1) > TempINV){
    digitalWrite(LEDFC, HIGH);
    digitalWrite(RELEFC, LOW);
    digitalWrite(LEDCC, LOW);
    digitalWrite(RELECC, HIGH);
  }
  if((TEMPERATURAN - 1) < TempNID){
    digitalWrite(LEDCN, HIGH);
    digitalWrite(RELECN, LOW);
    digitalWrite(LEDFN, LOW);
    digitalWrite(RELEFN, HIGH);
  }
  if((TEMPERATURAN + 1) > TempNID){
    digitalWrite(LEDFN, HIGH);
    digitalWrite(RELEFN, LOW);
    digitalWrite(LEDCN, LOW);
    digitalWrite(RELECN, HIGH);
  }
}

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                            APERTURA AUTOMATICA                                ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝
                                           
 void APERTURA(){                                       
                                         
  if((TEMPERATURAC - 2) < TempINV){                       
    digitalWrite(LEDCERRA, HIGH);           
    digitalWrite(RELECERRAR, LOW);         
    Serial.println("PUERTA CERRADA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA CERRADA");           
  }
  if((TEMPERATURAC + 2) > TempINV){                   
    digitalWrite(LEDABIER, HIGH);         
    digitalWrite(RELEABRIR, LOW);         
    Serial.println("PUERTA ABIERTA");       
    lcd.setCursor(0, 3);
    lcd.print("PUERTA ABIERTA");
  }
 }
 
//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                     SETUP                                     ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝


void setup(){

  lcd.setBacklightPin(3,POSITIVE);        //
  lcd.setBacklight(HIGH);
  lcd.begin(20, 4);
  lcd.clear();
 
  Serial.begin(9600);                     //inicializando monitor serie
  dht1.begin();                           //inicializando sonda DHT1(CLIMA)
  dht2.begin();                           //inicializando sonda DHT2(NIDO)
 
  digitalWrite(LEDCC, LOW);               //LED calor CLIMA señal baja
  digitalWrite(LEDFC, LOW);               //LED frío CLIMA señal baja
  digitalWrite(RELECC, HIGH);             //relé calor CLIMA señal baja
  digitalWrite(RELEFC, HIGH);             //relé frío CLIMA señal baja
  digitalWrite(RELELDR, HIGH);            //relé LDR iluminación Gral.señal alta
  digitalWrite(LEDCN, LOW);               //LED calor NIDO señal baja
  digitalWrite(LEDFN, LOW);               //LED frío NIDO señal baja
  digitalWrite(RELECN, HIGH);             //relé calor NIDO señal baja
  digitalWrite(RELEFN, HIGH);             //relé frío NIDO señal baja
  digitalWrite(RELEABRIR, HIGH);
  digitalWrite(RELECERRAR, HIGH);
 
  pinMode(LEDCC, OUTPUT);                 //pin LED calor CLIMA es una salida
  pinMode(LEDFC, OUTPUT);                 //pin LED frío CLIMA es una salida
  pinMode(LEDLDR, OUTPUT);                //pin LED LDR Ilumin. Gral. es una salida
  pinMode(RELECC, OUTPUT);                //pin relé calor CLIMA es una salida
  pinMode(RELEFC, OUTPUT);                //pin relé frío CLIMA es una salida
  pinMode(RELELDR, OUTPUT);               //pin relé LDR Ilumin. Gral. es una salida
  pinMode(LEDCN, OUTPUT);                 //pin LED calor NIDO es una salida
  pinMode(LEDFN, OUTPUT);                 //pin LED frío NIDO es una salida
  pinMode(RELECN, OUTPUT);                //pin relé calor NIDO es una salida
  pinMode(RELEFN, OUTPUT);                //pin relé frío NIDO es una salida
  pinMode(RELEABRIR, OUTPUT);
  pinMode(RELECERRAR, OUTPUT);
                                          //NOTA: Entradas analógicas asignan por defect
 
 }

//╔══════════════════════════════════════════════╗
//║                                                                               ║
//║                                                                               ║
//║                                    LOOP                                       ║
//║                                                                               ║
//║                                                                               ║
//╚══════════════════════════════════════════════╝

void loop(){


         
    uint64_t now = millis();  /// declaramos la variable now con los millis actuales
     
    if((now - tiempodelectura) > SENSORES) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     LEER_SENSORES();                                    /// ejecutamos la lectura de sensores
     }
    if((now - tiempodelectura2) > APERTURAS) {    /// si now menos la variable tiempo de lectura es mayor que los millis que le hemos declarado en sensores
          tiempodelectura2 = now;                   /// cambiamos la variable tiempo de lectura por now que son los millis actuales
     APERTURA();                                    /// ejecutamos la lectura de sensores
     }
     CREPUSCULO();                                   
         
     TEMPERATURA();
}