Schlagwort-Archive: Datalogger

Der Wetterfrosch 2.0 oder Umweltdatenlogger

Loading

Vor ein paar Jahren habe ich ein Projekt vorgestellt, in dem ein Raspberry Pi als Datenlogger arbeitete. An diesen Raspberry waren ein paar Sensoren angeschlossen, die Umweltdaten, wie Lufttemperatur, relative Luftfeuchte, den Luftdruck und auch die aktuelle GPS Position aufzeichneten. Die Sensoren bestanden größtenteils aus fertigen Breakoutboards, die über die diversen Busse (I²C, Serial, SPI…) an den RaspberryPi angeschlossen waren. Am PI selber liefen Python Skripten, die das Auslesen der Sensoren übernahmen, die Daten zusammenfassten und auf einen USB-Flashspeicher ablegten. Dieses Sammelsurium an Komponenten hatte ich dann in eine Kunststoffbox mit einer Größe von 150x80x50mm eingebaut.

Doch es geht auch um einiges kleiner. Im Rahmen eines kleinen Projektes war es die Aufgabe, diesen Sensor/Datenlogger zu verkleinern. Mein Ansatz, das zu realisieren, war ganz einfach: „Alles neu“. So habe ich das Konzept folgendermaßen geändert:

  • der RaspberryPi wird durch einen Microcontroller ersetzt
  • es wird eine Platine erstellt, auf der sämtliche Komponenten untergebracht sind
  • die erfassten Daten werden auf einer MicroSD Karte gespeichert
  • das Board ist auf die wesentlichsten Komponenten reduziert. Die Sensorelektronik und der SD-Card Reader wird direkt auf dem Board platziert
  • ein GPS-Empfänger (in Form eines Breakoutboards) soll optional aufgesteckt werden können
  • die Programmierung des Controllers wird durch eine ISP Schnittstelle durchgeführt
  • die Spannungsversorgung beträgt 5V DC

Daraus habe ich folgendes Blockschaltbild erstellt:

Blockschaltbild

Das zentrale Element ist, wie so oft, der Microcontroller Atmega328. Er benötigt als externe Beschaltung lediglich einen Quarz als Taktstabilisierung. (genauer gesagt bietet er aber auch die Optionen interne Oszillatoren zu benutzen…) Der Microcontroller kommuniziert über den I²C Bus mit den Sensoren HYT939 und BME280. Über die ausgeklügelte bidirektionale Levelshifter Schaltung mittels BSS138 Mosfet mit integrierter Body Diode wird die Anpassung der Pegel von 5V auf der Controller Seite zu den 3,3V auf der Sensorseite realisiert. Diese Schaltung wird sowohl für die SCL- (Serial Clock), als auch für die SDA-Leitung (Serial Data) angewendet.

Die Datenspeicherung findet auf einer MicroSD-Karte statt. Dafür wird ein Card Slot verbaut, der per SPI (Serial Peripheral Interface) mit dem Controller kommuniziert. Auch hier ist eine Anpassung der Signalamplituden notwendig. Das übernimmt dieses Mal jedoch der Chip TXB0108 von Texas Instruments. Das ist ein 8Bit Bidirektionaler Levelshifter.

Ein Taster wird die Datenaufzeichnung starten und stoppen und eine LED soll diverse Statusmeldungen durch Blinkfolgen darstellen.

Das optional aufsteckbare GPS Modul arbeitet mit 5V Spannungsversorgung und die Pegel der seriellen Datenkommunikation (RS232) sind ebenfalls 5V kompatibel.

Zu guter letzt ist natürlich auch die Spannungsversorgung zu planen. Hier soll lediglich eine externe, stabilisierte 5VDC Quelle angeschlossen werden, um den Logger zu versorgen. Die für die Sensoren und SD-Card benötigten 3,3VDC werden am Board mittels einem LDO (Low Drop Out) Regler erzeugt.

Sind alle Komponenten und deren Zusammenspiel definiert, dann wird daraus der Schaltplan gezeichnet. Für meine Bastelprojekte verwende ich hauptsächlich den Schaltplan- und Layout Editor „Eagle“.  Aus dem Blockschaltbild ergibt sich die unten abgebildete Schaltung.

Aus dem Schaltplan habe ich ein Layout mit zwei Layern erstellt, dessen Grundriss die Abmessungen 55x25mm hat. Bis auf die Steckverbinder befinden ausschließlich SMD Komponenten auf dem Board.

Im Layout Tool gibt es die Funktion, eine optische Vorschau der gefertigten Platine zu betrachten. So kann man vorab überprüfen, ob die Platine den Vorstellungen entspricht und gegebenenfalls die Lage der Bauteile optimieren. Ist das erledigt, wird aus dem Design ein Paket mit Produktionsfiles (Gerberdateien) erzeugt und das dann dem Platinen Hersteller seines Vertrauens gesendet. Da der auch sehr, sehr weit weg angesiedelt ist, dauert die Produktion auch ein paar Tage. Aber schlussendlich kommen die Platinen an und können sich auch sehen lassen.

Die beiden Bilder oben zeigen die Platine von der TOP und der BOTTOM Seite. Der nächste Schritt besteht darin, die Komponenten entsprechend der Planung zu bestellen und danach zu bestücken.

Die Bestückung erledige ich per Hand mit einem, für die SMD-Komponenten geeigneten Lötkolben mit entsprechend kleiner Spitze. Für die ganz kleinen Teile, wie den BME280 Sensor, kommt auch noch ein Mikroskop, bzw. eine Mikroskop Kamera zum Einsatz.

Wie die Platine nach der Bestückung aussieht, zeigen die beiden Bilder oben. Das folgende Foto zeigt den Größenunterschied des fertigen Loggers mit dem aufgesteckten GPS Modul im Vergleich zum alten „Wetterfrosch“Nach der Fertigstellung der Hardware, geht es nun an die Software. Die habe ich praktischer Weise mit dem Arduino IDE Tool gebastelt und per AVRISP mk2 über ISP auf den Controller geflashed. Um den AVRISP auf einem Windows 10 Rechner zum Laufen zu bekommen, muss ein geeigneter Treiber installiert sein. (hier hilft libusb-win32-1.2.6.0)

Programmcode mit der ArduinoIDE erstellt
Controller mit AVRISPmkII geflashed

Auf der SD-Karte wird nach Anlegen der Versorgungsspannung und nach Betätigen des Tasters die Datenaufzeichnung gestartet. Die Messwerte werden im Sekundentakt geschrieben. Wenn, wie in diesem Beispiel der GPS-Sensor gesteckt ist, so werden auch die GPS Daten mit aufgezeichnet. Die Software zeichnet auch auf, wenn der GPS Sensor noch keinen „fix“ hat. (Da in dem Beispiellog unten noch kein GPS-Fix vorhanden war, sind auch keine gültigen GPS Daten enthalten.)

Beispiel des Datenlogs:

Luftdruck962.41
Luftfeuchte37.05
Temperatur26.96
-----------------------------
$PGACK,103*40
$PGACK,105*46
$PMTK011,MTKGPS*08
$PMTK010,001*$GPGGA,235947.799,,,,,0,00,,,M,,M,,*71
$GPGLL,,,,,235947.799,V,N*73
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPGSV,1,1,00*79
$GPRMC,235947.799,V,,,,,0.00,0.00,050180,,,N*48
$GPVTG,0.00,T,,M,0.00,N,0.00,K,N*32
$GPGGA,235948.799,,,,,0,00,,,M,,M

-----------------------------
Luftdruck962.39
Luftfeuchte36.72
Temperatur26.95
-----------------------------
Luftdruck962.43
Luftfeuchte36.66
Temperatur26.97
-----------------------------

Raspberry als Datenlogger – Teil.3 Arduino nano als I²C Converter

Loading

DSC_4790
Raspberry PI als Datenlogger

Im letzten Teil des Projektes „Raspberry Pi als Datenlogger“ habe ich einen Raspberry Pi als Datenlogger für unterschiedliche Sensoren konfiguriert. Als Schnittstelle dient der I²C Bus und die RS232 Leitungen, an denen die Sensoren angeschlossen sind. Die Sensoren waren ein HYT939 (Luftfeuchtigkeit und Temperatur), ein BME280 (Luftdruck, Luftfeuchte und Temperatur) sowie ein Ultimate GPS Board an der seriellen Schnittstelle. Der Raspberry Pi ist dabei in eine Box eingebaut, wird mit einer Powerbank, die sich ebenfalls in der Box befindet, versorgt und stellt als Schnittstelle eine 8 polige RJ45 Buchse mit I²C und RS232 nach außen zur Verfügung. An diese Buchse können dann die Sensoren angeschlossen werden.   Will man die Sensorik nun ändern, bzw. erweitern, so können einfach weitere I²C Bus – Sensoren angeschlossen werden. Es muss lediglich noch die Software (in diesem Fall Python Skripten) angepasst werden und schon können die Daten des neuen Sensors empfangen und aufgezeichnet werden. Wie aber geht das System um, wenn der Sensor nicht über I²C spricht? Wenn zum Beispiel ein analoger Wert eingelesen werden soll? Ganz einfach: Soll die Hardware des Datenloggers nun nicht mehr modifiziert werden, so muss man einfach dafür sorgen, dass der neue Sensor, der beispielsweise analoge Spannungen ausgibt, diese an eine, nennen wir sie Black Box weitergibt, die wiederum an ihrem Ausgang ein I²C Bussignal bereit stellt. Das kann dann wieder in das bestehende System integriert werden.

dsc_2872
Arduino Nano als I²C Converter

Und genau diese Aufgabe erfüllt ein Microcontroller. Praktischer Weise habe ich diesmal einen Arduino Nano dazu verwendet. Der Arduino Nano mit dem Atmega 328 besitzt ja mehrere analoge und Digitale Eingänge, sowie zwei Interrupts. Über entsprechende Libraries ist einfach das I²C Bus Protokoll zu realisieren. Somit ist das geeignete Black-Box Gerät gefunden.

 

Der folgende Arduino Code stellt einen einfachen I²C Bus Slave dar. Die Busadresse soll beispielsweise 0x08 sein, von einer Messung haben wir den Messwert 1.3321 erhalten. Dieser Wert soll bei Anfrage an diese Busadresse gesendet werden. Das Beispiel sieht wie folgt aus:


// I2C Slave
#include
int address = 8;           //i2c busaddresse
float wert = 1.3321;       // testwert .... kommt zb aus sensorberechnung

char tmp[6];
void setup() {

Wire.begin(address);           // i2c adresse 0x08
Wire.onRequest(requestEvent);  // register event
}

void loop() {}

void requestEvent() {
dtostrf(wert,1,3,tmp);      // float "wert" in char array umwandeln
Wire.write(tmp);            // char array senden
}

Im Skript ist eine Funktion „dtostrf“ zu sehen. Sie wandelt den Inhalt einer Variablen des Datentyps „floating point“ in ein Charakter Array um. Infos sind hier zu sehen. Im Python Interpreter des Raspberry können wir nun überprüfen, ob die Daten ankommen. Doch zuvor soll der gesamte Aufbau einmal schematisch dargestellt werden.

blockschaltbild
Schematische Darstellung des Systems

Sind alle Sensoren inklusive des Arduino angeschlossen, so kann das folgende Python-Skript aus der Linux Konsole des Raspberry aufgerufen werden:

# Reading data from arduino as sensor slave
# V0.1 by bihlo 09/2016

import smbus, time

bus = smbus.SMBus(1)    # Raspberry Rev. 2
address = 0x08          # Fixed default address of Arduino

# Initialize sensor to acquire measurements
#def MeasurementRequest():
# void = bus.write_quick(address)
#time.sleep(0.1)

# Read from bus
def ReadMeasurement():
void= bus.write_quick(address)

time.sleep(0.1)
# Acquire 6 byte from sensor
Readout = bus.read_i2c_block_data(address,0,6)

out=''.join(chr(i) for i in Readout) #byte array von ascii in string wandeln

print "Antwort vom Arduino: ", Readout, " ."
print "Antwort als String:  ", out

ReadMeasurement()

Wenn der Python Interpreter jetzt keinen Fehler meldet und der Inhalt der Variable „wert“ des Arduino in ASCII und im Klartext dargestellt wird, dann kann jetzt mit einem „richtigen“ Messwert eines Sensors weiter gearbeitet werden.

dsc_2873
Partikeldetektor

Als Sensor soll an an den Arduino ein DSM501 Dust Sensor Module angeschlossen werden. Der DSM501A ist ein Staubsensor, der mit 5V bei einer Stromaufnahme von 90mA betrieben wird. Er erkennt Partikel ab einer durchschnittlichen Größe von 1µm bei einer Konzentration von 0 bis ca. 1.4mg pro Kubikmeter Raumluft. Laut Datenblatt und Herstellerinformationen wird die Luft im Bereich der Messkammer erhitzt, sodass eine Luftzirkulation entsteht. Die sich ständig bewegende Luft wird mit einem getakteten Lichtstrahl beleuchtet. Ein in einem Winkel zur Lichtquelle angebrachter Fotodetektor empfängt nun, im Falle dass sich Partikel im Licht befinden, dessen Streulicht. Die Intensität des Streulichtes ist von der Anzahl und Größe der Partikel abhängig und kann so erfasst werden. Als Ausgangssignal erzeugt der Sensor ein Puls/Pausensignal mit einer Periode von 100ms. Das Verhältnis von High- zu Lowtime stellt nun die Grundlage für die Berechnung der Partikelanzahl bzw. -dichte dar. Über einen Countereingang des Arduino werden die Impulse gemessen und der korrespondierende Partikelwert errechnet. Dieser Wert wird nun wie oben beschrieben als Busdatum für den I2C Bus herangezogen und bei Auslösen des Bus Events übertragen. Somit hat der Arduino die Aufgabe eines einfachen Protokollkonverters übernommen. Mit dieser Methode lassen sich alle möglichen Messwerte so aufbereiten, dass der Raspberry mit einer Schnittstelle damit umgehen kann.

Wie das im Detail funktioniert und wie der Code dazu aussieht, werde ich vielleicht später einmal posten.