Estação Meteorológica (

[c3dr1c]

Olá pessoal,
Já passaram uns quantos anos que deixei de vir aqui ao forum... mas agora voltei para partilhar um projecto simples e pedir algumas ideias. Estou a construir uma estação meteorológica para colocar num observatório astronómico (futuramente).
_________________________

Para monitorizar as condições climatéricas adquiri uma estação meteorológica, onde utilizei vários sensores que esta possui e alterei algumas partes estruturais de modo a instalar novo sensores.

Basicamente é constituída pelos seguintes sensores originais:
– Velocidade do Vento; Direcção do Vento; Caudal de Precipitação; Painel Fotovoltaico.

Adicionados:
– Temperatura; Humidade; Pressão atmosférica; Sensores de chuva; Temperatura IR; Luz ambiente.

Os sensores mais importantes são sem dúvidas os sensores de chuva que permitem detectar pequenas gotas de água, alertando para o caso de o observatório estar aberto, que este deve ser fechado o mais rapidamente possível.

Os sensor de temperatura IR permite medir a temperatura atmosférica (dependente do seu alcance) indicando assim a densidade de nuvens existentes no local.

Tanto o sensor de luz ambiente e o painel fotovoltaico permitem indicar a escuridão existente no local. Sendo assim é possível determinar quando começa o período nocturno astronómico e quando este acaba. Se estes forem sensíveis o suficiente, será possível monitorizar o luar nocturno.

Os sensores de velocidade e direcção do vento podem dar algumas indicações referentes a vibrações mecânicas  que o vento poderá provocar no observatório. Como o telescópio estará colocado sobre um pilar independente da estrutura do observatório, em principio este não será afectado. Contudo se a direcção do vento for de encontro à abertura da cúpula, poderá provocar vibrações no tubo óptico que afectarão os dados recolhidos.

Os sensores de temperatura, humidade e pressão atmosférica indicam o estado geral das condições climatéricas. São importantes na dedução das condições de visibilidade dos objectos astronómicos.

O sensor de caudal de precipitação não terá grande interesse para a recolha de dados astronómicos, é apenas uma extra na estação meteorológica.
_________________________

Na seguinte imagem podem visualizar onde estão instalados os seguintes sensores:

1- Direcção do Vento
2- Sensores de chuva
3- Caudal de Precipitação
4- Velocidade do Vento
5- Temperatura IR (MLX90614)
6- Painel Fotovoltaico
7- Luz ambiente (TSL2561)
8- Temperatura / Humidade (AM2302 DHT22)
8- Pressão atmosférica (BMP180)


_________________________

Localização dos sensores de temperatura / humidade / pressão atmosférica:




_________________________

Código simplificado de teste de leitura dos sensores (Arduino IDE):

Código: [Seleccione]

#include "cactus_io_DHT22.h"
#include <Wire.h>
#include <Adafruit_BMP085.h>
#include <Adafruit_MLX90614.h>
#define DHT22_PIN 2
Adafruit_BMP085 bmp;
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
DHT22 dht(DHT22_PIN);
int WindSpeedPin = 3;

int WindDirPin = A0;
float WindSpeed;
int WindCount;
int WindDir;
float WindDeg;
long Timer;
long TimerStart;
int CounterCond;

int RainAn;
int RainDig;

void setup() {
  pinMode(WindSpeedPin, INPUT);
  pinMode(WindDirPin, INPUT);
  Serial.begin(9600);
  CounterCond=0;
  dht.begin();
  bmp.begin();
  mlx.begin(); 
}

void loop() {
//  FWindSpeed();
//  FWindDir();
  FTempHum();
  FPressure();
  FIR();
//  FRain();

//  Serial.print(WindSpeed); Serial.print("  "); Serial.println(WindDeg);
    Serial.print(dht.temperature_C); Serial.print(","); Serial.println(dht.humidity);
//  Serial.print(","); Serial.print(bmp.readTemperature()); Serial.print(","); Serial.print(bmp.readPressure());Serial.print(","); Serial.print(mlx.readAmbientTempC());Serial.print(","); Serial.println(mlx.readObjectTempC());
//  Serial.print(RainAn); Serial.print("  "); Serial.println(RainDig);
  delay(250);
}


void FRain(){
  RainAn=analogRead(A1);
  RainDig=digitalRead(7);

}

void FIR(){
  mlx.readAmbientTempC();
  mlx.readObjectTempC();

}


void FPressure(){
  bmp.readTemperature();
  bmp.readPressure();

}

void FTempHum(){
  dht.readHumidity();
  dht.readTemperature();
}

void FWindSpeed() {
  TimerStart=millis();
  WindCount=0;
  while(Timer<10000){
    Timer=millis()-TimerStart;
    if(digitalRead(WindSpeedPin)==1&&CounterCond==0){
     WindCount++;
     CounterCond=1;
     }
    if(digitalRead(WindSpeedPin)==0){
     CounterCond=0;
    }
  }
  WindSpeed=WindCount/10.0*2.4;
  Timer=0;
}

void FWindDir() {
  WindDir = analogRead(WindDirPin);
  if(WindDir<70)
    WindDeg=112.5;
  else if (WindDir<89)
    WindDeg=67.5;
  else if (WindDir<97)
    WindDeg=90.0;
  else if (WindDir<132)
    WindDeg=157.5;
  else if (WindDir<189)
    WindDeg=135.0;
  else if (WindDir<248)
    WindDeg=202.5;
  else if (WindDir<291)
    WindDeg=180.0;
  else if (WindDir<410)
    WindDeg=22.5;
  else if (WindDir<465)
    WindDeg=45.0;
  else if (WindDir<604)
    WindDeg=247.5;
  else if (WindDir<635)
    WindDeg=225.0;
  else if (WindDir<707)
    WindDeg=337.5;
  else if (WindDir<791)
    WindDeg=0.0;
  else if (WindDir<832)
    WindDeg=292.5;
  else if (WindDir<950)
    WindDeg=270.0;
  else if (WindDir<983)
    WindDeg=315.0;
}

[vasco]

Gosto do material... :-)

Mas mais importante, como vais tratar os dados ?
Hoje em dia com os esp8266 é mais simples do que costumava ser, mas desde gravar para um cartão SD até portas serie há uma serie de opções.

[c3dr1c]

Olá. Os dados ainda não sei, mas agora tenho um problemazito maior para resolver:

É o seguinte: queria medir a velocidade do vento durante x segundos (por exemplo 10 segundos).
Tenho um anemometer que basicamente é um switch sensor. Queria contar dentro de um while loop quantas vezes havia um rising edge.
Vou ter de resolver o problem de debounce, em que posso usar um condensador mas acho que mais simples é programando.
Por outro lado poderia usar interrupt pins... estou um pouco baralhado quanto à metodologia a utilizar.

Que aconselham?


EDIT: Eu já resolvi o problema usando este código que faz debounce... Funciona, só que eu nunca sei se é o mais apropriado

Código: [Seleccione]

int WindSpeedPin = 3;
int WindCount;
float WindSpeed;

long Timer;
long TimerStart;

unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;
int WindState;
int WindReading;
int lastWindState = LOW;

void FWindSpeed() {
  WindCount = 0;
  TimerStart=millis();
  while(Timer<1000){
    Timer=millis()-TimerStart;
    WindReading = digitalRead(WindSpeedPin);
    if (WindReading != lastWindState) {
      lastDebounceTime = millis();
    }
    if ((millis() - lastDebounceTime) > debounceDelay) {
      if (WindReading != WindState) {
        WindState = WindReading;
        if (WindState == HIGH) {
          WindCount++;
        }
      }
    }
    lastWindState = WindReading;   
  }
  WindSpeed=WindCount/1.0*2.4;
  Timer=0;
}

[jm_araujo]

Debounce por hardware vs software é um assunto muito debatido, e uma boa maneira de começar uma flame war de forma disfarçada.
Faz como te der mais jeito, o que importa é que funcione.

A maneira da moda de tratar os dados é enviar para uma bd "InfluxDB" e apresentar os dados num dashboard "Grafana". Metes tudo num servidor, que pode ser um RPi, e os resultados ficam 5* (aspas para os termos a meter no google).

Exemplo do que é possível: https://www.circuits.dk/datalogger-example-using-sense-hat-influxdb-grafana/
A única programação do exemplo (em python) é para ler os dados dos sensores e metê-los na BD, que também pode ser feito desde fora do rpi por um pedido HTTP, por exemplo desde um ESP8266

[c3dr1c]

Eu como vou ter de ter um PC no meu observatório posso obter os dados via séria do arduino, armazenar numa base de dados interna, que depois através de internet envia para um server e mostra numa webpage Como por enquanto não tenho o observatório nem o PC, estava a pensar ligar o arduino a um RPi... mas ainda não vi nada sobre isso... Desde já obrigado pelas ajudas neste campo.

Actualizei o código e já faço as leituras como queria: a ideia implementada basicamente consiste em um while loop, que quantifica quantas vezes o switch sensor do anemômetro e do sensor de pluviosidade fazem um "rising edge". Debounce programado Também descobri que a datasheet do sensor da direcção do vento tem um valor errado que andava a me dar cabo do juízo Já agora em anexo deixo a datasheet do anemômetro, sensor da direcção do vento e do sensor de pluviosidade.

Agora falta só adicionar 2 sensores ao código: leitura de um painel fotovoltaico e dos sensores de chuva.

- Quanto ao painel fotovoltaico não tenho as specs dele, mas vou tentar medir o máximo output que ele fornece. Estava a pensar em fazer um divisor de tensão simples para ler a tensão fornecida. Por outro lado, gostaria de medir o quão escura é a noite... mas acho que para isso preciso de algo mais elaborado, com uns ampops talvez. Alguém tem alguma ideia?

- Quanto aos sensores de chuva, como tenho dois, vou programar um deles para alerta apenas com pouco pingos e outro para alerta com maior quantidade de pingos.

Código Actual:

Código: [Seleccione]

#include "cactus_io_DHT22.h"
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>
#include <Adafruit_BMP085.h>
#include <Adafruit_MLX90614.h>
#define DHT22_PIN 2
#define INTERRUPT_INPUT 2
Adafruit_BMP085 bmp; //pin
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
DHT22 dht(DHT22_PIN);
Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345);

long Timer;
long TimerStart;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;
unsigned long lastDebounceTime2 = 0;
unsigned long debounceDelay2 = 50;

int WindSpeedPin = 3;
int WindCount;
float WindSpeed;
int WindState;
int WindReading;
int lastWindState = LOW;

int RainPin = 7;
int RainCount;
float RainGauge;
int RainState;
int RainReading;
int lastRainState = LOW;

int WindDirPin = A0;
int WindDir;
float WindDeg;

float Temp;
float Temp2;
float Temp3;
float Humidity;
float Pressure;
float TempIR;
float LuxLight;

void setup() {
  pinMode(WindSpeedPin, INPUT);
  pinMode(WindDirPin, INPUT);
  Serial.begin(9600);
  dht.begin();
  bmp.begin();
  mlx.begin();
  tsl.begin();
  tsl.enableAutoRange(true);
  tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);
}

void loop() {
  FWhileLoop();
  FWindDir();
  FTempHum();
  FPressure();
  FIR();
  FLux();
 
  Serial.print("Wind Speed: "); Serial.print(WindSpeed); Serial.print(" km/h"); Serial.print(", "); Serial.print("Wind Direction: "); Serial.print(WindDeg); Serial.println("º");
  Serial.print("Temperature: "); Serial.print(Temp); Serial.print("ºC"); Serial.print(", "); Serial.print("Humidity: "); Serial.print(Humidity); Serial.println("%");
  Serial.print("Temperature: "); Serial.print(Temp2); Serial.print("ºC"); Serial.print(", "); Serial.print("Pressure: "); Serial.print(Pressure); Serial.println(" hPa");
  Serial.print("Temperature: "); Serial.print(Temp3); Serial.print("ºC"); Serial.print(", "); Serial.print("IR Temperature: "); Serial.print(TempIR); Serial.println("ºC");
  Serial.print("Light: "); Serial.print(LuxLight); Serial.println(" lux");
  Serial.print("Rain: "); Serial.print(RainGauge); Serial.println(" mm");
  Serial.println("--------------------");
}

void FTempHum(){
  dht.readHumidity();
  dht.readTemperature();
  Humidity = dht.humidity;
  Temp = dht.temperature_C;
}

void FPressure(){
  Temp2 = bmp.readTemperature();
  Pressure = bmp.readPressure()/100.0;
}

void FIR(){
  Temp3 = mlx.readAmbientTempC();
  TempIR = mlx.readObjectTempC();
}

void FLux(){
  sensors_event_t event;
  tsl.getEvent(&event);
  LuxLight = event.light;
}

void FWhileLoop() {
  WindCount = 0;
  RainCount = 0;
  TimerStart=millis();
  while(Timer<5000){
    Timer=millis()-TimerStart;
    WindReading = digitalRead(WindSpeedPin);
    RainReading = digitalRead(RainPin);
    if (WindReading != lastWindState) {
      lastDebounceTime = millis();
    }
    if (RainReading != lastRainState) {
      lastDebounceTime2 = millis();
    }
    if ((millis() - lastDebounceTime) > debounceDelay) {
      if (WindReading != WindState) {
        WindState = WindReading;
        if (WindState == HIGH) {
          WindCount++;
        }
      }
    }
    if ((millis() - lastDebounceTime2) > debounceDelay2) {
      if (RainReading != RainState) {
        RainState = RainReading;
        if (RainState == HIGH) {
          RainCount++;
        }
      }
    }
    lastWindState = WindReading;
    lastRainState = RainReading;   
  }
  WindSpeed=WindCount/5.0*2.4;
  RainGauge=RainCount*0.2794;
  Timer=0;
}

void FWindDir() {
  WindDir = analogRead(WindDirPin);
  if(WindDir>32&&WindDir<73)
    WindDeg=112.5;
  else if (WindDir>73&&WindDir<87)
    WindDeg=67.5;
  else if (WindDir>87&&WindDir<109)
    WindDeg=90.0;
  else if (WindDir>109&&WindDir<155)
    WindDeg=157.5;
  else if (WindDir>155&&WindDir<214)
    WindDeg=135.0;
  else if (WindDir>214&&WindDir<266)
    WindDeg=202.5;
  else if (WindDir>266&&WindDir<348)
    WindDeg=180.0;
  else if (WindDir>348&&WindDir<436)
    WindDeg=22.5;
  else if (WindDir>436&&WindDir<532)
    WindDeg=45.0;
  else if (WindDir>532&&WindDir<616)
    WindDeg=247.5;
  else if (WindDir>616&&WindDir<668)
    WindDeg=225.0;
  else if (WindDir>668&&WindDir<746)
    WindDeg=337.5;
  else if (WindDir>746&&WindDir<808)
    WindDeg=0.0;
  else if (WindDir>808&&WindDir<858)
    WindDeg=292.5;
  else if (WindDir>858&&WindDir<917)
    WindDeg=315.0;
  else if (WindDir>917&&WindDir<985)
    WindDeg=270.0;
}

EDIT: é verdade, esqueci-me que ainda tenho isto para adicionar à estação:

[c3dr1c]

Boas pessoal,

Já consigo enviar os dados que vêm do arduino  para uma DB online (bluehost), através de um RPi:



Fica aqui o código muito simples para quem quiser ter uma ideia... Precisa de ser refinado e completado. Depois de ter o código impec, explico a ideia por de trás...

Código: [Seleccione]

import serial, string, MySQLdb, time, datetime

timestamp = datetime.datetime.now()

ser = serial.Serial('/dev/ttyACM0',9600,8,'N',1,timeout=5)

db = MySQLdb.connect(host="xxxxxx", user="xxxxxx", passwd="xxxxxx", db="xxxxxx")
cur = db.cursor()

while True:
    if ser.in_waiting > 0:
        arduinoData = ser.readline()
        checkBeginString = arduinoData[:2]
        checkEndString = arduinoData[-2:]

        if checkBeginString == 'BL' and checkEndString == 'EL':
            splitData = arduinoData.split(';')

            WindSpeed = float(splitData[1])
            WindDeg = splitData[2]
            Temp = splitData[3]
            Humidity = splitData[4]
            Temp2 = splitData[5]
            Pressure = splitData[6]
            Temp3 = splitData[7]
            TempIR = splitData[8]
            LuxLight = splitData[9]
            RainGauge = splitData[10]
            RainDetectorValue1 = splitData[11]
            RainAlarm1 = splitData[12]
            RainDetectorValue2 = splitData[13]
            RainAlarm2 = splitData[14]

             
            cur.execute("INSERT INTO Data (DateTime,WindSpeed,WindDeg,Temp,Humidity,Temp2,Pressure,\
                        Temp3,TempIR,LuxLight,RainGauge,RainDetectorValue1,RainAlarm1,RainDetectorValue2,RainAlarm2)\
                        VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)", (timestamp,WindSpeed,WindDeg,Temp,\
                                                                               Humidity,Temp2,Pressure,Temp3,TempIR,\
                                                                               LuxLight,RainGauge,RainDetectorValue1,\
                                                                                 RainAlarm1,RainDetectorValue2,RainAlarm2))
            db.commit()
           
cur.close()
db.close()
ser.close()
Se tudo correr bem e tiver tempo, nos próximo dias já soldo umas cenas, meto a estação na rua, adquiro dados a longo prazo e faço uns plots no meu website

[c3dr1c]

Meti a estação na rua (excepto os micros).

Duas falhas de design:
> Falta de conectores entre os sensores e a cablagem que leva os dados aos micros;
> Sensores de chuva em base com baixo relevo onde acumula água.

[c3dr1c]

Então começam alguns desafios.

Primeiro: poupar energia! Estava a pensar que provavelmente posso ter o arduino a dormir e utilizar o RPi para o acordar a cada  10min, para ele ler os sensores e voltar a dormir, utilizando um interrupt. Que acham da ideia? Existe algo mais eficaz? Quanto ao RPi, não sei se o consigo mandar dormir e também acordar a cada x tempo...

Com isto tenho outro problema. Os sensores são de leitura rápida... Excepto o da velocidade do vento, que fica 10s a quantificar e depois dá-me uma média (como actua com switch's, se o vento estiver franquinho, demora a dar umas voltas). Mas e quanto ao sensor de pluviosidade? Este vai actuar apenas de vez em quando.... Se calhar também devia utilizar um interrupt para ir quantificando cada vez que o switch do sensor pluviométrico actua... que dizem?

Cumps e obrigado.

[c3dr1c]

Vou colocar este projecto por aqui. Como tenho tempo limitado e já me estou a desviar do seu propósito, fica em stand-by até ter o observatório a funcionar. O básico está feito. Segui o conselho do jm_araujo e estive a brincar com o Grafana. Muito giro e user friendly.

Ficam aqui umas últimas fotos, da modificação que fiz aos sensores de chuva para não acumularem água, do Grafana e de umas fotos nocturnas que fiz com uma câmara RPi NoIR.

Melhorias a implementar:
> Instalar conectores entre sensores - cablagem - micros;
> Colocar sistema de desembaciamento da câmara RPI;
> Mandar dormir o RPi e o Arduino quando não estão a ser utilizados;
> Implementar sistema de Log;
> Implementar sensor de qualidade do céu nocturno;
> Implementar circuito de interpretação da célula fotovoltaica;
> Calibrar sensores;
> Cálculo de alertas e algumas infos úteis, como o ponto de orvalho.

[jm_araujo]

Está a ficar com muito boa pinta!

É de mim, ou os resultados das fotos da câmara do Rpi são bem bons? Puxando pelo contraste e brilho, com 5" já tens algumas estrelas visíveis, e com 10" já tens o campo cheio! A de 20" está muito semelhante à de 10", não haverá algum limite no tempo de captura?

Desconfio também que a de 1" tenha algum erro e não tenha gravado, a imagens está toda a preto, nem o mínimo ruído.

[Njay]

Tá muito fixe, sim sr., 5*

Olhá Ursa Maior.

Com pouco esforço consegues melhorar as (astro)fotos.

Tubo negro ao redor da camara para não apanhar "luz lateral".

Fazes uma exposição com a mesma duração da foto que vais tirar, mas com a lente completamente tapada. A  isto chama-se penso que "dark field". Depois tiras a foto e subtrais-lhe o dark field. Isto remove artefactos do sensor.

Nas exposições mais curtas podes tirar 2 ou mais fotos e fazer uma média das várias fotos. Isto remove o ruído.

Para melhores resultados, aplicar as 3 técnicas em simultâneo.

[brunus]

Amigo c3dr1c, onde arranjou essa cúpula transparente? Faz uma esfera certa se se unir a outra igual? O aro possui furação?

[TigPT]

Está a ficar ótimo.

A minha dica é que a Calibrar Sensores, o faças de forma a que possas remotamente calibrar os mesmos facilmente. Algum ficheiro de configs na cloud que é feito o download frequentemente ou algo do género. Ficas com mais facilidade de no futuro fazer calibrações.