Estación Meterologica con Arduino

Una estación meteorológica es el lugar donde se realizan mediciones y observaciones puntuales de los diferentes parámetros meteorológicos utilizando para ello diferentes sensores, para así poder establecer el comportamiento atmosférico.

 En este curso de Estación Meteorologica con Arduino cuenta con 10 clases en donde analizaremos y programaremos cada sensor, como asi tambien la puesta en Marcha de la estación y la transferencia de Datos:

Clase N°1: Introdución


En este primer video se estudia las partes de una estación meteorologica. La estación cuenta con los siguientes sensores:

  • ·         Anemómetro: Sensor que nos permite saber la velocidad del viento en Km/h
  • ·         Veleta: Sensor que nos permite conocer la dirección del Viento. (N,S,E,O)
  • ·         Detector de Lluvia: Sensor que nos permite detectar la presencia de lluvia
  • ·         Pluviómetro: Sensor que nos mide la cantidad de lluvia caída (L/m^2)
  • ·         Sensor de Humedad: Sensor que nos permite conocer la humedad del ambiente.
  • ·         Sensor de Temperatura: Sensor que nos permite saber la temperatura en °C
  • ·         Sensor de Redición Solar: Sensor que nos permite medir la radiación solar en W/m^2

Clase N°2: Sensor detector de Lluvia FC-37


Este tipo de sensores detectan la presencia de lluvia por la variación de conductividad del sensor al entrar en contacto con el agua. Existen varios modelos de sensores similares, pero el que usamos en el proyecto es el Sensor FC-37 y el módulo YL-83.


Conexión del Sensor FC-37:

El sensor no tiene polaridad, por lo que puede ser conectada en cualquier sentido al módulo. Podemos mediante el módulo leer valores tanto Analógicos o Digitales: Los valores analógicos medidos varían desde 0 para una placa totalmente empapada, a 1023 para una placa totalmente seca.


La salida digital se dispara cuando el valor de humedad supera un cierto valor, que ajustamos mediante el potenciómetro. Por tanto, obtendremos una señal LOW en ausencia de lluvia, y HIGH con presencia de lluvia.

Código de Programación:

///////////////////////////////////////////////////////////////////////////////////////////

int analogValue;

bool digitalValue;

void setup() {

  Serial.begin(9600);   //iniciar puerto serie

}

void loop(){

  analogValue=analogRead(0); //leemos A0

  if (analogValue<300)

  Serial.println("Lluvia Intensa");

  else if (analogValue<500)

    Serial.print("Lluvia Moderada");

    else

    Serial.print("Lluvia No Detectada");

    digitalValue= digitalRead(9);

    if (digitalValue ==HIGH)

    Serial.println(">>> NO LLUVIA");

    else

    Serial.println(">>> LLUVIA");

  delay(2000);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Clase N°3: Pluviómetro Digital


El pluviómetro es un instrumento que se emplea en las estaciones meteorológicas para la recogida y medición de la precipitación. Se usa para medir la cantidad precipitaciones caídas en un lugar durante un tiempo determinado. La cantidad de agua caída se expresa en litros o milímetros caídos por metro cuadrado.

Esquema de Conexión:

El esquema de conexión del Pluviómetro digital con el Arduino es el siguiente:


Como se puede observar es un circuito bastante sencillo, ya que cuenta solamente con un interruptor que se cierra cada vez que un imán pasa frente de él. Para ello en Arduino usaremos la función INPUT_PULLUP.


Código de Programación:

Para el Código del pluviómetro se usara la función “ attachInterrupt”, que es una función para las interrupciones en Arduino. Arduino dispone de dos tipos de eventos en los que definir interrupciones. Por un lado, tenemos las interrupciones de timers (que veremos en su momento al hablar de temporizadores. Por otro lado, tenemos las interrupciones de hardware, que responden a eventos ocurridos en ciertos pines físicos.

Entonces el código que vamos a usar es el siguiente:

/////////////////////////////////////////////////////////////////////////////////////

const int SENSOR=3;

const int umbraltiempo=300;

volatile int ISRContador = 0;

int contador = 0;

float litros=0;

long tiempocontador=0;

long tiempohora =0;

 

void setup(){

   pinMode(SENSOR, INPUT_PULLUP);

   Serial.begin(9600);

   attachInterrupt(digitalPinToInterrupt(SENSOR),contadorLitros,FALLING);

}

void contadorLitros()

{

 if(millis()>(tiempocontador+umbraltiempo))

  {

    ISRContador++;

    tiempocontador=millis();

      Serial.println(ISRContador);

  }

}

void loop()  {

 if (millis()tiempohora)

    {

    tiempohora=0;

    }

 if (millis()-tiempohora3600000UL) { 

    tiempohora = millis();

    litros=ISRContador  1.5;

    Serial.print(Litros por m2 caidos en una una Hora (Lm2) );

    Serial.println(litros);

    ISRContador= 0;

    contador= 0;

  }

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Clase N°4: Anemómetro

El Anemómetro de Hélices es un instrumento que se utiliza para medir la velocidad del viento y se encontrará fijo en nuestra estación Meteorológica, con el tomaremos datos del viento expresados en Km/h. 


El anemómetro emite un pulso corto con cada revolución, que un microcontrolador cuenta durante un cierto período de tiempo. La velocidad del viento se puede medir usando el factor de conversión apropiado. El Arduino recibe un pulso por revolución. Según la hoja de datos del fabricante, esta establece que una revolución por segundo da como resultado una velocidad del viento de 2,4 km/h. Para ello, el software simplemente tendría que sumar los impulsos que llegan en exactamente un segundo y multiplicarlos por un factor de 2,4. Sin embargo, dado que un tiempo de medición de un segundo apenas ofrece resultados utilizables, debe aumentarse a unos pocos segundos. Tres segundos son suficientes para una prueba. En uso productivo, un tiempo de medición de 30 segundos o un minuto daría muy buenos resultados. Por lo tanto, la tarea del software es contar los pulsos individuales y dividirlos por el tiempo de medición. El resultado debe entonces ser multiplicado por un factor de 2.4. El resultado es la velocidad del viento en kilómetros por hora.



Esquema de Conexión:

Como se está trabajando con interrupciones en Arduino, sé puede usar únicamente el pin 2 y 3, en este caso se usará el pin 3, es por ello por lo que el circuito de conexión es el siguiente:

 


Dado que básicamente es solo un interruptor, el anemómetro está conectado de manera similar a un botón. La resistencia de 10K aquí actúa como un pull-down, llevando el nivel de circuito abierto a tierra. El capacitor paralelo a la resistencia se usa para absorber temporalmente el voltaje de la entrada digital. 

Código de Programación:

////////////////////////////////////////////////////////////////////////////////

const int RecordTime = 3; //Definir el tiempo de medición (segundos)

const int SensorPin = 3;  //Definir pin de interrupción (2 o 3 @ Arduino Uno)

int InterruptCounter;

float WindSpeed;

void setup()

{

  pinMode(SensorPin, INPUT_PULLUP);

  Serial.begin(9600);

}

void loop() {

  meassure();

  Serial.print("Wind Speed: ");

  Serial.print(WindSpeed);       //Velocidad en km/h

  Serial.print(" km/h - ");

  Serial.print(WindSpeed / 3.6); //Velocidad en m/s

  Serial.println(" m/s");

}

void meassure() {

  InterruptCounter = 0;

  attachInterrupt(digitalPinToInterrupt(SensorPin), countup, RISING);

  delay(1000 * RecordTime);

  detachInterrupt(digitalPinToInterrupt(SensorPin));

  WindSpeed = (float)InterruptCounter / (float)RecordTime * 2.4;

}

void countup() {

  InterruptCounter++;

}

///////////////////////////////////////////////////////////////////////////


Clase N°5: Veleta


La veleta se emplea para conocer la Dirección del viento, la misma se compone de 8 interruptores cada uno conectado a una resistencia diferente. Un imán de aleta puede cerrar dos interruptores a la vez lo que permite hasta 16 posiciones diferentes.


Esquema de Conexión:

Se trata de un simple divisor resistivo que nos da un valor de tensión diferente según la posición de la veleta. Este valor lo medimos con el ADC del microcontrolador para obtener la dirección del viento. En la siguiente figura podemos ver cómo está configurado el divisor resistivo de la veleta.


Cuando el imán cierra 2 interruptores a la vez la vez el resultado es de dos resistencias en paralelo lo que nos permite tener hasta 16 direcciones diferentes. En la siguiente tabla se muestra un ejemplo de lo que obtendríamos a la salida si alimentamos el sensor con 5V y añadimos una resistencia R de 10K.



En el caso que se quiera trabajar con los 3.3V del Arduino, se usara la siguiente tabla:



La conexión de la Veleta al Arduino es la siguiente:




Código de Programación:

////////////////////////////////////////////////////////////////////////////////////////

int sensorPin = A0;    // select the input pin for the potentiometer
int veleta = 0;  // variable to store the value coming from the sensor
 
void setup() {
Serial.begin(9600);
}
 
void loop() {
  // read the value from the sensor:
  veleta = analogRead(sensorPin);
 
   Serial.print("direccion=");
  
    if ((745 < veleta) && (veleta < 824)) 
    Serial.println("N o 0°" ); //0°
 
  if ((384 < veleta) && (veleta < 425))
  Serial.println("NNE o 22.5°"); //22.5°
 
  if ((437 < veleta) && (veleta < 483))
    Serial.println("NE o 45°"); //45°
 
 if ((78 < veleta) && (veleta < 87))
 Serial.println("ENE o 67.5°"); //67.5°
 
  if ((88 < veleta) && (veleta < 97))
    Serial.println("E o 90°");//90°
 
  if ((61 < veleta) && (veleta < 68))
    Serial.println("ESE o 112.5°"); //112.5°
 
if ((175 < veleta) && (veleta < 193))
    Serial.println("SE o 135°"); //135°
 
if ((120 < veleta) && (veleta < 132))
    Serial.println("SSE o 157.5°"); //157.5°
 
if ((272 < veleta) && (veleta< 301))
    Serial.println("S o 180°"); //180°
 
if ((232 < veleta) && (veleta < 256))
    Serial.println("SSO o 202.5°"); //202.5°
 
if ((598 < veleta) && (veleta < 661))
    Serial.println("SO o 225°"); //225°
 
  if ((568 < veleta) && (veleta < 628))
    Serial.println("OSO"); //247.5°
 
if ((897 < veleta) && (veleta < 991))
    Serial.println("O o 270°"); //270°
 
if ((785 < veleta) && (veleta < 868))
    Serial.println("ONO o 292.5°"); //292.5
 
if ((842 < veleta) && (veleta < 930))
    Serial.println("NO o 315°");//315°
 
if ((666 < veleta) && (veleta < 737))
    Serial.println("NNOo 337.5°"); //337.5°
      delay(500);
}

/////////////////////////////////////////////////////////////////////////////////////////////

 

Clase N°6:Sensor de Tempertura y Humedad DHT22




El sensor de temperatura y humedad que usamos en la estación meteorológica es el Sensor DHT22 el cual puede medir Temperatura y Humedad al mismo tiempo.

Si leemos la hoja de datos de este sensor, tendremos información sobre sus pines (Fig.21), las tensiones de alimentación y los rangos de Temperatura y Humedad el cual este seno puede medir son:

·         Temperatura: -40 a 125°C (+-0.5°C)

·         Humedad: 0 a 100% +- 2.5%

·         Voltaje: 3V a 5.5V

 

Circuito del Sensor DHT22:

El circuito del sensor DTH22 conectado a Arduino se muestra a continuación:

El pin VCC del sensor lo conectamos a los 5v del Arduino, el Pin de Dato se conecta al pin 2 del Arduino y además en este pin de Dato se conecta una resistencia de 4.7 K-ohms y por último el Pin GND se conecta al Pin GND de Arduino.


Código de Programación:

/////////////////////////////////////////////////////////////////////////////////

#include <DHT.h>

#include <DHT_U.h>

int SENSOR=2;

int TEMPERATURA;

int HUMEDAD;

DHT dht(SENSOR, DHT22);

void setup() {

 Serial.begin (9600);

 dht.begin();

}

void loop() {

 TEMPERATURA= dht.readTemperature();

 HUMEDAD= dht.readHumidity();

 Serial.print("Temperatura: ");

 Serial.print(TEMPERATURA);

 Serial.print(" Humedad: ");

 Serial.println(HUMEDAD);

 delay(500);

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 

Clase N°7: Sensor de Radiación Solar SUF268J001


El Sensor solar SUF268J001 es el sensor que nos permitirá conocer la radiación solar en los destiladores solares. La Radiación Solar es la energía emitida por el sol en forma de radiación electromagnética que llega a la atmósfera. Se mide en superficie horizontal, mediante el sensor de radiación o piranómetro, que se sitúa orientado al sur y en un lugar libre de sombras.



Código de Programación:

//////////////////////////////////////////////////////////////////////

int lectura;

int Dato;

void setup() {

 pinMode (A0, INPUT);

 Serial.begin(9600);

}

void loop() {

  lectura= analogRead(A0);

  Dato=(lectura*-0.75)+767,4;

  Serial.print(Dato);

  Serial.println(" W/m^2");

delay(2000);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////



Clase N°8: Diseño de Soportes y ubicación de Sensores




En este video respondemos algunas cosultas y veremos los soportes del Sensor de Radiación y el sensor Dectector de Lluvia como asi tambien la ubicación de los mismos. A continuación se puede descargar los soportes en 3d los cuales estan listos para impimirse. ¡Recuerde que el filamento que se uso es el tipo PET!




/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



Clase N°9: Programación de Estación Meteorologica con Arduino



En este video les muestro el circuito y la programación completa de una estación Meteorologica usando Arduino. A continuación se muestra el circuito que se construyo para conectar los sensores:





Clase N°10: Transmisión de Datos de Estación Meteorológica




Una vez realizado la adquisición de datos, para la transferir los mismos, tanto de la estación Meteorológica como los sensores de peso y Temperatura de los destiladores, se usará un módulo Ethernet ENC28J60 el cual se conecta a la Red para enviar dichos datos a una base Datos.

El módulo Ethernet se conecta sobre la placa de Arduino Mega y se procede a conectar los circuitos sobre él. En la siguiente imagen se muestra como se conecta el circuito de la estación meteorológica con el Módulo: