Arduino Wetter Station

Ich habe in letzter Zeit etwas mit dem Arduino gespielt und habe beschloßen eine Wetterstation zu bauen. Das Resultat ist im Bild zu sehen. Unten ist das eigentliche Arduino zu sehen, oben drauf ist das Datenshield auf dem 2 Temperatursensoren, Lichtsensor, Drucksensor und Fechtesensor ( zusammen 1 Sensor) von mir verlötet wurden.

Arduino Wetter Station

Es ist angedacht, einen Server zu erstellen, an dem ich gerade arbeite. Dieser wird die Daten abgreifen.Die Daten werden über die serielle Verbindung welche mittels USB oder Bluetooth realisiert werden kann, übertragen. Es werden in periodischen Abständen ein JSON Strin mit den Sensordaten abgeschickt. Die Programmierung des Arduino ist bereits abgeschlossen…

Doch bevor ich auf den Quellcode verweise, möchte ich noch das Platinenlayout verfügbar machen, oder besser gesagt, das Bild der Rückseite. Die Widerstände sind 10Kohm, ansonsten sind die Verbindungen dem Bild zu entnehmen, ja ich bin faul, aber ich denke man kann das Platinenlayout anhand des Bildes nachvollziehen.

Platinenlayout Arudino Wetter Station

Ich weiß, das sieht alles sehr schrecklich aus. Ich hatte leider keine Entlötpumpe und auch konnte ich die Platine nicht auf der Diagonalen befestigen und musste im Kipp löten. Das wichtigste ist aber, dass alles soweit funktioniert wie gedacht. Ich habe auch ein Sketch geschrieben, der die Daten abgreift und über die serielle Verbindung im JSON Format abschickt. Der Quellcode ist entweder hier verfügbar: https://github.com/feugen/AWS oder auch dierekt hier:


// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.

// Reading temperature or humidity takes about 250 milliseconds!
// Sensor readings may also be up to 2 seconds ‚old‘ (its a very slow sensor)

#include <Arduino.h>
#include <Wire.h>
#include „dht.h“
#include <stdlib.h>
#include <SoftwareSerial.h>
#include „SFE_BMP180.h“

#define DHTPIN 2 // Digitalpin an dem wir angeschlossen sind.
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
#define Fehlermeldung „Fehler beim Lesen des DHT Sensors!“
#define Hoehe 520.0 // Höhe in München in Metern

//ACHTUNG!!!ACHTUNG!!!ACUHTUNG!!! Für USB: Serial und HardwareSerial und für Bluetooth: Bluetooth und SoftwareSerial
//in den nächsten beiden Zeilen einfügen.
#define Verbindungstyp Serial //Bluetooth oder Serial
#define VerbindungsDatentyp HardwareSerial //SoftwareSerial (Bluetooth) oder HardwareSerial(USB)

#define Versionsnummer „Version 1.1“

DHT dht(DHTPIN, DHTTYPE);
//Tx = 1, Rx = 0
SoftwareSerial Bluetooth(1, 0);
SFE_BMP180 BMP180;

unsigned long int startzeit = 0;
unsigned int zielzeit = 10000; //Zielzeit in Millisekunden pro Durchgang

void setup() {

//Initialisierung der Serialverbindung
Verbindungstyp.begin(9600);
Serial.println(„AWS – Arduino Wetter Server“);
Serial.println(Versionsnummer);

//Initialisieren den BMP180 Sensor
if (BMP180.begin()){
Serial.println(„BMP180 Initialisierung erfolgreich“);
}
else{
Serial.println(„BMP180 Initialisierung nicht erfolgreich\n\n“);
}

dht.begin();
}

String json_generator(const double &feuchte, const double &temp_am2302, const double &temp_bmp180, const int &druckwert, const int &widerstand){

char json_feuchte[5];
dtostrf(feuchte,3,1,json_feuchte);

char json_temperatur_am2302[5];
dtostrf(temp_am2302,3,1,json_temperatur_am2302);

char json_temperatur_bmp180[5];
dtostrf(temp_bmp180,3,1,json_temperatur_bmp180);

return „{\“Luftfeuchte\“: “ + String(json_feuchte) + „, “ + „\“Temperatur\“: “ + „{\“Temp_am2302\“: “ + String(json_temperatur_am2302)+ „, “ + „\“Temp_bmp180\“: “ + String(json_temperatur_bmp180) + „}, “ + „\“Luftdruck\“: “ + String(druckwert) + „, “ + „\“Photostrom\“: “ + String(widerstand) +“}“;
}

String seriell_auslesen(VerbindungsDatentyp &Verbindungstyp){

String serial_nachricht = „“;
char serial_char;

while (Verbindungstyp.available()){
serial_char = Verbindungstyp.read();
serial_nachricht.concat(serial_char);
}
return serial_nachricht;
}

boolean seriell_senden(VerbindungsDatentyp &Verbindungstyp, const String &serial_anfrage, const String &json_string){

boolean stat;

//Es sollen Daten je nach Anfrage geliefert werden
if (serial_anfrage != „“){
if (serial_anfrage == „sensor_anfrage“){
Verbindungstyp.println(json_string);
}
if (serial_anfrage == „version“){
Verbindungstyp.println(„{\“Versionsnummer\“: “ + String(Versionsnummer) + „}“);
}
else{
Verbindungstyp.println(„Achtung, “ + serial_anfrage + “ ist ein falsches Schlüsselwort, keine Funktion hinterlegt.“);
}
stat = true;
}
else{
//Es sollen immer die Sensordaten gesendet werden, wenn keine manuelle Abfrage
Verbindungstyp.println(json_string);
//Da keine manuelle Anfrage
stat = false;
}
return stat;
}

void loop() {

startzeit = millis();

char status;
double T,P;

status = BMP180.startTemperature();

while (true){
if (status != 0){
// Warte bis die Messung komplett ist:
delay(status);

// Extrahiere die Temperatur aus der Messung
// Die Messung wird in der Variablen T gespeichert
// Funktionen liefern 1 wenn erfolgreich, 0 wenn nicht.

status = BMP180.getTemperature(T);
if (status != 0){
status = BMP180.startPressure(3);
if (status != 0){
delay(status);
status = BMP180.getPressure(P,T);
if (status != 0){
//Messung erfolgreich, geh raus aus der Schleife
break;
}
else{
//Warte 250 ms und probiere nochmal
delay(250);
}
}
}
}
}

//Beinhaltet die aktuellen Messwerte
String json_string = „“;

//Sensoren Variablen
double feuchte = 0.0;
double temp_am2302 = 0.0;
double widerstand = 0.0;
double temp_bmp180 = static_cast<double>(T);
int druckwert = static_cast<int>(P);

//Serialport Variablen
String serial_anfrage = „“;

//Lese die Sensoren x mal aus
int anzahl_messungen = 5;
for (int i = 0; i < anzahl_messungen; i++){

// Wartezeit zwischen den Messungen.
delay(500);

feuchte += dht.readHumidity();
temp_am2302 += dht.readTemperature();
widerstand += analogRead(0);

// Wenn das Auslesen Fehlschlägt so schreib die Meldung und versuch es nochmal.
if (isnan(feuchte) || isnan(temp_am2302)) {
Verbindungstyp.println(Fehlermeldung);
return;
}
}

//Bestimme den Mittelwert
feuchte = feuchte/static_cast<double>(anzahl_messungen);
temp_am2302 = temp_am2302/static_cast<double>(anzahl_messungen);
widerstand = widerstand/static_cast<double>(anzahl_messungen);

//Generiere das Json Objekt
json_string = json_generator(feuchte, temp_am2302, temp_bmp180, druckwert, widerstand);

//Lese die Daten aus und sende sie seriell
seriell_senden(Verbindungstyp, serial_anfrage, json_string);

//In der Wartezeit soll man in der Lage sein, Infos auzutauschen, das passiert hier
while ((millis() – startzeit) < zielzeit){
//Lese die serielle Anfrage aus
serial_anfrage = seriell_auslesen(Verbindungstyp);
//Antworte auf die serielle Anfrage, falls was da ist
if (serial_anfrage != „“){
seriell_senden(Verbindungstyp, serial_anfrage, json_string);
}
}
}

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.