Archiv für Selbstbau-Datenlogger

Wir basteln uns einen Datenlogger – Die Klimadiagramme unter die Lupe nehmen

Ich bin mir ziemlich sicher, dass Sie alle schon unzählige Male auf Klimagrafiken gestarrt und versucht haben, sich das zu erklären, was Sie da sehen. Wir möchten nun Calc oder Excel dafür verwenden, unser Klima im Lager und/oder in der Ausstellung besser kennen zu lernen und Entscheidungen darüber zu treffen, bei welchen Werten ein zukünftiges Alarmsystem anschlagen soll. Ja, im Moment ist unser Logger nur ein dummes Ding, das in der Ecke sitzt und aufzeichnet, was passiert. Aber wir können ihm beibringen, mit seinen LEDs Warnmeldungen zu blinken, oder wir können ihm einen Piezo-Lautsprecher verpassen, mit dem er einen Warnton ausgeben kann, oder wir können einen anderen Logger bauen, der in der Lage ist, Warnmeldungen über WLAN zu verschicken. Aber Sie erinnern sich an Aesop’s Jungen, der immer vor dem Wolf warnte? Genau, wenn Warnmeldungen zu häufig und ohne ernsthaften Grund kommen, neigen wir dazu, sie zu ignorieren. Deshalb müssen wir zunächst verstehen, was übliches und unübliches Verhalten in unserem Raumklima ist, indem wir unsere Klimadiagramme analysieren.

Das Problem mit festen Warnwerten

Die meisten Geräte mit Alarmfunktion erlauben es uns einen Alarm einzustellen, wenn die Temperatur oder Luftfeuchtigkeit einen gewissen Wert übersteigt oder darunter fällt. Gute, professionelle Geräte besitzen zudem eine einstellbare Funktion, die festlegt, wie häufig ein Wert über- oder unterschritten sein muss, bevor gewarnt wird, um unnötige Alarme durch minimale Überschreitungen und falsche Messungen zu vermeiden.
Das ist gut für Institutionen, die ein sehr stabiles Raumklima haben, wie es zum Beispiel durch Klimaanlagen möglich ist. Hier können wir einen Alarm einstellen, der warnt, wenn die Temperatur unter 19 °C (66 °F) fällt oder über 22 °C (71 °F) ansteigt. Wir können für die Luftfeuchtigkeit einen etwas breiteren Korridor festlegen, der wahrscheinlich irgendwo um die 55% herum liegt. Aber wenn Sie immer noch eine Artikelserie lesen, das sich damit beschäftigt, einen Datenlogger selbst zu bauen, haben Sie vermutlich keine so idealen Bedingungen.
Viel wahrscheinlicher (Achtung, Studenten der Museumskunde/Museologie, hier kommt ein Klimadiagramm aus dem wahren Leben) sieht es irgendwie so aus:

A real-life graph with usual and unusual climate swings.

Ein Klimadiagramm aus dem richtigen Leben mit üblichen und unüblichen Klimaschwankungen.

Es ist nicht so, dass dieses Raumklima nicht problematisch wäre. Aber es gibt darin problematische Dinge und einige Dinge, die einfach „normal“ für diesen nicht idealen Lagerort sind. Zum Beispiel ist es völlig normal, dass die Temperatur in Auf- und Abbewegungen von 17 °C auf 23 °C (62 auf 73 °F) steigt. Eine Warnmeldung bei 22 °C (71 °F) wäre ziemlich sinnlos, da der Raum lediglich eine Heizung besitzt.

Am 2. Mai gibt es plötzlich einen rapiden Anstieg der Luftfeuchtigkeit in nur 35 Minuten:

A sudden rise of relative humidity from under 47% to over 52% within 35 minutes.

A sudden rise of relative humidity from under 47% to over 52% within 35 minutes.


Ironischerweise würde ein normaler Feuchtigkeitsalarm hier aufhören zu alarmieren, da der Wert von einem theoretisch nicht so guten Wert in den Idealbereich wechselt. Aber für den Sammlungsverwalter in einer nicht so idealen Umgebung ist diese Verhalten des Raumklimas definitiv unnormal. jemand hat eventuell die Tür aufgelassen und die feuchte Luft kommt hereingeströmt. Sie möchten überprüfen, was los ist. Doch wie erfahren Sie davon?

Eine Warnung über plötzliche Veränderungen

Wir brauchen ein flexibleres Warnsystem, eines, das uns warnt, wenn sich plötzliche Veränderungen in Temperatur und Feuchte ereignen. Ein einfacher Weg das zu erreichen ist, den aktuellen Messwert vom vorigen Messwert abzuziehen. Wir erhalten einen Wert, der etwas über die Veränderung in der Zeit zwischen zwei Messungen aussagt.

Mit unserem Wissen aus dem vorigen Artikel über die Verwendung von Calc sollten Sie nun in der Lage sein, eine solche Formel zu definieren, die den zweiten Feuchtigkeitswert vom ersten abzieht (Tipp: Die Formel lautet „=C2-C1“) und diese Formel mit der „Füllen“ Funktion auf die ganze Spalte zu übertragen. In Excel ist das übrigens sehr ähnlich.

Subtracting a humidity value from the previous value.

Einen Feuchtigkeitswert vom vorhergehenden abziehen.

Wir erhalten eine Spalte die uns etwas über die Veränderungen über die Zeit sagt. Es ist nun einfach, daraus ein Diagramm zu machen, mit dem wir sehen können, welche Werte ziemlich daneben liegen. Tipp: Sie können die Spalten, die sie für das Diagramm nicht benötigen, über das Kontextmenü ausblenden, bevor sie die Spalten für Ihr Diagramm markieren. Vielleicht nutzen wir dieses Mal auch Punkte statt Linien:

A diagramm of changes.

Ein Diagramm der Veränderungen.

Natürlich konnten Sie die Veränderungen vom ursprünglichen Diagramm ablesen, aber dieses neue Diagramm gibt Ihnen einen besseren Überblick und eine Handhabe zu definieren, über welche Veränderungen Sie wirklich informiert werden möchten. Sie sehen zum Beispiel, dass alles unter 1 wahrscheinlich ziemlch normal ist und zu viele Warnmeldungen produzieren würde, wenn Sie den Warnwert dort ansiedeln. Alles über 1 ist vermutlich etwas, von dem Sie sofort erfahren möchten, nicht erst, wenn der monatliche Klimabericht eintrudelt.

Im wirklichen Leben haben wir diese Form des Finetuning für die Klimawarnungen am TECHNOSEUM verwendet. Es gibt Bereiche mit wohlbekannten Klimaschwankungen und andere, die ein genaueres Hinsehen erfordern. Für die meisten Bereiche bekomme ich eine Warnmail, wenn sich Temperatur oder Feuchte um mehr als 1 Grad innerhalb von 5 Minuten ändert. Wenn die Veränderungen über 3 Grad liegen, bekommen andere Kolleginnen oder Kollegen, die für diesen Bereich verantwortlich sind auch eine Warnung. Das hält mich über die meisten Veränderungen informiert und ich kann entscheiden, ob ich mir das ansehen oder einen Kollegen informieren muss, während die anderen Kollegen meistenteils unbehelligt bleiben, aber trotzdem sofort nach dem Rechten sehen können, wenn etwas ganz schief läuft.

Die langsame, kontinuierliche, böse Veränderung

Das ist schon gut, aber es warnt einen nicht vor einer anderen Sache, die den Sammlungsverwalter ängstigt: die langsame und kontinuierliche Veränderung, hervorgerufen durch eine ausfallende Heizung oder einen Wasserrohrbruch. Um Ihnen zu zeigen, was ich meine, sehen wir uns ein anderes echtes Klimadiagramm an:

A slow and steady rise in humidity.

Eine langsame und kontinuierliche Veränderung der Luftfeuchtigkeit.

Dieser Raum hat eigentlich ein ziemlich stabiles Klima um die 40% relative Luftfeuchtigkeit. Gegen 8 Uhr morgens fängt die Luftfeuchtigkeit langsam an zu steigen. Langsam aber kontinuierlich, bis sie gegen 13:30 Uhr 46,7% erreicht. Kein Ereignis, über das unser Warnsystem uns informiert hätte, da die Veränderungen zwischen zwei Feuchtigkeitswerten sehr gering sind. Wenn wir ein Warnsystem für diese Art von Veränderungen haben wollen, brauchen wir etwas anderes. Wir brauchen eine Warnung vor problematischen Tendenzen.

Wie können wir das erreichen? Wir müssen zunächst einen Zeitraum definieren, der die Grundlage unserer Berechnung bilden soll. Sagen wir 30 Minuten. Wenn wir die Differenzen zwischen den letzten 6 Werten nehmen und durch 5 teilen, bekommen wir einen Wert für die Tendenz. Sie sollten nun in der Lage sein, die Formel dafür zusammen zu stellen. Sie lautet:
=(C2-C1)+(C3-C2)+(C4-C3)+(C5-C4)+(C6-C5)/5
(Wenn C die Spalte mit Feuchtigkeitswerten ist.)

Wenn wir daraus ein Diagramm machen und es mit der ursprünglichen Kurve vergleichen, bekommen wir eine Vorstellung, wie problematische Veränderungen aussehen:

The tendency values against the original curve.

Tendenzwerte verglichen mit der Ursprungskurve.

Wir können daraus ableiten, dass es eine gute Idee sein könnte eine Warnung zu bekommen, wenn der Tendenzwert über 0,5 liegt. Aber noch viel mehr als der Wert für die plötzliche Veränderung hängt das doch sehr von den örtlichen Gegebenheiten ab und kann von überwachtem Raum zu überwachtem Raum unterschiedlich sein. Es könnte weniger ideale Lagerräume geben bei denen man den Wert überhaupt nicht verwenden kann, da das Schwanken der Temperatur- und/oder Feuchtigkeitswerte einfach normal ist und man daran nichts ändern kann. Lassen Sie uns ein Beispiel ansehen, damit klar wird, was ich meine…

Alles zusammengefasst…

Wenn wir uns noch einmal die ersten drei Tage des beängstigenden Klimadiagramms vom Anfang ansehen (Sie können sich hier die kompletten Daten herunterladen), wie würde unser Warnsystem reagieren?

3 Tage im Mai…

Unsere erste Warnmeldung kommt am ersten Mai kurz nach 8, als der langsame Anstieg der Feuchtigkeit zuerst die 0,5 Marke erreicht. Dieser Wert wird den ganzen Vormittag über einige Male erreicht, es wäre also genügend Zeit zu reagieren.

Die erste Warnmeldung kommt um 8:07 Uhr am 1. Mai.

Die nächste Warnung kommt einen Tag später gegen 10 Uhr. Dies ist eine Warnung wegen einer plötzlichen Änderung. Wir sehen dass dieser Warnung 5 Minuten später eine Tendenzwarnung folgt:

Warnung über eine plötzliche Veränderung gefolgt von einer Tendenzwarnung am 2. Mai.

Etwa eineinhalb Stunden später sehen wir einen rapiden Abfall der Luftfeuchtigkeit, als diese sich wieder in Richtung „normal“ bewegt.

Wir sehen wieder eine steigende Tendenz (wenn auch nicht so stark und lang andauernd wie am 1.5.) gegen 16:30 Uhr an diesem Tag, die nächste am Folgetag gegen 10:30 Uhr, die nächste gegen 13 Uhr, die nächste gegen 20 Uhr.

7 Warnmeldungen in 3 Tagen.

In einem Zeitrahmen von lediglich 3 Tagen hatten wir 7 Tendenzwarnungen. Warnungen über rapide Änderungen kamen zweimal. Eine Warnung bei Grenzwertüberschreitung… tja, wenn wir eine Warnung ausgelöst hätten, wenn die Feuchtigkeit über 40% steigt, wäre ab 13:00 Uhr am 1. Mai kontinuierlich gewarnt worden – 5 Stunden nach der ersten Tendenzwarnung.

Wenn dieses Klimadiagramm aus einem Raum mit Klimaanlage stammen würde, hätte ich sicherlich alle 7 Tendenzwarnungen erhalten wollen, denn, ehrlich, das ist KEINE schöne Klimagrafik! Ich würde wahrscheinlich meine Tendenzwarnungen sogar auf 0,2 oder 0,3 setzen. Für einen wohlbekannten, nicht so idealen Lagerbereich… tja, da reicht dann wohl doch die Warnung bei rapiden Veränderungen. Ich werde das deutsche Wetter nicht ändern, möchte aber sehr wohl lecke Dachfenster oder offene Tore bei feuchtem Wetter mitbekommen.

Ich hoffe, Sie hatten Spaß an dieser kleinen Datenanalyse. Ich schon. Wir möchten eventuell unseren Logger auf Grundlage dieser Beobachtungen verbessern…

Weitere Beiträge zu diesem Projekt:

Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail

Wir basteln uns einen Datenlogger – Wir Wollen Fahrenheit!

Bisher war diese Anleitung sehr europäisch. Aber Sie möchten Ihre Temperatur ja vielleicht in Fahrenheit angezeigt bekommen. Es gibt zwei Möglichkeiten das zu tun: In der Arduino-Software oder in der Tabellenkalkulation. Weil ich Sie zuletzt beim Tabellenkalkulationsprogramm Calc zurückgelassen habe, machen wir es zunächst hiermit. Die Formel, mit der man Celsius in Fahrenheit umwandelt lautet: die Temperatur in Celsius wird mit 1,8 Mal genommen und dann wird 32 addiert.

In unserem Tabellenkalkulationsprogramm fügen wir eine neue Spalte ein und schreiben die Formel „=D1*1.8 + 32“ für den ersten unserer Temperaturwerte in D1:

The formula for converting Celsius into Fahrenheit.

Die Formel für die Konversion Celsius in Fahrenheit.

Wie letztes Mal möchten wir, dass sich die Formel auf alle unsere Daten bezieht, also schreiben wir das erste und das letzte Feld in unser Adressfeld: „C1:C8484“:

For which cells the formula should apply.

Eintragen für welche Zellen die Formel gelten soll.

Vergessen Sie nicht, die Enter-Taste zu drücken. Jetzt wählen wir wieder „Füllen…“ und „Unten“ in unserem Menü „Bearbeiten“:

Filling the formula into all other fields of this column.

Die Formel auf alle anderen Daten der Spalte übertragen.

Aber unsere Grafik ist immer noch in Celsius? Kein Problem, das ändern wir jetzt. Wir doppelklicken das Diagramm und gehen ins Menü „Format“, in dem wir „Datenbereiche…“ auswählen.

Changing the data range

Den Datenbereich verändern.

Hier können wir Spalten hinzufügen und entfernen. Wenn wir Celsius nicht mehr angezeigt bekommen wollen, klicken wir auf die Spalte D und ändern das D in C in der Formel:

Changing row D to C.

Spalte D in C umwandeln.

Changing row D to C.

Spalte D in C umwandeln.

Wir sehen, dass jetzt statt „Spalte D“ „Spalte C“ angezeigt wird und die Linie im Diagramm nun die Fahrenheit-Werte statt der Celsius-Werte zeigt. Wenn wir die Celsius-Werte auch mit angezeigt bekommen möchten, wählen wir „Y-Werte“, dann „Hinzufügen“ und ändern die „Unbekannte Datenreihe“ in der Formel auf die Spalte mit den Celsius-Werten (D).

Add a row.

Add a row.

Change added row to row D.

Hinzugefügte Spalte in Spalte D ändern.

Übrigens, falls uns die Farbe unserer Linie nicht gefällt, können wir das mit einem Doppelklick auf die Linie ändern:

Changing the color of a line.

Die Farbe einer Linie ändern.

Und wenn wir den Fahreheit-Wert gleich von Anfang an in unserem Arduino-Code ändern möchten? Tja, suchen Sie mal nach der folgenden Zeile:

Und ändern Sie sie zu:

Was? So einfach? Ja. Das „true“ sagt der Bibliothek, dass wir die Temperaturwerte in Fahrenheit möchten. Wenn dieser Parameter nicht gesetzt ist, oder wir dht.readTemperature(false) schreiben, dann bekommen wir die Werte in Celsius. Einfach!

Selbst wenn Sie das in der Software geändert haben, möchten Sie vielleicht die Umrechnungsformeln im Hinterkopf behalten, falls Sie sich mit Partnern in den USA oder anderen Teilen der Welt über Klimadaten austauschen möchten:

Grad Fahrenheit (°F) = Grad Celsius (°C) × 1,8 + 32
Grad Celsius (°C) = (Grad Fahrenheit (°F) − 32) / 1,8

Im nächsten Teil stellen wir noch ein paar andere schöne Dinge mit unseren Daten an, also bleiben Sie dran.
Halten Sie Ihre Klimakurven gerade!

Weitere Beiträge zu diesem Projekt:

Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail

Wir basteln uns einen Datenlogger – Daten verarbeiten mit Microsoft Excel

Im letzten Beitrag habe ich OpenOffice Calc von Apache (https://www.openoffice.org/product/index.html) als Tabellenkalkulationsprogramm empfohlen, aber einige von Ihnen haben wahrscheinlich ohnehin das Office-Paket von Microsoft, deshalb hier das Ganze nochmal in Excel:

Statt „MyLogger.csv“ zu öffnen (was die Daten ziemlich durcheinanderwürfelt), erstellen wir zunächst eine neue Arbeitsmappe. Dann wählen wir das „Daten“ Menü und dort „Aus Text“. Wir wählen unsere Datei aus und klicken auf „Importieren“. Wir wählen „Getrennt“ und dann „Weiter“.

Our csv file in the preview window.

Unsere CSV-Datei im Vorschaufenster.

Im nächsten Dialog können wir auswählen, wie unsere Werte voneinander getrennt sind. In unserem Fall also durch „Komma“.

lala

Wenn wir „Komma“ wählen, sehen wir im Vorschaufenster, wie die Werte getrennt werden.

Nach einem Klick auf „Weiter…“ haben wir die Möglichkeit, für unsere Werte ein Format festzulegen. Auch einfach, dadurch seine Daten durcheinander zu bringen. In den meisten Fällen kann man hier alles auf „Standard“ lassen.

You can choose the format of the data in all the columns seperately.

Man kann für jede Spalte ein eigenes Format auswählen.

Hier kann man sich selbst ein Bein stellen, wenn man mit einem anderen Sprachpaket als dem Englischen arbeitet. Im Deutschen werden die Dezimalstellen durch Komma getrennt, nicht durch den Punkt. Im Deutschen Sprachpaket interpretiert deshalb Excel die Dezimalzahlen nicht als Dezimalzahlen, wenn man den „.“ als Dezimalstellentrenner stehen lässt und macht alle möglichen komischen Dinge mit den Werten, indem es z.B. alles hinter dem Punkt wegfallen lässt oder bei den Diagrammen die Zahlen nicht als Zahlen interpretiert. Man muss also das Dezimaltrennzeichen unter „Weitere…“ von Komma auf Punkt umstellen.

Tweak for decimals in foreign languages.

Umstellen des Dezimaltrennzeichens.

Nach einem Klick auf „Fertig stellen“ kommt noch ein weiterer Dialog, den man einfach mit „OK“ bestätigen kann. Jetzt haben wir unsere Daten in der Tabelle. Wir machen so ziemlich genau so weiter, wie wir es in Calc auch gemacht haben. Wir fügen eine neue Spalte für unseren Datums- und Zeitstempel ein. Den erzeugen wir, indem wir unsere Daten im richtigen Format verketten: Wir setzten den Mauszeiger in A1 und tippen das Gleichheitszeichen „=“ das anzeigt, dass wir eine Formel beginnen. Dann tippen wir das erste Feld „D1“, setzten ein „&“ um es mit dem nächsten benötigten Zeichen zu verketten, das ein Schrägstrich „/“ ist. Wir tippen den Schrägstrich in Anführungszeichen, da unser Programm sonst denkt, dass wir den Wert aus D1 mit etwas dividieren möchten. Wir fügen das nächste Feld, E1, mit einem & an, und so weiter. Nach 6 Feldern, zwei „/“ und zwei „:“ haben wir:
=D1&“/“&E1&“/“&F1&“ „&G1&“:“&H1&“:“&I1
Wenn wir Enter drücken, sollten wir einen schönen, sauberen Datums- und Zeitstempel in A1 sehen:

Our first timestamp.

Einen Zeitstempel aus den Feldern D bis I erzeugen.

Nun möchten wir das natürlich für die gesamte Spalte A. Wir stellen fest, wie viele Zeilen mit Daten wir insgesamt haben, das sind in diesem Fall 8484, bei Ihnen kann das anders sein. Wir gehen in das Adress-Feld und schreiben „A1:A8484“ und drücken Enter. Das sagt Excel, dass wir etwas mit allen A-Feldern von A1 bis A8484 tun möchten. Folgerichtig sind diese jetzt markiert. Jetzt gehen wir in das „Start“ Menü und wählen am äußersten rechten Rand „Füllbereich“. Dort wählen wir „Unten“. Jetzt haben alle unsere Datensätze einen Datums- und Zeitstempel aus ihren Werten in D bis I.

We select all our A fields in the address field and choose the fill option.

Wir wählen alle A-Felder im Adress-Feld aus und füllen sie mit unserer Formel.

Bereit für ein nettes Diagramm? Na dann, los. Sie markieren als erstes die Spalten A bis C, die die Daten enthalten, die wir im Diagramm haben wollen. Dann wählen wir „Diagramm“ in unserem Menü „Einfügen“. Sie können entweder „Empfohlene Diagramm“ wählen oder direkt auf „Linien“ gehen.

Choose your diagramm options.

Auswahl der Diagrammoptionen

Wenn Sie „Linien“ wählen, wird das Diagramm sofort erzeugt, im anderen Fall können Sie sich die Empfehlungen ansehen und damit herumspielen:

Diagramm options.

Diagrammoptionen.

Jetzt haben wir ein schönes Diagramm, das wir vergrößern, verschieben und mit dem wir herumspielen können:

Climate graph ready.

Klimagrafik fertig.

Nun sind Calc- und Excel-Kapitäne auf dem gleichen Stand und wir können ein paar Dinge mit unseren Daten anstellen….

Weitere Beiträge zu diesem Projekt:

Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail

Wir basteln uns einen Datenlogger – Daten verarbeiten mit OpenOffice Calc

Daten sammeln ist nett, aber kein Wert an sich. Wir wollen schließlich etwas mit unseren Werten anfangen. Um die Daten weiter zu verarbeiten verwende ich OpenOffice Calc von Apache (https://www.openoffice.org/product/index.html). Warum Calc und nicht Excel? Dafür gibt es verschiedene Gründe: es ist kostenlos, es ist Open Source, es ist für Windows, Linux und Mac erhältlich und, vielleicht am wichtigsten, es ist sehr benutzerfreundlich beim Daten verarbeiten. Es schlägt Excel in vielen Bereichen, jedenfalls meiner Meinung nach (trotzdem gibt’s auch eine Excel-Version dieses Beitrags).

Wir haben bisher ein Programm geschrieben, das unsere Klimadaten als „MyLogger.csv“ auf unserer SD_Karte ablegt. Als nächstes speichern wir die Datei auf unserem Rechner und öffnen sie mit OpenOffice Calc. Das sollte dann ungefähr so aussehen:

Window when you open a csv-file directly with Calc

Fenster, wenn man eine csv-Datei direkt mit Calc öffnet.

Natürlich in der Sprache, in der Sie arbeiten. Das Programm schlägt also vor, eine Tabelle aus ihren durch Komma getrennten Werten zu machen – was ja genau das ist, was wir haben wollen. Falls Ihre Werte nicht durch Komma getrennt sind, können sie das Trennzeichen hier angeben. Wenn Sie mit der Voransicht zufrieden sind, drücken Sie „OK“.

Your raw data spreadsheet.

Ihre Roh-Tabelle.

Wir könnten jetzt natürlich direkt ein Diagramm mit Luftfeuchte und Temperatur machen. Aber vielleicht wäre es besser, wenn wir Datum und Uhrzeit in einem Format hätten, das wir auch gebrauchen können. Das hätten wir natürlich auch in unserer Arduino-Software schon tun können – aber niemand ist perfekt, wir notieren das aber für unsere weiteren Verbesserungen. Jetzt fügen wir erst einmal eine neue Spalte in unser Datenblatt ein: Wir markieren die Spalte A und wählen „Einfügen“–>Spalte. Eine neue Spalte erscheint links von der ursprünglichen Spalte, die jetzt „B“ heißt.

Our new empty column A.

Unsere neue leere Spalte A.

Jetzt machen aus dem Geschnipsel in den Spalten D bis I einen schönen Datums- und Zeitstempel. Er soll so aussehen: „2017/4/1 0:1:22“ Um das hinzukriegen, verknüpfen wir die Angaben in den Spalten mit einer Formel, das heißt wir klicken in A1 und tippen erst einmal ein Gleichheitszeichen „=“ was anzeigt, dass wir nun eine Formel eingeben. Dann tippen wir die Bezeichnung des ersten Feldes, „D1“, und fügen ein „&“ ein, um es mit dem nächsten Zeichen das wir brauchen zu verbinden, das ist ein Schrägstrich „/“. Das tippen wir in Anführungszeichen, denn sonst würde unsere Software denken, dass wir den Wert teilen möchten. Jetzt fügen wir mit & das nächste Feld, E1, an, und so weiter. Nach 6 Feldern, zwei „/“, einem Leerzeichen “ “ und zwei Doppelpunkten „:“ haben wir:
=D1&“/“&E1&“/“&F1&“ „&G1&“:“&H1&“:“&I1
Wenn wir Enter drücken, haben wir einen schönen, sauberen Datums- und Zeitstempel erzeugt:

The formula entered and executed.

The formula entered and executed.

Das möchten wir nun so in der ganzen A-Spalte, richtig? Aber erst müssen wir feststellen, wie viele Zeilen mit Daten wir überhaupt haben, also schauen wir in die letzte Zeile, die in unserem Fall die 8484 ist, bei Ihnen kann das anders sein. Wir gehen nun ins Adressfeld und tippen „A1:A8484“ und bestätigen mit Enter. Das sagt Calc, dass wir etwas mit allen A-Feldern von A1 bis A8484 unternehmen möchten. Deshalb sind die jetzt markiert.

We select all our A fields in the address field.

Wir wählen alle A-Felder im Adressfeld aus.

Jetzt kommt der Trick. Aus dem Menü „Bearbeiten“ wählen wir „Füllen“ und „Unten“. Jetzt haben alle unsere Daten einen schönen Datums- und Zeitstempel, der aus den jeweiligen Einträgen in D bis I erzeugt wurde.

From the "edit" menu, choose "fill" and then "down".

Aus dem Menü „Bearbeiten“ wählen wir „Füllen“ und „Unten“.

Fertig um ein nettes Diagramm zu erzeugen? Also los. Wir markieren zunächst die Spalten A bis C, die alle Daten enthalten, die wir in unserer Grafik sehen möchten. Dann wählen wir aus dem Menü „Einfügen“ „Diagramm…“.

Choose the "diagramm..." option from the "Insert" menu.

„Diagramm…“ im Menü „Einfügen“.

Als Diagrammtyp wählen wir „Linien“, im Hintergrund sehen wir schon eine Vorschau auf das Ergebnis.

We choose the lines for a type.

Wir wählen ein Liniendiagramm.

Jetzt können wir „Ferigstellen“ wählen oder noch ein paar Einstellungen vornehmen, z.B. unserem Diagramm einen Titel geben. Sobald wir „Fertigstellen“ wählen haben wir eine Grafik, die wir herumschieben, vergrößern oder sogar ausschneiden und in ein neues Tabellenblatt einfügen können, genau so wie wir das haben möchten.

The finished graph.

Fertiggestelltes Diagramm.

There, we have a nicely enhanced graph in an added spreadsheet.

Eine schön vergrößerte Ansicht in einem neuen Tabellenblatt.

Mit all dem Calc-Wissen, das wir jetzt haben, können wir nun daran gehen, unsere Daten so zu bearbeiten, wie wir das wollen. Zum Beispiel sind ja alle unsere Temperaturen in Celsius und wir brauchen sie vielleicht in Fahrenheit. Aber zunächst einmal machen wir das ganze nochmal in Excel für diejenigen, die sich damit sicherer fühlen…

Weitere Beiträge zu diesem Projekt:

Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail

Wir basteln uns einen Datenlogger – Die Software, dem Logger sagen, dass er loggen soll

790px-Kaffeetasse_Milchkaffee_Cafe-au-Lait_CoffeeGut, mit dem Arduino, dem Loggershield und der Verdrahtung, sowie mit dem Sensor, haben wir jetzt alles beieinander und können unseren Logger zum Aufzeichnen bringen. Um das zu tun, müssen wir dem Arduino sagen, was er zu tun hat. Das tun wir mit der Arduino-Programmiersprache. Was ist das und warum brauchen wir das?

Wie wir im letzten Teil gesehen haben, ist ein Arduino nicht besonders intelligent. Zu jedem normalen Menschen kann man sagen: „Wärst Du so nett und bringst mir eine Tasse Kaffee?“ und er oder sie wird in der Lage sein, diesen Auftrag ohne weiteres auszuführen, vorausgesetzt, alles Notwendige ist vorhanden. Wenn man nun das gleiche von einer Maschine erwartet, muss man ihre Sprache sprechen (oder einen Übersetzer haben, der sich „Compiler“ nennt) und man muss über die Aufgabe für das Dings so nachdenken, als ob das Dings nichts von dieser Welt weiß. Was, genau betrachtet, ja für jede Maschine zutrifft. Also, um bei unserem Beispiel zu bleiben, um eine Maschine zu programmieren muss man sagen:

Wenn Du das Kommando „Wärst Du so nett und bringst mir eine Tasse Kaffee?“ hörst, tue folgendes:

1. Gehe in die Küche
2. Falls die Tür zu sein sollte, öffne sie, um in die Küche zu gelangen
3. Gehe zum Schrank
4. Öffne die Schranktür
5. Nimm eine Tasse heraus
6. Schließe die Schranktür
7. Platziere die Tasse unter der Kaffeemaschine
8. Drücke den ersten Knopf
9. Warte, bis die Flüssigkeit die Tasse gefüllt hat
10. Nimm die Tasse in aufrechter Position heraus
11. Bringe die Tasse der Person, die das Kommando gegeben hat

Blöd, oder? Sie würden wahnsinnig werden an einem Assistenten, der so präzise Anweisungen braucht. Das ist es, weswegen es manchen Menschen schwer fällt, zu programmieren – es ist sehr kompliziert, so einfach zu denken. Aber egal, wir wollen, dass unser Logger loggt, also lassen Sie uns Schritt für Schritt die Programmierung durchgehen. (Das komplette Programm können Sie aus dem Schnellstart heraus kopieren):

Der Teil, der durch /* eingeleitet wird und mit */ endet ist ein Kommentar, etwas, das für Menschen geschrieben wurde, nicht für den Arduino. Stellen Sie es sich so vor, wie man manchmal Wörter buchstabiert, damit Kinder sie nicht verstehen. Nun, bei Kindern kann man nie sicher sein, aber mit /* */ beim Arduino schon.

Sie verwenden Kommentare um sicher zu gehen, dass ein anderes menschliches Wesen versteht, was Sie mit einem bestimmten Teil der Programmierung bezwecken. Die Chance ist hoch, dass Sie dieses menschliche Wesen sind, denn nach einer gewissen Zeit werden Sie sich nicht mehr daran erinnern, warum Sie manche Dinge so und nicht anders gelöst haben. Kommentare sind Teil einer guten Dokumentation, etwas, was wir Sammlungsmenschen lieben, richtig?

Als nächstes fügen wir einige Bibliotheken, „libraries“, in unser Programm ein.

Wir haben ja schon gesehen, was ein Arduino-Gehirn braucht, um eine Tasse Kaffee holen zu können. Nun, jemand hat schon mal alle Schritte, angefangen von „1. Gehe in die Küche…“ in einer Bibliothek zusammengefasst. Wenn man jetzt seinen Arduino-Assistenten programmieren möchte, muss man nur am Anfang „#include <Kaffee.h>“ in das Programm einfügen und wann immer Sie sagen „Wärst Du so nett und bringst mir eine Tasse Kaffee?“ wird der Assistent in der Lage sein, alle notwendigen Schritte auszuführen, um Ihnen eine schöne, heiße Tasse Kaffee zu bringen. Die Bibliothek wird auch enthalten was er tun soll, wenn die Maschine abgeschaltet ist, der Wassertank leer ist, der Kaffee aus ist…

Nun muss ich zugeben, dass ich auch nicht alle Bibliotheken verstehe, die bei unserem Logger eingebunden wurden. Von manchen weiß ich nur so viel, dass ich sie brauche und das weiß ich, weil sie in einigen Beispielprogrammen eingebunden waren. Ich denke, das ist als ob man eine Restauratorin/Restaurator bräuchte – natürlich muss ich wissen, was er oder sie können sollte, aber man muss nicht vollständig verstehen, was er oder sie tut. Obwohl es natürlich auch so ist, dass, je besser man versteht was er oder sie macht, es desto effektiver ist, zusammen zu arbeiten.

Bei unserem Logger haben wir einige Bibliotheken eingebunden, damit er:

  • einige Funktionen der Programmiersprache C versteht (stdlib.h)
  • weiß, wie man mit Zeit umgeht, also versteht, dass es Sekunden, Minuten, Stunden, Tage,… gibt (Time.h)
  • weiß, wie man die Echtzeitumhr auf dem Loggershield abliest (DS1307RTC.h)
  • weiß, wie man über I2C kommuniziert (Wire.h)
  • versteht, was unser Sensor ihm zu sagen hat (DHT.h)
  • weiß, wie man mit Peripheriegeräten wie einem SD-Karten-Leser kommuniziert (SPI.h)
  • weiß, wie man eine SD-Karte liest und auf ihr schreibt (SD.h).

Als nächstes definieren wir, wo unser Sensor ist und welchen Typ wir verwenden. Die DHT-Bibliothek, die wir eingebunden haben kann nämlich unterschiedliche Sensoren verstehen: DHT11, DHT21 und DHT22, also müssen wir angeben, dass wir einen DHT22 verwenden und diesen an Pin 9 angeschlossen haben. Die Bemerkungen hinter den // sind wieder Kommentare für den Menschen, nicht für den Arduino:

Als nächstes bekommt der Sensor einen Namen, so dass wir ihm Befehle geben können.

Um die Sache einfach zu machen, haben wir ihn „dht“ in Kleinbuchstaben genannt, aber wir hätten ihn genau so gut „Walter“, „Gretchen“ oder „sensor1“ nennen können. Es ist nur wichtig, dass er konsequent so genannt wird und dass wir mit der Groß- und Kleinschreibung aufpassen. Denn für unseren Arduino ist „Gretchen“ etwas anderes als „gretchen“ und das Programm wird nicht laufen, wenn wir hier einen Fehler machen.

Die nächste Zeile stellt sicher, dass wir die SD-Karte verwenden können, obwohl wir ein Shield verwenden. In unserer Bibliothek ist nämlich der Pin 4 für eine bestimmtes Aktion vorgesehen, aber der wird vom Shield für etwas anderes verwendet. Also muss der Arduino statt dessen Pin 10 verwenden.

Bisher haben wir nur dafür gesorgt, dass der Arduino grundsätzlich ein paar Dinge weiß. als nächstes gehen wir ins „setup“. Stellen Sie sich einfach vor, ihr neuer Assistent kommt zur Tür herein. Bevor Sie ihm irgendwelche Aufträge erteilen können, müssen Sie ihn herumführen. Wo ist die Toilette? Wo ist die Küche? Wo ist die Kaffeemaschine… Das passiert alles innerhalb der geschweiften Klammern nach „void setup“.

Tatsächlich sagen wir unserem neuen Assistenten erst einmal, wie er/sie mit uns reden soll. Unser Arduino wird in der Lage sein, uns zu sagen was er tut, in dem er etwas verwendet, was „serial communication“ heißt. Er wird in der Lage sein, Informationen über das USB-Kabel zu schicken, die wir dann auf dem Serial Monitor unserer Arduino-Software lesen können. Die Zeile Serial.begin(9600) ist als ob wir unserem Assistenten sagen, dass er deutsch mit uns reden soll.

Als nächstes sagen wir unserem Arduino dass er Pin 7 und 8 als Ausgang (output) verwenden soll. Dort sind unsere beiden LEDs angeschlossen, aber das weiß unser Arduino nur, wenn wir es ihm sagen. Es gibt für einen Pin zwei Möglichkeiten: entweder er ist ein Ausgang oder ein Eingang (input). Wenn wir ihn als Ausgang definieren können wir an ihn Signale senden, die dann mit dem Ding, das dort angeschlossen ist, etwas tun. In unserem Fall können wir ein „HIGH“ Signal senden, dann schaltet sich die LED an, oder ein „LOW“ Signal, dann schaltet sie sch aus.
Wenn wir einen Pin als Eingang definieren, dann „hört“ der Arduino darauf, was an diesem Pin passiert. Wenn der Arduino dort ein Signal erhält, kann er darauf entsprechend reagieren. Aber in unserem Fall brauchen wir nur einen Ausgang für die LEDs.

Jetzt testen wir, ob unsere SD-Karte funktioniert. Zunächst schicken wir den Satz „Initializing SD card…“ an unseren Serial Monitor, so dass wir es sehen können.
Dann definieren wir noch einen Pin, Pin 10, als Ausgang, da unser SD-Karten-Leser es so braucht (das wissen wir aus dem Beispielprogramm).

Nun testet der Arduino, ob er die SD-Karte lesen kann. Wenn er sie nicht lesen kann, schickt er die Nachricht „Card failed, or not present“ an den Serial Monitor.
Aber „in freier Wildbahn“ haben wir kein USB-Kabel und keinen Computer, nur den Logger an sich. Also benutzen wir unsere rote LED um uns die gleiche Nachricht mitzuteilen. Wenn der Arduino den SD-Karten-Leser nicht erkennt, schaltet er für 5 Sekunden die rote LED an. In Arduino-Sprache werden Zeitintervalle in Millisekunden angegeben. Sie sehen, dass wir der LED ein „HIGH“ Signal senden, dann für 5000 Millisekunden warten (delay), um dann ein „LOW“ Signal zum Abschalten der LED zu senden.
Hier kommt nun auch das Wattestäbchen zum Einsatz: Wenn die rote LED anzeigt, dass die SD-Karte fehlt oder nicht richtig eingeschoben ist, kann man die SD-Karte erneut einsetzen und auf das Wattestäbchen drücken, das im Inneren des Gehäuses mit dem Reset-Knopf verbunden ist. Der Arduino macht einen Neustart und versucht es noch einmal.

Wenn der Arduino die SD-Karte dagegen lesen kann, sendet er die Nachricht „card initialized.“ an den Serial Monitor. Als nächstes schickt er „DHTxx test!“. Wieder haben wir keine Ahnung, ob die SD-Karte gelesen werden konnte, also schalten wir die grüne LED an Pin 8 für 5 Sekunden ein wenn alles in Ordnung ist.

Mit dem einfachen Befehl „dht.begin();“ teilen wir unserem Sensor mit, dass er anfangen soll, seine Umgebung zu überwachen.

Damit ist unser setup beendet und wir können unserem Assistenten sagen, was er oder sie den lieben langen Tag tun soll. Das tun wir in der „loop“-Funktion. Diese Funktion wird sich ständig wiederholen, wenn wir nichts hineinschreiben, was sie stoppt (oder wenn der Stecker gezogen wird).

Was wir immer wieder machen wollen ist zu lesen, wie hoch die relative Luftfeuchtigkeit und Temperatur in unserem Raum ist, richtig? Um die Werte von unserem Sensor zu lesen, rufen wir „dht.readHumidity“ für die Feuchtigkeit und „dht.readTemperature“ für die Temperatur.
Wenn wir diese Werte noch ein paar Mal in unserem Programm brauchen, benutzen wir etwas, was sich „Variable“ nennt. Eine Variable ist so etwas wie eine Tasche. Wir können einen Wert darin speichern und mit uns herumtragen. In unserem Fall nennen wir eine Variable „h“ für Feuchtigkeit (humidity) und „t“ für Temperatur. Taschen gibt es in allen Größen und Formen, genau so Variablen. Sie würden die kleine, schwarze Handtasche für eine Essenseinladung nehmen und Ihren Rucksack für einen Tagesausflug, eben für jeden Anlass und Platzbedarf genau das richtige. Unsere Daten vom Sensor sehen z.B. so aus: 14.5 oder 34.8, sie kommen als Fließkommazahlen. Also wählen wir den Variablentyp „float“ (Fließkommazahl) für sie. Es gibt noch viele andere Variablentypen, aber für heute reicht uns erst einmal zu wissen, dass „float“ der richtige Typ für unsere Sensorwerte ist.
Zusammengefasst: Die folgenden Zeilen unseres Programmes speichern die Sensorwerte in den Variablen „h“ und „t“. Wenn wir diese Variablen im folgenden Teil des Codes aufrufen, werden sie die aktuellen Sensorwerte ausspucken.

Aber was passiert, wenn unser Sensor etwas ausgibt, das kein gültiger Wert für Feuchtigkeit oder Temperatur ist? Der nächste Teil des Programms überprüft genau das und reagiert dementsprechend.

Wenn entweder der Feuchtigkeitswert in „h“ oder der Temperaturwert in „t“ keine Zahl ist, wird uns der Arduino darüber informieren, indem er auf dem Serial Monitor schreibt: „Failed to read from DHT sensor!“ Der Ausdruck dafür, dass etwas keine Zahl ist heißt „isnan“ (für IS Not A Number). Statt „oder“ zwischen diesen beiden Bedingungen zu schreiben, müssen wir eine Sprache verwenden, die der Arduino versteht, das sind hier die beiden vertikalen Striche || (davon gibt es wieder einige, wie && für „und“, > für „größer als“ oder < für „kleiner als“ ).

Wieder können wir das in freier Wildbahn nicht sehen, also lassen wir unsere rote LED wie verrückt blinken, wenn die Sensorwerte keinen Sinn ergeben, z.B. weil der Sensor falsch angeschlossen wurde. Es mag wesentlich elegantere Methoden geben so etwas zu programmieren, aber ich bin schließlich nur Depotleiterin, kein IT-Profi.

Als nächstes lassen wir uns die ausgelesenen Werte auf dem Serial Monitor anzeigen, für den Fall dass ein Computer angeschlossen ist. Inzwischen sollten Sie in der Lage sein zu verstehen, was passiert:

Jetzt brauchen wir die Zeit von der Echtzeituhr. Übrigens: vergessen Sie nicht, dass Sie die Zeit am Anfang einmal einstellen müssen, wenn Sie die korrekte Zeit haben möchten, das passiert mit dem Beispielprogramm aus der RTC library. Im Grunde genommen sagen wir mit den folgenden Zeilen einfach „schau auf die Uhr und merke dir alles, was Du liest in der Variablen „tm“.“ Auf diese Weise können wir später nach dem spezifischen Tag, Monat, Stunde, Minute, Sekunde… fragen.

Was nun folgt, ist vielleicht ein wenig verwirrend zu erklären und anzusehen. Wir wollen unsere Daten auf der SD-Karte speichern, auf eine Art und Weise, bei der jeder Datenpunkt durch ein Komma vom nächsten getrennt ist. Auf diese Art können wir die Daten später in jedem beliebigen Tabellenkalkulationsprogramm verarbeiten, indem wir die Daten in einem Format einlesen, das CSV für „comma separated values“ heißt. Das Problem ist, unsere Daten sind Nummern. Sie erinnern sich, dass wir unsere Sensorwerte als Fließkommazahlen definiert haben? Genau!

Was wir aber brauchen, um die Daten abspeichern zu können sind Zeichen, in anderen Worten, einen „string“. Um noch genauer zu sein, wir brauchen einen string, eine Aneinanderreihung von Zeichen, der alle Daten umfasst, die wir speichern wollen. Wir möchten etwas erhalten, was in etwa so aussieht:
„34.8, 14.5, 2017, 04, 14, 2, 45, 23,“
Das können wir dann so in unser Tabellenkalkulationsprogramm importieren, dass wir eine Zeile erhalten, die 34.8 % Luftfeuchtigkeit, 14.5 Grad Celsius am 14. April 2017 um 14:45 (und 23 Sekunden) angibt.

Um das zu erreichen, nehmen wir eine neue Variable, unsere „Tasche“ heißt dieses Mal „dataString“ und soll alle unsere Daten aufnehmen. Ich muss zugeben, dass ich nicht verstanden habe, was Zeile 116 wirklich tut, aber sie hat etwas damit zu tun, welcher Platz für unsere Werte zur Verfügung steht.

Was als nächstes passiert ist, dass wir alle unsere Werte, die wir speichern wollen in unsere „Tasche“ namens „dataString“ packen. Das machen wir Stück für Stück, genau so, wie wir im wirklichen Leben unsere Tasche öffnen würden, um das Maßband, die Handschuhe, den Lippenstift,… hineinzutun. Das Tückische ist, dass wir erst unsere Nummern in Zeichen umwandeln müssen. Hmmm… vielleicht so, wie wenn man Flüssigkeiten in eine Tasche tun will. Man muss sie erst in einen Behälter packen. Naja, vielleicht nicht ganz so, aber so ähnlich.

Also tun wir unseren Feuchtigkeitswert in ein Behältnis. Wir nennen das Behältnis „stringH“. Die Funktion „dtostrf“ macht das mit unserer Variablen „h“, die, wie wir wissen, die Fließkommazahl unseres Luftfeuchtigkeitswertes ist. Dann tun wir unseren Behälter „stringH“ in unsere Tasche „dataString“:

Wir haben gesagt, wir wollen am Ende durch Komma getrennte Werte, also müssen wir jetzt noch ein Komma anhängen. Wir nehmen unsere „dataString“ Tasche und tun ein Komma rein, indem wir „+=“ als Kommando zum Anfügen verwenden. Los geht’s:

Das gleiche für unseren Temperaturwert:

Was ist jetzt in unserer Tasche? Etwas, was folgendermaßen aussieht: „34.8, 14.5,“. Man kann sicher gehen, wenn man sich das über den Serial Monitor bestätigen lässt, indem man folgende Zeile einfügt:

Das haben wir jetzt mal gelassen. Statt dessen sammeln wir nun in unserer Tasche nach und nach die Werte für den Tag, Monat, Jahr, Stunde, Minute und Sekunde, alle durch Komma getrennt. Randnotiz: Ich habe später herausgefunden, dass man nicht alle Werte hätte mit Komma trennen müssen, aber dazu vielleicht später in der Serie. Im Moment wissen wir erstmal nur, dass es funktioniert.

Puh, das ist eine Menge Programm. Unsere „Tasche“ dataString hat jetzt folgenden Inhalt: „34.8, 14.5, 2017, 04, 14, 2, 45, 23,“. Als nächstes schreiben wir das auf die SD-Karte. Dafür müssen wir erst einmal die Datei öffnen, auf die der string geschrieben werden soll.

Wenn der Arduino die Datei „Mylogger.csv“ auf der Karte findet, öffnet er sie, schreibt den Inhalt von „dataString“ darauf (er hängt ihn ans Ende aller darauf befindlichen Daten an) und schließt die Datei wieder. Auftrag ausgeführt!

Was daran großartig ist: wenn es keine Datei namens „Mylogger.csv“ auf der SD-Karte gibt, erzeugt sie der Arduino einfach. Nur in dem Fall, in dem eine solche Datei existiert, aber nicht geöffnet werden kann oder wenn die SD-Karte fehlt brauchen wir einen Fehlercode, der uns über den Serial Monitor informiert und die rote LED bis zum nächsten Durchgang anschaltet:

Zuletzt müssen wir noch definieren, wie lange der Arduino zwischen den Messungen warten soll. Je häufiger man ausliest, desto mehr Daten erhält man, was natürlich detaillierter ist, aber auch mehr Speicherplatz braucht. Im Beispiel warten wir 5 Minuten zwischen den Messungen, 300000 Millisekunden. Für ein 10-Minuten-Interval müsste man es auf 600000 Millisekunden setzen und so weiter.

Das ist alles, das ist das ganze Programm. Da ist natürlich noch viel Spielraum für Verbesserungen, zum Beispiel wenn wir die Temperatur in Fahrenheit messen oder den Taupunkt berechnen möchten. Aber das wird ein anderer Teil der Serie sein…

Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail

Wir basteln uns einen Datenlogger – Arduino, das Shield und die Verkabelung

Bitte entschuldigen Sie die Verzögerung im Fortführen dieser Serie. Tatsächlich hatte die Verzögerung unter anderem damit zu tun, dass ein Kollege und ich zusammen ein Hands-On zum Thema Übersetzung/Gangschaltung beim Fahrrad entwickelt haben, das auf dem Arduino basiert…

Also, die Basis des Loggers ist ein Arduino, den wir Ihnen neulich als „Dings, das Dinge tun kann“ vorgestellt haben. Für dieses Projekt verwenden wir einen Arduino Uno:
Photo by Clic17 via Wikipedia, CC-BY-SA 4.0Photo by Clic17 via Wikipedia, CC-BY-SA 4.0

Nun, ein Arduino Uno kann viel mehr als nur Sensordaten auslesen, wie wir das tun möchten, aber mit ihm ist es eben sehr einfach, Projekte in die Realität umzusetzen, ohne immer gleich löten zu müssen, er wird mit einer einfach zu lerneneden Programmiersprache programmiert und es gibt eine breite Gemeinschaft auf der ganzen Welt, die mit ihm experimentiert, so dass man meistens Antworten zu auftauchenden Fragen im offiziellen Arduino-Forum https://forum.arduino.cc/ oder irgendwo sonst im Internet findet.

Um mit dem Arduino zu arbeiten werden wir den Sensor und andere Bauteile mit den Ports des Arduino verbinden. Zur Verfügung stehen uns digitale Aus- und Eingänge (0 to 13), analoge Aus- und Eingänge (A0 to A5) und einige Anschlüsse für die Stromversorgung (bezeichnet mit 3,3 V, 5 V und GND). Wir werden später sehen, was wir wie verbinden.

Zunächst brauchen wir aber ein anderes nützliches Ding, ein Datenlogger-Shield. Also, was ist denn ein Shield, fragen Sie? Nun, so wie der Arduino aus der Verpackung kommt ist er ein Generalist. Er kann alles machen, ob es nun darum geht, die Geschwindigkeit eines Fahrrads zu messen oder Klimadaten zu speichern. Man verbindet einfach alles, was man für ein Projekt braucht mit dem Arduino. Je nach Projekt können das ziemlich viele Kabel, Widerstände, Kondensatoren, Schalter… sein. Deshalb haben einige nette Leute bereits fertige Platinen entwickelt, die schon sehr viel von den Dingen an Bord haben, die man für ein spezifisches Projekt braucht und die man ganz einfach mit dem Arduino verbinden kann, indem man sie ihm auf den Rücken „klickt“. Jetzt sitzt dieses Shield wie ein Rucksack auf dem Arduino und ist bereit, seine Aufgabe wahrzunehmen und es stehen immer noch eine ganze Reihe von Ports zur Verfüngung, obwohl einige jetzt natürlich für die Zusammenarbeit zwischen Arduino und Shield belegt sind.

Und was ist nun ein Datenlogger-Shield? Sehen Sie hier:

Taken from Adafruit website https://www.adafruit.com/product/1141

Von der Adafruit-Website https://www.adafruit.com/product/1141


Ein Datenlogger-Shield hat zwei sehr nützliche Einrichtungen: Ein SD-Card-Lesegerät, um die Klimadaten mit zu schreiben und eine Echtzeituhr. Wir brauchen eine Echtzeituhr weil ein Arduino im Grunde genommen ziemlich dämlich ist. Wenn wir ihm sagen, wie spät es ist, erinnert er sich daran nur so lange, wie er Strom hat. Wenn wir ihn von der Stromquelle abklemmen, glaubt er sofort, es ist 0 Uhr. Die Echtzeituhr hat eine kleine Batterie dabei, die sicher stellt, dass der Arduino sein Zeitgedächtnis behält, auch wenn er abgestöpselt ist.

Nachdem wir das Shield auf den Arduino gesteckt haben, können wir damit beginnen, unseren Logger zu verkabeln. Das können wir tun, indem wir die Kabel direkt auf das Shield löten, das praktischerweise auch noch eine kleine Lochrasterplatine für diesen Zweck an Bord hat. Oder aber wir benutzen ein kleines Breadboard und stellen die Verbindung mit Breadboard-Kabeln her, wie wir das im Beispiel gemacht haben. Für den Langzeit-Einsatz würde ich immer das Löten bevorzugen, da diese Verbindung weniger anfällig für Wackelkontakte ist. Die Verkabelung sollte so aussehen:

logger

Der Daten-Pin des Sensors ist mit dem digitalen Port 9 verbunden, die grüne LED über einen 100 Ohm Widerstand mit dem digitalen Port 8, die rote LED über einen 200 Ohm Widerstand mit dem digitalen Port 7. Die „angewinkelten (kürzeren) Beinchen“ der LEDs, die deren Minuspol sind, und der Ground-Pin des DHT22 werden mit dem GND (Ground) Port des Arduino verbunden. Der Power Pin und der Daten-Pin des DHT22 über einen 10 Kiloohm-Widerstand werden mit dem 5V-Port des Arduino verbunden.

Bei unserem Logger haben wir das Breadboard mit dem Sensor und den zwei LEDs außerhalb des Gehäuses angebracht, während Arduino und Shield innerhalb des Gehäuses sitzen. Man kann sehen, wie die Breadboardkabel innen und außen verbinden:

DatLog_2

Schließlich benötigen wir noch etwas, um den Reset-Button zu bedienen, falls wir das Programm neu starten müssen. Dafür haben wir ein Wattestäbchen mit einem breiten Plastikdübel am Ende verwendet.

Als nächstes sehen wir uns dann die Programmierung an.

Angela Kipp

Mehr zum Thema:
Ein Dings, das Dinge tun kann – Ein Blick auf den Arduino aus Sicht eines Sammlungsmenschen
Wir basteln und einen Datenlogger – Schnellstart
Wir basteln uns einen Datenlogger – Der Sensor, Herz des Loggers

Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail

Wir basteln uns einen Datenlogger – Der Sensor, Herz des Loggers

The first thing that can do things that actually DOES things for the TECHNOSEUM: A data logger that records the climate in a certain area of our museum.

Der „Q-Tip-Logger“, ein einfacher Datenlogger, der Temperatur und Feuchte auf SD-Card schreibt.

Zu meiner Überraschung hat der letzte Beitrag über den Selbstbau-Logger für einige Diskussionen gesorgt. Wie bereits im ersten Teil erwähnt ist dies keine Konkurrenz zu kommerziellen Loggern. Es ist eine alternative Lösung für Leute, die gerne basteln bzw. nach Ideen für Kooperationsprojekte mit Schulen und MINT-Clubs suchen. Wer keinen Spaß daran hat, sich in ein neues, vielleicht ungewöhnliches Thema einzuarbeiten und ein wenig zu basteln, für den wird dieses Projekt uninteressant sein. Wer einen genügend hohen Sammlungspflege-Etat hat, um sich professionelle Logger zu kaufen und diese regelmäßig zur Wartung einzuschicken für den mag es trotzdem interessant sein, um die Selbstbau-Lösungen mit den professionellen Varianten abzugleichen. Für denjenigen oder diejenige, der/die kein Geld im Sammlungspflege-Etat hat, dafür aber Sponsoren für die Bauteile werben kann, wenn er oder sie ein Kooperationsprojekt mit einer Schulklasse hat, für den/die eröffnet sich die Möglichkeit, eine Alternative zu billigen Baumarkt-Loggern zu bauen und gleichzeitig junge Leute für die Bedeutung der Sammlungspflege zu sensibilisieren.

Die kritischen Nachfragen, die ich durchaus begrüße, haben mich bewogen, die Reihenfolge dieser Anleitung umzudrehen: statt mit den Grundbauteilen Arduino und Datalogger-Shield beginnen wir mit dem Herzstück des Loggers: dem Sensor.

Beim Sensor entscheidet sich, wie gut der Logger für den Einsatz geeignet sein wird. Egal wie sorgfältig man arbeitet, wenn der Sensor schlecht ist, werden auch die Ergebnisse unbefriedigend sein. Andererseits haben gute Sensoren auch ihren Preis. Es gilt also, wie so oft, abzuwägen, was man für den vorgesehenen Einsatzzweck wirklich braucht. Hilfreich fand ich bei der Entscheidung die Tests, die Robert Smith mit den gängigsten Modellen für Selbstbauer, dem DHT11, DHT22 und SHT71 durchgeführt hat: http://www.kandrsmith.org/RJS/Misc/Hygrometers/calib_dht22_dht11_sht71.html. Dieser Vergleich zusammen mit seiner vorhergehenden Untersuchung von sechs DHT22-Sensoren haben mich schließlich dazu bewogen, den DHT22/AM2302 für meine Projekte einzusetzen, der sowohl Temperatur als auch relative Luftfeuchtigkeit misst.

Der DHT22, auch unter der Bezeichnung AM2302 zu finden.

Der DHT22, auch unter der Bezeichnung AM2302 zu finden.

Er erreicht zwar im Praxistest nicht die im Datenblatt auf Seite 3 genannten +/- 2% bei der Messung der relativen Feuchtigkeit (das wäre, nebenbei bemerkt, auch ein Wunder, die professionellen Logger, die diese Genauigkeit versprechen liegen in der Regel im hochpreisigen Segment…), bietet aber dennoch ein gutes Preis-/Leistungsverhältnis. Er ist über den Elektronik-Fachhandel, über den Shop von Adafruit oder über ebay einfach zu beziehen und einfach einzubauen.

Grundsätzlich muss man beachten, dass alle Sensoren nicht für die Ewigkeit gebaut sind, weshalb man die professionellen Logger ja auch regelmäßig zur Kalibrierung einschicken sollte. Um aber festzustellen, ob der Logger überhaupt noch zuverlässig arbeitet, gibt es zum Glück auf der Seite von Connecting to Collections Care eine Anleitung von Samantha Alderson und Rachael Perkins wie man das anhand von gesättigten Salzlösungen überprüfen kann: http://www.connectingtocollections.org/wp-content/uploads/2012/03/Calibration-using-saturated-salt-solutions.pdf
Dies sollte man tunlichst auch mit den Sensoren der Selbstbau-Logger tun, hier kann man sich sogar einen entsprechenden Prüfstand bauen, um immer nur die Sensoren und nicht gleich die ganzen Logger dem Test auszusetzen.

Vor dem ersten Einsatz des Selbstbau-Loggers sollte man ihn mit einem entsprechenden professionellen Gerät abgleichen. Ich habe bei meinen Loggern in zwei Fällen eine lineare Abweichung bemerkt (d.h. z.B. immer 1% unter dem Referenz-Gerät), die ich über die Programmierung korrigiert habe. Dann gilt es, wie gesagt, den Sensor regelmäßig zu überprüfen. Alle Sensoren haben die Tendenz mit der Zeit zu driften. Arbeitet der Sensor nicht mehr zuverlässig, sollte man ihn austauschen. Hier ist der Preis von um die 8 € für den Sensor hilfreich.

Soviel zum Sensor. Im Nächsten Teil befassen wir uns dann mit den Komponenten Arduino und Datenlogger-Shield.

Angela Kipp

Dieser Beitrag ist auch auf Russisch erhältlich, übersetzt von Helena Tomashevskaya.

Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail

Wir basteln und einen Datenlogger – Schnellstart

The first thing that can do things that actually DOES things for the TECHNOSEUM: A data logger that records the climate in a certain area of our museum.

Der „Q-Tip-Logger“, ein einfacher Datenlogger, der Temperatur und Feuchte auf SD-Card schreibt.

Wie versprochen stelle ich Ihnen hier vor, wie man einen einfachen Datenlogger mit dem Arduino baut. Nun möchte ich das gerne Schritt für Schritt tun und Sie dabei an der Entwicklung und den Überlegungen, die bei „unserem“ Logger eine Rolle gespielt haben, teilhaben lassen. Viele dieser Überlegungen haben mit den Anforderungen aus der praktischen Museumsarbeit zu tun und dürften deshalb selbst dann interessant sein, wenn man gar nicht vor hat, selbst einen Logger zu bauen, sondern das ganze an die nächste engagierte MINT-Gruppe oder den museumseigenen Bastelclub weiter zu geben. Für die ganz ungeduldigen aber, die entweder selbst schon viel gebastelt oder technikaffinen Nachwuchs haben, stelle ich hier schon einmal die Teileliste, die Verdrahtung und den Code online.

Noch ein Wort vorweg: Natürlich gibt es jede Menge kommerzielle Lösungen für die Klimaüberwachung und ich maße mir nicht an, mit ihnen konkurrieren zu wollen. Allerdings sehe ich häufig, dass Kolleginnen und Kollegen sich die professionellen Lösungen nicht leisten können und statt dessen zu billigeren, weniger geeigneten Modellen greifen. Hier bietet der Selbstbau eine interessante Alternative. Denn, da man die Kontrolle über die verwendeten Komponenten hat, bestimmt man selbst, wie gut die Lösung ist. Und, da man es selbst gebaut hat, kann man das Gerät auch selbst warten und reparieren.

Ein weiteres Wort vorweg: Schaltung und Code haben mit den angegebenen Komponenten bei uns tadellos funktioniert. Ich übernehme jedoch keinerlei Haftung für eventuell entstehende Schäden beim Nachbau.

Was das Gerät tut:
Der Logger zeichnet im 5 Minuten Abstand Temperatur in Grad Celsius und relative Luftfeuchtigkeit in Prozent auf und schreibt diese Werte zusammen mit Datum und Zeit als kommagetrennte Werte in die Datei MyLogger.csv. Diese Datei kann dann zur Weiterverarbeitung auf dem Rechner in ein Tabellenkalkulationsprogramm eingelesen werden 1

Benötigte Komponenten:

  • 1 Arduino Uno
  • 1 Logging Recorder Shield mit SD-Card reader und Zeitbasis
  • 1 Temperatur- und Feuchtigkeitssensor (hier: DHT 22 / AM 2302)
  • 1 Minibreadboard
  • 1 LED rot
  • 1 LED grün
  • 1 Widerstand 200 Ohm
  • 1 Widerstand 100 Ohm
  • 1 Widerstand 10 Kiloohm
  • Breadboard-Kabel
  • 1 SD-Card (aufgrund der geringen Datenmenge ist die Kapazität fast gleichgültig, ich habe ein 2 GB Karte verwendet)
  • 1 Netzteil (230 V auf 9 V)
  • Gehäuse je nach persönlichen Vorlieben

Verdrahtung:

logger

Arduino Code:

Der Code basiert im wesentlichen auf den Beispielprogrammen, die bei den verschiedenen eingebundenen libraries mitgeliefert wurde. Ein paar Lösungen mögen allerdings aus Internetrecherchen stammen, bei denen ich den Urheber nicht vermerkt habe. Sollte als jemand „seinen“ Code wiedererkennen, so möge er oder sie sich melden, damit ich die entsprechenden Credits einfügen kann.

Das Gehäuse:
Hier sind der Kreativität keine Grenzen gesetzt. Ich habe einen ungefähr passenden Karton dafür verwendet und die Öffnungen für die Kabel und die SD-Karte mit einem Messer ausgeschnitten. Wichtig ist lediglich, dass der Reset-Knopf auf dem Shield irgendwie zu bedienen ist. Man kann ihn einfach frei lassen, in unserem Fall ist es ein Q-Tip, an dem unten noch ein breiter Plastikdübel befestigt ist, um den Knopf zuverlässig zu treffen.

Verbesserungen:
Man merkt diesem Bauprojekt an, dass es mit heißer Nadel gestrickt war, um schnell verfügbar zu sein. Es sind also zahlreiche Verbesserungen denkbar.
Statt des Minibreadboards bietet es sich natürlich an, die Komponenten gleich auf das Logger-Shield zu löten, wo angenehmerweise bereits eine Lochraster-Platine integriert ist. Dabei sollte man nur beachten, dass der Sensor nicht direkt auf der Platine sitzt, sondern außerhalb des Gehäuses angebracht werden kann. Schließlich soll er die Umgebungstemperatur und -feuchte überwachen.
Dann ist dieser Logger natürlich relativ stumm, d.h. um zu wissen, wie es mit dem Klima steht, muss man die SD-Karte auslesen oder einen Rechner anstecken und schauen, welche Werte auf dem Serial Monitor ausgegeben werden. Ein LCD-Display-Shield wäre hier eine komfortablere Lösung, dann könnte man sich auch die LEDs sparen und die Fehlermeldungen hier lesbar ausgeben.
Und schließlich könnte man das ganze noch per LAN- oder WLAN-Shield netzwerkfähig machen.

Viel Spaß beim experimentieren!
Angela Kipp

  1. Deutschsprachigen Tabellenkalkulationsprogramme haben manchmal Probleme damit, dass die Messwerte einen Punkt als Komma verwenden, also als 21.5 °C statt 21,5 °C erscheinen. Hier muss man dann im Programm entweder auf Englisch umstellen oder per „suchen und ersetzen“ den Punkt gegen ein Komma austauschen.
Facebooktwittergoogle_plusredditpinterestlinkedintumblrmail