Electrónica y programación para Microcontroladores.

/*******************************************************************
** Descripción: Control de un sistema de bomba para hidroponia con
**              lectura de temperatura de la solución nutritiva y
**              condiciones ambientales como temperatura y humedad
**              Sensor DS18B20 conectado en pin 10 y DHT22 en pin 9
**              Botones de arranque/parada manual conectados en pines 
**              3 y 4. 
**              Boton de programación de tiempos en pin 2
**   Placa Arduino: NANO
**   Arduino IDE: 1.8.15
**   
**   www.firtec.com.ar
*******************************************************************/
#include <DHT.h>
#define DHTTYPE DHT22     // Tipo de sensor
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <avr/wdt.h>
#include <DallasTemperature.h>
 
void Temperatura_Nutriente(void);  // Función para medir la temperatura 
void Programar_Tiempo(void);       // Función para los tiempos de la bomba
void Potenciometro(void);          // Función para ajustar los minutos de trabajo
void Pantalla(void);               // Función para mostrar los textos en pantalla
void Sensor_DHT22(void);           // Lee temperatura y humedad ambiente
 
LiquidCrystal_I2C lcd(0x27,20,4);
#define prog 2                  // Boton de programacion para el tiempo de bomba
#define arranque_manual 3      // Boton para el arranque manual de la bomba
#define parada_manual 4        // Boton para la parada manual de la bomba
#define relay_bomba 5           // Salida para activar/desactivar bomba de nutrientes
#define alarma_temperatura 18   // LED para indicar alarma de temperatura
#define calefactor 17           // Pin para activar/desactivar el calefactor 
 
OneWire UnWire(10);             // Sensor DS18B20 conectado en el pin 10
DallasTemperature sensor(&UnWire);
DHT dht(9, DHT22); // Instancia del sensor conectado en el pin 9
 
byte minutos = 0, segundos = 0, estado = 0;
byte tiempo_boton = 0; // Tiempo de espera para entrar en modo programacion
byte tiempo_funcionamiento = 10; // Valor por defecto si no hay nada previo
byte tiempo_apagado = 10;        // Valor por defecto si no hay nada previo
char buffer[5] = " ";            // Manejo de datos a ASCII para el LCD
unsigned int M0 = 0;             // Variable usada en el conversor
volatile bool flag_bomba = false; // Variable para avisar que ha pasado un segundo
bool estado_bomba = false;
bool flag_prog = false;
bool programando = false;
unsigned int dir_ep = 0;      // Variable para contener la dirección EEPROM donde se guarda los valores
double temp;         // Variable para contener la temperatura
float t;
float h;
static char Temperatura[5]="";
static char Humedad[5]="";
 
 
/******************* FUNCIÓN PARA ESCALAR EL CONVERSOR A/D ********************
** Potenciometro conectado en el Canal A0
******************************************************************************/
long map(long x, long in_min, long in_max, long out_min, long out_max){
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
 
/******************* FUNCIÓN DE CONFIGURACIÓN GENERAL ************************
** Configura las condiciones de arranque y Hardware.
******************************************************************************/
void setup() {
  Serial.begin(9600);
  pinMode(A0, INPUT);
  pinMode(alarma_temperatura, OUTPUT);
  digitalWrite(alarma_temperatura, LOW); 
  pinMode(calefactor, OUTPUT);  // Pin para activar/desactivar el calefactor 
  digitalWrite(calefactor, LOW); // Pin normal
  //digitalWrite(calefactor, HIGH);  // Pin invertido
  pinMode(relay_bomba, OUTPUT);
  digitalWrite(relay_bomba, LOW); // Pin normal
  //digitalWrite(relay_bomba, HIGH);  // Pin invertido
  pinMode(prog,INPUT_PULLUP); 
  pinMode(arranque_manual,INPUT_PULLUP); // Configura el pin de arranque manual de la bomba
  pinMode(parada_manual,INPUT_PULLUP); // Configura el pin de parada manual de la bomba
  noInterrupts(); 
  TCCR1A = 0;                // El registro de control A queda todo en 0
  TCCR1B = 0;                //limpia registrador
  TCNT1  = 0;                //Inicializa el temporizador
  OCR1A = 0x3D09;            // Carga el registrador de comparación: 16MHz/1024/1Hz = 15625 = 0X3D09
  TCCR1B |= (1 << WGM12)|(1<<CS10)|(1 << CS12);   // modo CTC, prescaler de 1024: CS12 = 1 e CS10 = 1  
  TIMSK1 |= (1 << OCIE1A);  // habilita interrupción por igualdade de comparación
  TIMSK1 |= (1 << TOIE1);   // enable timer overflow interrupt
  interrupts();             // enable all interrupts
  if(EEPROM.read(dir_ep) > 50){  // Recupera de memoria el ultimo tiempo de encendido
    tiempo_funcionamiento = 10;  // Si no es valido asigna uno por defecto 10 minutos
  }
  else
    tiempo_funcionamiento = EEPROM.read(dir_ep);
  
  if(EEPROM.read(dir_ep + 1) > 50){ // Recupera de memoria el ultimo tiempo de parada
    tiempo_apagado = 10;            // Si no es valido asigna uno por defecto 10 minutos
  }
  else
    tiempo_apagado = EEPROM.read(dir_ep + 1);
  lcd.init();                      
  lcd.backlight();
  dht.begin();
  Pantalla();
  wdt_disable();
  wdt_enable(WDTO_4S);
 
}
/******************* BUCLE PRINCIPAL DE PROGRAMA *****************************
** Verifica botones, sensor de temperatura y control general del programa.
******************************************************************************/
void loop() {
  wdt_reset(); // Borra el contador del wachdog
  Sensor_DHT22();
//********* VERIFICA LOS BOTONES DE CONTROL MANUAL DE BOMBA*********************** 
  if (digitalRead(arranque_manual) == LOW & programando == false){
     segundos = 0;
     minutos = 0;                     // Borrar minutos para nueva cuenta
     digitalWrite(relay_bomba, HIGH); // Activar la bomba de nutrientes (normal)
     //digitalWrite(relay_bomba, LOW);    // Activar la bomba de nutrientes (invertido)
     estado_bomba = true;             // Avisar que la bomba esta funcionando
     lcd.setCursor(6,2); 
     if(programando == false)
         lcd.print("SI");   // Mostrar cartel del estado de la bomba
  }
 if (digitalRead(parada_manual) == LOW & programando == false){
     segundos = 0;
     minutos = 0;                     // Borrar minutos para nueva cuenta
     digitalWrite(relay_bomba, LOW); // Activar la bomba de nutrientes (normal)
     //digitalWrite(relay_bomba, HIGH);  // Activar la bomba de nutrientes (invertido)
     estado_bomba = false;           // Avisar que la bomba esta funcionando
     lcd.setCursor(6,2);
     if(programando == false) 
          lcd.print("NO");  // Mostrar cartel del estado de la bomba
  }
  if(programando == false)
      Temperatura_Nutriente();  // Mide la temperatura de solución de nutrientes
  wdt_reset(); // Borra el contador del wachdog
 //********* CONTROL DE LA BOMBA DE NUTRIENTES ****************************  
  if(flag_bomba == true){           // Temporizador avisa que ya paso un segundo
    if (digitalRead(prog) == LOW){  // El boton de programación esta activado?
     tiempo_boton++;                // Incrementar el tiempo de control
     flag_prog = true;              // Avisar que el boton esta apretado
     if(tiempo_boton == 5 & digitalRead(prog) == LOW){ // Pasaron 5 segundos con el boton apretado?
        Programar_Tiempo();  // Programa tiempo de funcionamiento de la bomba
     }
    }
    if (digitalRead(prog)){ // El botón de programación se soltó?
      tiempo_boton =0;      // Ignorar todos los pasos anteriores!!
      flag_prog = false;    // Borrar bandera de programación.
    }
    segundos++;           // Incrementa los segundos
    if(segundos == 59){   // La cuenta llego al minutos?
      segundos = 0;       // Borra segundos para nueva cuenta
      minutos++;          // Incrementa los minutos    
      wdt_reset(); // Borra el contador del wachdog
    }
    if(minutos == tiempo_apagado & estado_bomba == false){ // Se cumplió el tiempo de apagado?
      minutos = 0;                     // Borrar minutos para nueva cuenta
      digitalWrite(relay_bomba, HIGH); // Activar la bomba de nutrientes (normal)
      //digitalWrite(relay_bomba, LOW);    // Activar la bomba de nutrientes (invertido)
      estado_bomba = true;             // Avisar que la bomba está funcionando  
      lcd.setCursor(6,2);
      if(programando == false) 
            lcd.print("SI");  // Mostrar cartel del estado de la bomba
      wdt_reset(); // Borra el contador del wachdog
    } 
    if(minutos == tiempo_funcionamiento & estado_bomba == true){  // Se cumplió el tiempo de funcionamiento? 
      minutos = 0;    // Borrar los minutos para nueva cuenta
      digitalWrite(relay_bomba, LOW);  // Apagar la bomba de nutrientes (normal)
      //digitalWrite(relay_bomba, HIGH);   // Apagar la bomba de nutrientes (invertido)
      estado_bomba = false;       // Avisar que la bomba está apagada
      lcd.setCursor(6,2); 
      if(programando == false)
            lcd.print("NO"); // Mostrar cartel del estado de la bomba
      wdt_reset(); // Borra el contador del wachdog
    }    
    wdt_reset(); // Borra el contador del wachdog
    flag_bomba = false; // Borra bandera de INTE
  }
}
/******************* INTERRUPCION POR CADA SEGUNDO ********************
** Ciclo de interrupción: 1 segundo
***********************************************************************/
ISR(TIMER1_COMPA_vect)          
{
   flag_bomba = true;   // Bandera para controlar los segundos
}
 
/****** MIDE LA TEMPERATURA DE LA SOLUCIÓN NUTRIENTE *******************
** Sensor: DS18B20
** Alarma Max/Min: 18 grados y 35 grados
** Calefactor: SI por debajo de 16 grados NO por encima de 14 grados
************************************************************************/
void Temperatura_Nutriente(){
  wdt_reset(); // Borra el contador del wachdog
  sensor.requestTemperatures();
  temp = sensor.getTempCByIndex(0);
  dtostrf(temp, 2, 0, buffer);
  lcd.setCursor(5, 1);
  lcd.print(buffer);
  lcd.print((char)223);
  wdt_reset(); // Borra el contador del wachdog     
}
/****** PROGRAMA EL TIEMPO DE FUNCIONAMIENTO DE LA BOMBA****************
** Sensor: 
** Tiempo Max/Min: 1 minutos y 50 minutos
************************************************************************/
void Programar_Tiempo(void){
  byte contador = 0;
  bool bandera = false;
  programando = true;
  digitalWrite(alarma_temperatura, LOW); // Apagar indicador de alarma
  digitalWrite(relay_bomba, LOW); // Apagar la bomba de nutrientes (normal)
  //digitalWrite(relay_bomba, HIGH);  // Apagar la bomba de nutrientes (invertido)
  lcd.clear();
  lcd.setCursor(0,0); 
  lcd.print("TIEMPO DE ENCENDIDO");  
  lcd.setCursor(0,1); 
  lcd.print("Minutos:--"); 
 m1:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m1;
    }
 m2:
  if (digitalRead(prog)== HIGH){
    Potenciometro();
    wdt_reset(); // Borra el contador del wachdog
    lcd.setCursor(8, 1);
    lcd.print(buffer);
    goto m2;
    }
  if (digitalRead(prog)== LOW){
    tiempo_funcionamiento = M0;
    EEPROM.write(dir_ep, M0);  // Salva el valor de funcionamiento en EEPROM
    wdt_reset(); // Borra el contador del wachdog
    }
 m3:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m3;
    }
  lcd.setCursor(0,0); 
  lcd.print("TIEMPO DE APAGADO");  
 m4:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m4;
    }
 m5:
  if (digitalRead(prog)== HIGH){
    Potenciometro();
    wdt_reset(); // Borra el contador del wachdog
    lcd.setCursor(8, 1);
    lcd.print(buffer);
    goto m5;
    }
  if (digitalRead(prog)== LOW){
    tiempo_apagado = M0;
    EEPROM.write(dir_ep + 1, M0);   // Salva el valor de apagado en EEPROM
    wdt_reset(); // Borra el contador del wachdog
    }
 m6:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m6;
    }
  Pantalla();
  programando = false;    
}
/****** OBTIENE UN NÚMEROENTRE 1 Y 50 PARA CONFIGURAR LOS MINUTOS ******
** Sensor: 
** Tiempo Max/Min: 1 minutos y 50 minutos
************************************************************************/
void Potenciometro(void){
byte muestras=0;
unsigned int M1=0;
do{ 
  M1 += analogRead(A0);    // Lee el A/D y acumula el dato en M1
  muestras++;         // Incrementa el contador de muestras
  wdt_reset(); // Borra el contador del wachdog
}while(muestras <=49);  
  M0 = M1/50;
  M0 = map(M0, 0, 1023, 1, 50);  // Escalar lectura para minutos de 1 a 50
  dtostrf(M0, 2, 0, buffer);    // Preparar el dato para el LCD
  muestras =0;
  M1 = 0;
}
/************* FUNCIÓN PARA MOSTRAR LOS TEXTOS EN PANTALLA*************
** 
***********************************************************************/
void Pantalla(void){
  wdt_reset(); // Borra el contador del wachdog
  lcd.clear();
  lcd.setCursor(0,1); 
  lcd.print("Temp:   ");
  lcd.setCursor(0,3); 
  lcd.print("Activa: ");
  lcd.setCursor(7,3); 
  lcd.print(tiempo_funcionamiento);
  lcd.setCursor(12,3); 
  lcd.print("Apaga:");
  lcd.setCursor(18,3); 
  lcd.print(tiempo_apagado);
  lcd.setCursor(0,2); 
  lcd.print("Bomba:NO");
  lcd.setCursor(11,0); 
  lcd.print("Ambiente");
  lcd.setCursor(10,1); 
  lcd.print("Temp:");
  lcd.setCursor(10,2); 
  lcd.print("Hum:");
  lcd.setCursor(0,0); 
  lcd.print(" Solucion");
  lcd.setCursor(10,3); 
  lcd.print("~");
}
/*********** FUNCIÓN PARA LEER LAS VARIABLES ATMOSFERICAS *************
** 
***********************************************************************/
void Sensor_DHT22(void){
  t = dht.readTemperature(); // Lee sensor temperatura
  h = dht.readHumidity();  // Lee sensor humedad
  
  if (isnan(h) || isnan(t)) { // Verifica si error de lectura
              lcd.setCursor(14,1);
              lcd.print("Error");
              lcd.setCursor(14,2);
              lcd.print("Error");  
              }
            else{ // No hay error, procesa los datos
              
   dtostrf(t, 4, 1, Temperatura); // Procesa la temperatura 
   dtostrf(h, 4, 1, Humedad);     // Procesa la humedad
   lcd.setCursor(15,1);
   lcd.print(Temperatura);  // Muestra la temperatura
   lcd.print((char)223);
   lcd.setCursor(15,2);
   lcd.print(Humedad);    // Muestra la humedad
   lcd.print("%");
  
   }
 } 
 
//*************** Fin del archivo Firtec Argentina ********************