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.
Clase N°1: Introdución
- · 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:
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.
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:
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.
Código de Programación:
////////////////////////////////////////////////////////////////////////////////////////
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
//////////// Definición Pluviometro////////////
const int
SENSOR=3;
const int
umbraltiempo=300;
volatile int
ISRContador = 0;
int contador = 0;
float litros=0;
long tiempocontador=0;
long tiempohora =0;
/////////////// Sensor detector de Lluvia
/////////////
int analogValue;
////////////////Definición Anemometro
///////////////////////////
const int
RecordTime = 3;
//Definir el tiempo de medición (segundos)
const int
SensorPin = 2;
//Definir pin de interrupción (2, 3 , 18, 19, 20 ,22 @ Arduino Mega)
int InterruptCounter;
float WindSpeed;
/////////////////
Definición Veleta ///////////////////////////////////////////
int sensorvPin = A0;
int veleta = 0;
//////////////////Definición de DHT22/////////////////////////////////////77
#include <DHT.h>
#include <DHT_U.h>
int SENSORT=12;
int TEMPERATURA;
int HUMEDAD;
DHT dht(SENSORT,
DHT22);
/////////////////////Definición sensor Radiación Solar///////////////////////////////////
int lectura;
int Dato;
//////////////////////////////////////////////////////////////7
void setup(){
//////////// Void SETUP Pluviometro /////////////////////
pinMode(SENSOR, INPUT_PULLUP);
Serial.begin(9600);
attachInterrupt(digitalPinToInterrupt(SENSOR),contadorLitros,FALLING);
/////////////////// Void Setup Anemometro ////////////////////
pinMode(SensorPin, INPUT_PULLUP);
/////////////////
Void setup del DHT22 /////////////////////////
dht.begin();
///////////////// Void Setup del Sensor de
Radiación /////////////////
pinMode
(A1, INPUT);
}
//// Void del Pluviometro
/////////////////////////////////7
void contadorLitros()
{
if(millis()>(tiempocontador+umbraltiempo))
{
ISRContador++;
tiempocontador=millis();
Serial.println(ISRContador);
}
}
//////////////////////////////////////////////////////////////////////////
void loop()
{
////////////////////////////////cODIGO
Pluviometro /////////////////////////77
if
(millis()<tiempohora)
{
tiempohora=0;
}
if
(millis()-tiempohora>3600000UL)
{
tiempohora = millis();
litros=ISRContador * 0.27945;
Serial.print("Litros
por m2 caidos en una una Hora (L/m2): ");
Serial.println(litros);
ISRContador= 0;
contador= 0;
}
//////////////////////////////Codigo
Anemometro //////////////////////////////////////
meassure();
Serial.print("Velocidad
del Viento: ");
Serial.print(WindSpeed); //Velocidad en km/h
Serial.print(" km/h -
");
Serial.print(WindSpeed / 3.6); //Velocidad
en m/s
Serial.println("
m/s");
//////////////////// Codigo Veleta
//////////////////////////////////////////
veleta = analogRead(sensorvPin);
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 ((824
< veleta) && (veleta
< 842))
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("NNO
o 337.5°");
//337.5°
delay(500);
/////////////////////// Codigo del DHT22
//////////////////
TEMPERATURA= dht.readTemperature();
HUMEDAD= dht.readHumidity();
Serial.print("Temperatura:
");
Serial.print(TEMPERATURA);
Serial.println(
" °C");
Serial.print("Humedad:
");
Serial.println(HUMEDAD);
delay(500);
//////////////////// Codigo del sensor de
Radiación ////////////////////////////////
lectura= analogRead(A1);
Dato=(lectura*-0.75)+767,4;
Serial.print("Radiación
Solar: ");
Serial.print(Dato);
Serial.println(" W/m^2");
delay(2000);
////////////////// Codigo del Sensor dectector de
Lluvia //////////////////////////
analogValue=analogRead(2); //leemos A0
if (analogValue<300)
Serial.println("Lluvia
Intensa");
else
if (analogValue<500)
Serial.println("Lluvia
Moderada");
else
Serial.println("Lluvia
No Detectada");
delay(5000);
}
/////////////////////////Void
del Anemometro ///////////////////////////////////////
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°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:
A continuación, se muestra el código el cual usa las librerías “Ethernet.h” y “SPI.h “para trabajar con el módulo. Además, el código cuenta con una parte de Diseño en HTML para mostrar los datos de formas más ordenada:
Código de
Programación
///////////////////////////////////////////////////////////////////////////////////77
#include <SPI.h>
#include <Ethernet.h>
// Enter a
MAC address and IP address for your controller below.
// The IP
address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
IPAddress ip(192, 168, 1, 177);
// Initialize
the Ethernet server library
// with the
IP address and port you want to use
// (port 80
is default for HTTP):
EthernetServer
server(80);
////////////
Definición Pluviometro////////////
const int SENSOR=3;
const int umbraltiempo=300;
volatile int
ISRContador = 0;
int contador = 0;
float litros=0;
long tiempocontador=0;
long tiempohora =0;
/////////////// Sensor detector de Lluvia /////////////
int analogValue;
////////////////Definición Anemometro
///////////////////////////
const int
RecordTime = 3;
//Definir el tiempo de medición (segundos)
const int
SensorPin = 2;
//Definir pin de interrupción (2, 3 , 18, 19, 20 ,22 @ Arduino Mega)
int InterruptCounter;
float WindSpeed;
/////////////////
Definición Veleta ///////////////////////////////////////////
int sensorvPin = A0;
int veleta = 0;
//////////////////Definición de DHT22/////////////////////////////////////77
#include <DHT.h>
#include <DHT_U.h>
int SENSORT=12;
int TEMPERATURA;
int HUMEDAD;
DHT dht(SENSORT,
DHT22);
/////////////////////Definición sensor Radiación Solar///////////////////////////////////
int lectura;
int Dato;
//////////////////////////////////////////////////////////////7
void setup(){
Serial.begin(9600);
while (!Serial) {
; // wait for
serial port to connect. Needed for native USB port only
}
Serial.println("Ethernet WebServer Example");
//
start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
//
Check for Ethernet hardware present
if (Ethernet.hardwareStatus() == EthernetNoHardware) {
Serial.println("Ethernet shield was not found. Sorry, can't run without
hardware. :(");
while (true) {
delay(1); // do nothing, no point
running without Ethernet hardware
}
}
if (Ethernet.linkStatus() == LinkOFF) {
Serial.println("Ethernet cable is not connected.");
}
//
start the server
server.begin();
Serial.print("server
is at ");
Serial.println(Ethernet.localIP());
//////////// Void SETUP Pluviometro /////////////////////
pinMode(SENSOR, INPUT_PULLUP);
Serial.begin(9600);
attachInterrupt(digitalPinToInterrupt(SENSOR),contadorLitros,FALLING);
/////////////////// Void Setup Anemometro ////////////////////
pinMode(SensorPin, INPUT_PULLUP);
/////////////////
Void setup del DHT22 /////////////////////////
dht.begin();
/////////////////
Void Setup del Sensor de Radiación /////////////////
pinMode
(A1, INPUT);
}
//// Void del Pluviometro
/////////////////////////////////7
void contadorLitros()
{
if(millis()>(tiempocontador+umbraltiempo))
{
ISRContador++;
tiempocontador=millis();
Serial.println(ISRContador);
}
}
//////////////////////////////////////////////////////////////////////////
void loop()
{
////////////////////////////////cODIGO
Pluviometro /////////////////////////77
if
(millis()<tiempohora)
{
tiempohora=0;
}
if
(millis()-tiempohora>3600000UL)
{
tiempohora = millis();
litros=ISRContador * 0.27945;
Serial.print("Litros
por m2 caidos en una una Hora (L/m2): ");
Serial.println(litros);
ISRContador= 0;
contador= 0;
}
//////////////////////////////Codigo
Anemometro //////////////////////////////////////
meassure();
Serial.print("Velocidad
del Viento: ");
Serial.print(WindSpeed); //Velocidad en km/h
Serial.print(" km/h -
");
Serial.print(WindSpeed / 3.6); //Velocidad
en m/s
Serial.println("
m/s");
//////////////////// Codigo Veleta
//////////////////////////////////////////
veleta = analogRead(sensorvPin);
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 ((824
< veleta) && (veleta
< 842))
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("NNO
o 337.5°");
//337.5°
delay(500);
/////////////////////// Codigo del DHT22
//////////////////
TEMPERATURA= dht.readTemperature();
HUMEDAD= dht.readHumidity();
Serial.print("Temperatura:
");
Serial.print(TEMPERATURA);
Serial.println(
" °C");
Serial.print("Humedad:
");
Serial.println(HUMEDAD);
delay(500);
//////////////////// Codigo del sensor de
Radiación ////////////////////////////////
lectura= analogRead(A1);
Dato=(lectura*-0.75)+767,4;
Serial.print("Radiación
Solar: ");
Serial.print(Dato);
Serial.println(" W/m^2");
delay(2000);
////////////////// Codigo del Sensor dectector de
Lluvia //////////////////////////
analogValue=analogRead(2); //leemos A0
if (analogValue<300)
Serial.println("Lluvia
Intensa");
else
if (analogValue<500)
Serial.println("Lluvia
Moderada");
else
Serial.println("Lluvia
No Detectada");
delay(5000);
////////////////////////////////////////////////////////////////////////////////
EthernetClient
client = server.available();
if (client) {
Serial.println("new client");
// an HTTP request ends with a blank line
bool currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the HTTP request has ended,
// so you can send a reply
if (c == '\n' &&
currentLineIsBlank) {
// send a standard HTTP response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close"); // the connection will be closed after completion of the response
client.println("Refresh: 5"); //
refresh the page automatically every 5 sec
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<html>");
client.println("<head><title>
Datos de la Estacion </title>");
client.println("</head>");
client.println("<body>");
client.println("<div style='text-align:center;'>");
client.println("<h1>Estacion
Meteorologica</h1>");
client.println("<h3>Datos
del viento</h3>");
client.print("Velocidad
del Viento: ");
client.print(WindSpeed);
client.println(" Km/h");
client.println("<br
/>");
client.print("Direccion:
");
if
((745
< veleta) && (veleta
< 824))
client.print("N
o 0 °" );
//0°
if
((384
< veleta) && (veleta
< 425))
client.print("NNE
o 22.5 °");
//22.5°
if
((437
< veleta) && (veleta
< 483))
client.print("NE
o 45 °");
//45°
if
((78 < veleta)
&& (veleta < 87))
client.print("ENE
o 67.5 °");
//67.5°
if
((88 < veleta)
&& (veleta < 97))
client.print("E
o 90 °");//90°
if
((61 < veleta)
&& (veleta < 68))
client.print("ESE
o 112.5°");
//112.5°
if
((175
< veleta) && (veleta
< 193))
client.print("SE
o 135 °");
//135°
if
((120
< veleta) && (veleta
< 132))
client.print("SSE
o 157.5 °");
//157.5°
if
((272
< veleta) && (veleta<
301))
client.print("S
o 180 °");
//180°
if
((232
< veleta) && (veleta
< 256))
client.print("SSO
o 202.5 °");
//202.5°
if
((598
< veleta) && (veleta
< 661))
client.print("SO
o 225 °");
//225°
if
((568
< veleta) && (veleta
< 628))
client.print("OSO");
//247.5°
if
((897
< veleta) && (veleta
< 991))
client.print("O
o 270 °");
//270°
if
((824
< veleta) && (veleta
< 842))
client.print("ONO
o 292.5 °");
//292.5
if
((842
< veleta) && (veleta
< 930))
client.print("NO
o 315 °");//315°
if
((666
< veleta) && (veleta
< 737))
client.print("NNO
o 337.5 °");
//337.5°
client.println("<br
/>");
client.println("<h3>Datos
de Temperatura</h3>");
client.print("Temperatura:
");
client.print(TEMPERATURA);
client.print("℃");
client.println("<br
/>");
client.print("Radiacion
Solar: ");
client.print(Dato);
client.print("
W/m^2");
client.println("<br
/>");
client.print("Humedad:
");
client.print(HUMEDAD);
client.print("%");
client.println("<h3>Datos
de Lluvia</h3>");
client.print("Lluvia:
");
if
(analogValue<300)
client.print("Lluvia
Intensa");
else
if (analogValue<500)
client.print("Lluvia
Moderada");
else
client.print("Lluvia
No Detectada");
client.println("<br
/>");
client.print("Cantidad
caida en 1hora: ");
client.print(litros);
client.print(" L/m^2");
client.println("<br />");
client.println("<br /><br />");
client.println("</b></body>");
client.println("</html>");
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
} else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(0.1);
// close the connection:
client.stop();
Serial.println("client disconnected");
}
}
/////////////////////////Void
del Anemometro ///////////////////////////////////////
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++;
}
/////////////////////////////////////////////////////////////////////////
0 Comentarios