Temperatur-Logger

Dieses kleine Projekt soll mit Hilfe einiger Sensoren die Zimmer-Umgebung für längere Zeit messen, damit später eine (grafische) Auswertung gemacht werden kann.

Anforderungen

Der zu bauende Temperatur-Logger soll folgende Aufgaben lösen:

• Messung der aktuellen Umgebungstemperatur in bestimmten Zeitintervallen (z.B. alle 5min.)
• Messung der aktuellen Luftfeuchtigkeit in bestimmten Zeitintervallen (z.B. alle 5min.)
• Messung der aktuellen Helligkeit in bestimmten Zeitintervallen (z.B. alle 5min.)
• Schreiben der gemessenen Werte auf eine SD-Card im CSV-Format: Datum + Uhrzeit, Temperatur, Luftfeuchtigkeit, Helligkeit
• Anzeigen der Mess- und Log-Tätigkeit durch Aufleuchten einer Status-LED
• Der Messungszeitraum sollte mehrere Tage oder sogar Wochen umfassen können

Verwendete Bauteile

• Grundlegende Werkzeuge und Hilfsmittel
• Arduino UNO oder Arduino Nano
• TMP36 Temperatur-Sensor
• DHT22 Temperatur- und Luftfeuchtigkeits-Sensor
• Fotowiderstand (LDR) der GL55xx-Serie
• SD-Card-Modul
• microSD-Karte
• Echtzeit RTC-Modul DC1307
• 3V-Knopfbatterie (CR2032)
• LED (hier: 3mm grün)
• 1kΩ Widerstand
• Steckkabel ("Jumperkabel")
• Steckbrett ("Breadboard")

Aufbau

Abb.: Aufbau des Projektes

Der Aufbau ist eine Zusammenstellung einiger schon verwendeter Module:

• RTC-Modul
• Sensor DHT22
• TMP36 - Sensor
• SD-Card-Modul TE417
• LDR GL55xx

Abb.: Fertiger Prototyp

Software

Die Kombination der Komponenten in der Software war recht problemlos, nur ist durch den Einsatz einiger Libraries der Speicher sehr schnell weniger geworden.

Letztendlich ist durch einige Einsparungen jedoch noch genug für dynamische Variablen vorhanden.

Verwendete Libraries

• Wire (für das RTC-Modul)
• SPI (für SD-Card-Modul)
• SD (für SD-Card-Modul)
• DHT (für den DHT22-Sensor)

Sketch

/** * Used pins: *    A0 TMP36 *    A1 LDR *    A5 SCL (RTC) *    A4 SDA (RTC) *     8 DHT22 *     9 LED *    10 CS      (SD card module) *    11 MOSI    (SD card module) *    12 MISO    (SD card module) *    13 CLK/SCK (SD card module) */#define MEASURING_DELAY 300000   // time in milliseconds between measuring events (should be 5 minutes = 300 seconds = 300000 milliseconds)#define TMP36_AREF_VOLTAGE 5.0   // depends if we´re using 3.3V or 5.0V for operating the TMP36#define TMP36_PIN A0#define DHT22_PIN 8#define LDR_PIN A1#define STATUS_LED_PIN 9#define SDCARD_CS_PIN 10#define DS1307_ADDRESS 0x68   // I2C Address#include <DHT.h>#include <SPI.h>#include <SD.h>#include <Wire.h>const char *SD_FILE = "log.csv";File logFile;unsigned long lastMeasuringTime = 0;int sensorValue = 0;int tmp36Temperature = 0;int ldrBrightness = 0;int dh22Humidity = 0;int dht22Temperature = 0;DHT dht22(DHT22_PIN, DHT22);void setup(){  Serial.begin(9600);  Serial.flush();  pinMode(STATUS_LED_PIN, OUTPUT);  if (!SD.begin(SDCARD_CS_PIN)) {    Serial.println("ERR");    while (true); // stop further execution  }  String logData = String("DATETIME;TEMP1;TEMP2;HUMIDITY;BRIGHTNESS");  Serial.println(logData);  logFile = SD.open(SD_FILE, FILE_WRITE);  if (logFile) {    logFile.println(logData);    logFile.close();  } else {    Serial.println("ERR");  }  dht22.begin();  Wire.begin();}void loop(){  if ((millis() - lastMeasuringTime) > MEASURING_DELAY) {    lastMeasuringTime = millis();    digitalWrite(STATUS_LED_PIN, HIGH);    sensorValue = analogRead(TMP36_PIN);    tmp36Temperature = (int)getTemperature(getVoltage(sensorValue));    ldrBrightness = (int)analogRead(LDR_PIN);    dht22Temperature = (int)dht22.readTemperature();    dh22Humidity = (int)dht22.readHumidity();    String logData = String(getDateTime() + ";" + tmp36Temperature + ";" + dht22Temperature + ";" + dh22Humidity + ";" + ldrBrightness);    Serial.println(logData);    logFile = SD.open(SD_FILE, FILE_WRITE);    if (logFile) {      logFile.println(logData);      logFile.close();    } else {      Serial.println("ERR");    }    digitalWrite(STATUS_LED_PIN, LOW);  }}/** * Converts the 0 to 1023 value from a sensor value into a 0.0 to 5.0 * value that is the true voltage being read at that sensor. */float getVoltage(int sensorValue){  return (sensorValue * TMP36_AREF_VOLTAGE / 1024);}/** * Converting the voltage to degrees Celsius. * The formula comes from the datasheet of the TMP36 */float getTemperature(float voltage){  return (voltage - 0.5) * 100.0;}/** * Converts a decimal (Base-10) integer to BCD (Binary-coded decimal) */int decToBcd(int value){  return ((value/10*16) + (value%10));}/** * Converts a BCD (Binary-coded decimal) to decimal (Base-10) integer */int bcdToDec(int value){  return ((value/16*10) + (value%16));}String getDateTime(){  Wire.beginTransmission(DS1307_ADDRESS);  Wire.write(0x00);  Wire.endTransmission();  Wire.requestFrom(DS1307_ADDRESS, 7);  byte nowSeconds = bcdToDec(Wire.read());  byte nowMinute = bcdToDec(Wire.read());  byte nowHour = bcdToDec(Wire.read() & 0b111111);  byte nowWeekDay = bcdToDec(Wire.read());  byte nowMonthDay = bcdToDec(Wire.read());  byte nowMonth = bcdToDec(Wire.read());  byte nowYear = bcdToDec(Wire.read());  char data[20] = "";  sprintf(data, "20%02d-%02d-%02d %02d:%02d:%02d", nowYear, nowMonth, nowMonthDay, nowHour, nowMinute, nowSeconds);  return String(data);}

Auswertung

Nach ca. 24h Laufzeit ist sind folgende Daten gesammelt worden:

Ideen/Erweiterungen

• OLED: Ursprünglich war noch ein kleines OLED geplant, welches die aktuellen Messdaten per Knopfdruck anzeigt, jedoch hatte ich Probleme, das OLED gleichzeitig mit den SD-Karten-Modul zu betreiben, daher habe ich es wieder aus dem Set entfernt.
  Es lag vermutlich am Speicherbrauch (SRAM) der OLED-Library, denn es werden für den Bildschirm-Puffer im 128×64-Modus immer 1024 Bytes reserviert! Hier wäre ein weiterer Versuch mit der U8g2-Library für die OLED und einer alternativen SD-Library nötig.
• Messung auf das Vorhandensein verschiedener Gase, z.B. CO₂, CO, CH₄, etc.
• Hinzufügen einer mobilen Stromversorgung z.B. durch einen Akku
• Zusätzlich könnten die Daten zu einem IoT-Service wie ThingSpeak versendet werden.

reichelt-Magazin » How-to » Temperatur und Luftfeuchtigkeit mit dem Arduino Uno messen

Temperatur und Luftfeuchtigkeit mit dem Arduino Uno messen

Wir bauen ein Messgerät für Temperatur und Luftfeuchtigkeit, das die Werte auf einem farbigen Display anzeigt – die Farbe ändert sich je nachdem, wie heiß oder kalt es ist. Umgesetzt wird dieses Projekt mit einem Arduino Uno Microcontroller-Board und dem Grove-Erweiterungssystem.

Geeignet für: Anfänger mit Programmier-Vorkenntnissen
Zeitaufwand: circa 1,5 Stunden
Budget: circa 70 Euro
Das brauchen Sie: 1x Arduino Uno Rev. 3, 1x Arduino Shield – Base Shield V2 (Grove Base-Shield), 1x Grove LCD mit RGB-Backlight, 1x Arduino – Grove Temperatur- & Feuchtigkeitssensor Pro (präzise), 1x USB-Kabel 2.0, Hi-Speed A-St auf B-St, 1m

Kann erweitert werden mit: SD-Karte sowie einer Echtzeituhr zum Speichern der Daten

Benötigt wird: Internetanschluss, Computer mit Browser, Stromversorgung für den Arduino

Die Hardware

1. Der Arduino Uno Rev. 3 DIL-Variante  ATmega328P

2. Das Grove Base Shield

Der hier verwendete Temperatur- und Luftfeuchtigkeitssensor und das Display stammen aus dem Grove-Erweiterungssystem, welches eine einfache und schnelle Entwicklung ermöglicht. Das Grove-Base-Shield wird einfach auf den Arduino gesteckt und stellt vier analoge, acht digitale sowie vier I²C-Anschlüsse in einem einheitlichen Steckersystem zur Verfügung.

Die Status-LED und der Reset-Knopf des Arduino-Boards werden von diesem verdeckt und befinden sich deshalb nochmal auf dem Base-Shield.

Wichtig: Der Spannungsschalter auf dem Grove-Base-Shield muss für einen Arduino auf 5 V stehen!

3. Der Temperatur- und Luftfeuchtigkeitssensor

Der hier verwendete “Grove Temperatur- & Feuchtigkeitssensor Pro” basiert auf einem DHT22 Temperatur- und Feuchtigkeitssensor, der die Temperatur auf ± 0,5 °C und die relative Luftfeuchtigkeit auf ± 2 % genau misst.

Der Sensor benötigt einen beliebigen analogen Anschluss, wir verwenden in diesem Projekt A0.

4. Das Display

Das hier verwendete “Grove LCD mit RGB-Backlight” verfügt über zwei Zeilen mit jeweils 16 Zeichen und erlaubt es, eigene Zeichen zu definieren.

Die Hintergrundfarbe ist einstellbar.

Das Display benötigt einen beliebigen I²C Anschluss. Da es sich bei I²C um ein Bussystem handelt, spielt es keine Rolle welchen.

Die Software

Arduino Studio

Das Arduino Studio ist die Entwicklungsumgebung für den Arduino. Dort werden die Programme erstellt (sog. “Sketches”) und in den Arduino geladen.

Außerdem kann auf die serielle Schnittstelle zugegriffen werden, die über den USB-Anschluss bereitgestellt wird.

Arduino Studio ist auf der Arduino-Webseite kostenlos verfügbar:

https://www.arduino.cc/en/Main/Software

Wenn der Arduino mit dem PC verbunden ist, muss im Menü unter “Werkzeuge” → “Port” der Eintrag mit “Arduino/Genuino” ausgewählt sein, damit die Verbindung zum Arduino funktioniert.

Die Bibliotheken

Um die einzelnen Shields und Grove-Bausteine zu verwenden, benötigt man die entsprechenden Bibliotheken, die Programmierschnittstellen zur Verfügung stellen.

Die Bibliothek für das SD-Shield ist bereits standardmäßig verfügbar, für die beiden Grove-Bausteine muss man diese noch installieren:

Grove Temperatur- und Luftfeuchtigkeitssensor Pro

Download: https://github.com/Seeed-Studio/Grove_Temperature_And_Humidity_Sensor/archive/master.zip

Dokumentation: http://wiki.seeed.cc/Grove-Temperature_and_Humidity_Sensor_Pro/

Grove LCD RGB Display

Download: https://github.com/Seeed-Studio/Grove_LCD_RGB_Backlight/archive/master.zip

Dokumentation: http://wiki.seeed.cc/Grove-LCD_RGB_Backlight/

Die Bibliotheken herunterladen, anschließend über das Menü “Sketch” → “Bibliothek einbinden” → “.ZIP-Bibliotheken hinzufügen…” installieren.

Zu allen Bibliotheken gibt es unter “Datei” → “Beispiele” entsprechende Beispiel-Programme.

Das erste Programm: Werte vom Sensor auslesen

GRV TEMP HUM PRO Arduino - Grove Temp. & Feuchte Pro (präzise), DHT22 / AM2302

#include <SPI.h> // Bibliothek für die serielle Schnittstelle laden #include <DHT.h> // Bibliothek für den Sensor laden  // Instanz der Sensorschnittstelle erstellen. // A0 ist der Anschluss am Grove Base Shield, DHT22 der Sensortyp DHT dht(A0, DHT22);   void setup() { // Wird einmal beim Start ausgeführt  Serial.begin(9600); // Serielle Schnittstelle initialisieren  dht.begin(); // Sensor initialisieren }  void loop() { // Wird in einer Endlosschleife ausgeführt  float humidity = dht.readHumidity(); // Daten auslesen  float temperature = dht.readTemperature(); // Daten auslesen   if (isnan(temperature) || isnan(humidity)) { // Hat das Auslesen funktioniert?    Serial.println("Fehler bein lesen von DHT");  } else {    // Daten ausgeben    Serial.print(temperature);    Serial.print(" | ");    Serial.print(humidity);    Serial.println();  }  delay(1000); // Programmausführung für 1s anhalten }

Jedes Arduino-Programm hat zwei Methoden:

setup() wird einmal aufgerufen, wenn das Programm startet – also wenn es neu auf den Arduino gespielt wird, der Reset-Button gedrückt wird oder die Stromzufuhr zum Arduino unterbrochen war.

Hier werden üblicherweise Geräte initialisiert.

loop() wird in einer Endlosschleife aufgerufen, sobald setup beendet wurde. Hier findet die eigentliche Programmlogik statt – die Daten werden vom Sensor ausgelesen, es wird geprüft ob das Auslesen erfolgreich war und die Daten an die Serielle Schnittstelle geschrieben.

Wichtig ist das Delay am Ende:

Hier wird die gesamte Ausführung für 1s unterbrochen, damit man die Konsole auf dem PC noch lesen kann.

Das Programm wird mit “Sketch” → “Überprüfen/Kompilieren” gebaut, sodass es auf den Arduino geschrieben werden kann.

Dabei erhält man auch Meldungen zu Progammierfehlern und möglichen Problemen.

Es kann sein, dass bei diesem Programm eine rote Warnung in der Statusausgabe von Arduino Studio erscheint, weil NAN neu definiert wird.

Das kommt von Bibliothek des Temperatursensors und kann ignoriert werden.

Mit “Sketch” → “Hochladen” wird das Programm auf den Arduino geschrieben, dabei wird es automatisch gebaut. Unter “Werkzeuge” → “Serieller Monitor” ist dann eine Ausgabe zu sehen:

26.10 | 64.5026.20 | 64.5026.20 | 64.50

Das Display ansteuern

#include <Wire.h> #include <rgb_lcd.h> rgb_lcd lcd; // Instanz der Display-Schnittstelle erstellen  byte HEART_SYMBOL = 0; // Sprechender Name für das Symbol byte heart[8] = { // Die Belegung der einzelnen Pixel    0b00000,    0b01010,    0b11111,    0b11111,    0b11111,    0b01110,    0b00100,    0b00000 };  void setup(){  lcd.begin(16, 2); // Display initialisieren - 2 Zeilen mit jeweils 16 Zeichen  lcd.createChar(HEART_SYMBOL, heart); // Herz-Symbol registrieren }  void loop() {  int red = 255;  int green = 0;  int blue = 0;  lcd.setRGB(red, green, blue);   lcd.setCursor(0, 0); // Cursor im Display auf den Anfang der ersten Zeile setzen  lcd.print("I ");  lcd.write(HEART_SYMBOL);  lcd.print(" Arduino");  lcd.setCursor(0, 1); // Cursor im Display auf den Anfang der zweiten Zeile setzen  lcd.print("==========="); } 

Das Programm wieder mit “Sketch” → “Hochladen” auf den Arduino schreiben. Die Ergebnisse auf dem Display sind sofort zu sehen.

Das endgültige Programm

#include <Wire.h> #include <rgb_lcd.h> #include <DHT.h>  rgb_lcd lcd; DHT dht(A0, DHT22);  byte DEGREE_SYMBOL = 0; byte degree[8] = {  0b00000,  0b00010,  0b00101,  0b00010,  0b00000,  0b00000,  0b00000,  0b00000 };  void setup(){  Serial.begin(9600); // Seriellen Anschluss initialisieren   lcd.begin(16, 2); // Display initialisieren - 2 Zeilen mit je 16 Zeichen  lcd.createChar(DEGREE_SYMBOL, degree); // Das neue "°"-Symbol beim Display registrieren  dht.begin(); // Sensor initialisieren }  void loop() {  float humidity = dht.readHumidity();  float temperature = dht.readTemperature();    if (isnan(temperature) || isnan(humidity)) {    Serial.println("Fehler beim Lesen vom Sensor");  } else {    const float coldest = 18;    const float hottest = 30;    int red = limit(255 * (temperature - coldest) / (hottest - coldest));    // Farben von blau über lila nach rot    int green = 0;    // rot und blau je näher man den Grenzen kommt, in der Mitte weiß    // int green = limit(255 * sqrt(max(0, (hottest - temperature)*(temperature - coldest))) / (hottest - coldest));    int blue = limit(255 * (hottest - temperature) / (hottest - coldest));    lcd.setRGB(red, green, blue);        lcd.setCursor(0, 0);    lcd.print("T: ");    lcd.print(temperature);    lcd.write(DEGREE_SYMBOL);    lcd.print("C");     lcd.setCursor(0, 1);    lcd.print("H: ");    lcd.print(humidity);    lcd.print("%");  }  delay(100); }  float limit(float color) { // Farbwerte müssen im Bereich 0..255 liegen  if (color < 0) {    return 0;  }  else if (color > 255) {    return 255;  }  else {    return color;  } } 

Viel Spaß!

reichelt-Magazin » How-to » Fortsetzung: Temperatur-Log mit dem Arduino Uno programmieren

Fortsetzung: Temperatur-Log mit dem Arduino Uno programmieren

Geeignet für: Fortgeschrittene
Zeitaufwand: circa 1,5 Stunden
Budget: circa 30 Euro
Das brauchen Sie: 1x Arduino – Grove Echtzeituhr – RTC, 1x Arduino Shield – SD-Karte V4, 1x Batterie für Grove-Echtzeituhr, 1x SD-Karte

Kann erweitert werden mit:–

Benötigt wird: Internetanschluss, Computer mit Browser, Stromversorgung für den Arduino

Das SD-Shield

Beschreibung und Einbau

https://www.arduino.cc/en/Reference/SD

Daten schreiben – Hallo Welt

Die ersten Daten schreiben wir mit folgendem Programm auf die Karte:

#include <SPI.h>#include <SD.h>int SELECTED_CHIP = 4;int count = 0;void setup() { Serial.begin(9600); if (SD.begin(SELECTED_CHIP)) {   Serial.println("SD-Card initialized.");   } else {   Serial.println("SD-Card failed or is missing");     }}void loop() { String line = String("Hallo Welt #") + String(count); writeToSD(line); count = count + 1; delay(1000);}void writeToSD(String line) { File dataFile = SD.open("test.csv", FILE_WRITE); if (dataFile) {   dataFile.println(line); // Auf die SD-Karte schreiben   dataFile.close();       // Datei schließen   Serial.println(line); } else {   Serial.println("Error opening datafile"); }}

Die Echtzeituhr

Beschreibung und Einbauen

Download: https://github.com/Seeed-Studio/RTC_DS1307/archive/master.zip

Dokumentation: http://wiki.seeed.cc/Grove-RTC/

Die Bibliotheken herunterladen, anschließend über das Menü “Sketch” → “Bibliothek einbinden” → “.ZIP-Bibliotheken hinzufügen…” installieren.

Zu allen Bibliotheken gibt es unter “Datei” → “Beispiele” Beispiel-Programme.

Zeit stellen und auslesen

#include <Wire.h>#include <DS1307.h>DS1307 clock; // ein Uhr-Objekt anlegenvoid setup() { Serial.begin(9600); // Die Verbindung zur Uhr aufbauen clock.begin(); // Die Zeit einstellen clock.fillByYMD(2017, 9, 24); clock.fillByHMS(18, 53, 15); clock.fillDayOfWeek(SAT); clock.setTime();}void loop() { printTime(); delay(1000);}void printTime() { clock.getTime(); // Zeit vom Chip abfragen Serial.print(clock.hour, DEC); Serial.print(":"); Serial.print(clock.minute, DEC); Serial.print(":"); Serial.print(clock.second, DEC); Serial.print(" | "); Serial.print(clock.dayOfMonth, DEC); Serial.print("."); Serial.print(clock.month, DEC); Serial.print("."); Serial.print(clock.year, DEC); Serial.println();}

Das endgültige Datenlogger-Programm

Nachdem wir alle Teile einmal getestet haben, können wir das Programm aus dem letzten Tutorial erweitern:

#include <SPI.h>#include <SD.h>#include <Wire.h>#include <DS1307.h>#include <DHT.h>#include <rgb_lcd.h>DS1307 clock;DHT dht(A0, DHT22);rgb_lcd lcd;byte DEGREE_SYMBOL = 0;byte degree[8] = { 0b00000, 0b00010, 0b00101, 0b00010, 0b00000, 0b00000, 0b00000, 0b00000};unsigned long DISPLAY_UPDATE_INTERVAL = 200; // 200 Millisekundenunsigned long WRITE_INTERVAL = 60000; // 1 Minutenunsigned long lastDisplayUpdate = DISPLAY_UPDATE_INTERVAL;unsigned long lastWrite = WRITE_INTERVAL;void setup() { Serial.begin(9600); // Serielle Schnittstelle initialisieren // SD Karte initialisieren int selectedChip = 4; if (!SD.begin(selectedChip)) {   Serial.println("SD-Card failed or is missing"); } else {   Serial.println("SD-Card initialized.");   } dht.begin(); // Verbindung zum Sensor herstellen clock.begin(); // Verbindung zur Echtzeituhr herstellen lcd.begin(16, 2); // Verbindung zum Display herstellen und Display initialisieren - 2 Zeilen mit je 16 Zeichen lcd.createChar(DEGREE_SYMBOL, degree); // Das neue "°"-Symbol beim Display registrieren  }void loop() { float humidity = dht.readHumidity(); float temperature = dht.readTemperature(); if (isnan(temperature) || isnan(humidity)) {   Serial.println("Failed to read from DHT");   return; // Keine Daten --> loop() an dieser Stelle wieder verlassen } if (millis() - lastDisplayUpdate > DISPLAY_UPDATE_INTERVAL) {   const float coldest = 18;   const float hottest = 30;   int red = limit(255 * (temperature - coldest) / (hottest - coldest));   // Farben von blau über lila nach rot   int green = 0;   int blue = limit(255 * (hottest - temperature) / (hottest - coldest));   updateDisplay(red, green, blue, temperature, humidity);   lastDisplayUpdate = millis(); } if (millis() - lastWrite > WRITE_INTERVAL) {   String line = String(getTime()) + ";" + String(temperature) + ";" + String(humidity);   writeToSD(line);   lastWrite = millis(); }}String getTime() { clock.getTime(); // Zeit vom Chip abfragen String t = String(clock.dayOfMonth, DEC); t += String("."); t += String(clock.month); t += String("."); t += String(clock.year); t += String(" "); t += String(clock.hour); t += ":"; t += String(clock.minute); t += ":"; t += String(clock.second); return t;}void writeToSD(String line) { File dataFile = SD.open("datalog.csv", FILE_WRITE); if (dataFile) {   dataFile.println(line); // Auf die SD-Karte schreiben   dataFile.close();   Serial.println(line); // Zusätzlich auf serielle Schnittstelle schreiben zum Debuggen } else {   Serial.println("Error opening datafile"); }}void updateDisplay(int red, int green, int blue, float temperature, float humidity) { lcd.setRGB(red, green, blue); lcd.setCursor(0, 0); lcd.print("T: "); lcd.print(temperature); lcd.write(DEGREE_SYMBOL); lcd.print("C"); lcd.setCursor(0, 1); lcd.print("H: "); lcd.print(humidity); lcd.print("%");}float limit(float color) { // Farbwerte müssen im Bereich 0..255 liegen if (color < 0) {   return 0; } else if (color > 255) {   return 255; } else {   return color; }}

Auswertung der Daten

Die Daten werden in eine Datei mit dem Namen datalog.csv geschrieben und können zur Auswertung in Excel, LibreOffice Calc oder Google Spreadsheets importiert werden.

Einfach die SD-Karte aus dem Arduino entfernen und am PC auslesen.

Viel Spaß!

#include <Wire.h>#include "RTClib.h"#include "DHT.h"#include <SPI.h>#include <SD.h>#define DHTPIN 2     //Pin für DHT#define DHTTYPE DHT22 DHT dht(DHTPIN, DHTTYPE);RTC_DS1307 rtc;File logFile;const int chipSelect = 10; //für AZ-Delivery Data-Logger Shieldconst int zeit = 5000; //Messintervalllong temperature;long humidity;void setup() {    pinMode(10, OUTPUT);  Serial.begin(9600);  dht.begin();  rtc.begin();  SD.begin (chipSelect);  char filename[] = "LOGGER00.CSV";                         for (uint8_t i = 0; i < 100; i++) {    filename[6] = i/10 + '0';    filename[7] = i%10 + '0';    if (! SD.exists(filename)) {      // only open a new file if it doesn't exist      logFile = SD.open(filename, FILE_WRITE);       break;  // leave the loop!    }  }  if (!logFile) {    Serial.println("could not create file");  }  Serial.print("Start logging: ");  Serial.println(filename);  logFile.print ("Start logging");  logFile.println();}void loop() {  delay (zeit);  humidity = dht.readHumidity();  temperature = dht.readTemperature();  DateTime now = rtc.now();  logFile.print(now.day(), DEC);  logFile.print('/');  logFile.print(now.month(), DEC);  logFile.print('/');  logFile.print(now.year(), DEC);  logFile.print(',');  logFile.print(' ');  logFile.print(now.hour(), DEC);  logFile.print(':');  logFile.print(now.minute(), DEC);  logFile.print(':');  logFile.print(now.second(), DEC);  logFile.print (",");  logFile.print (" ");  logFile.print (temperature);  logFile.print (",");  logFile.print (" ");  logFile.print (humidity);  logFile.println();  logFile.flush();  Serial.print(now.day(), DEC);  Serial.print('/');  Serial.print(now.month(), DEC);  Serial.print('/');  Serial.print(now.year(), DEC);  Serial.print(',');  Serial.print(' ');  Serial.print(now.hour(), DEC);  Serial.print(':');  Serial.print(now.minute(), DEC);  Serial.print(':');  Serial.print(now.second(), DEC);  Serial.print (",");  Serial.print (" ");  Serial.print (temperature);  Serial.print (" Grad bei");  Serial.print (",");  Serial.print (" ");  Serial.print (humidity);  Serial.print (" %");  Serial.println(); }

DHT22 / AM2302-Luftfeuchte und Temperatursensor

Arduino: Das LCD Display

Schaltplan Arduino mit LCD Display

Schritt für Schritt Anleitung: Arduino mit LCD Display (Video)

Benötigte Elemente

• HD44780 1602 LCD Module Display
• Original Arduino Uno Rev.3 oder UNO-R3 Rev3 Arduino kompatibles Board
• Nettes Set mit Potis, Widerständen und Schaltern
• Steckboard (Breadboard) oder als Set: Breadboard + Kabelbrücken

Sketch Arduino mit LCD Display

12345678910111213141516171819202122232425262728293031

//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!#include < LiquidCrystal.h > LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() {// Definition von LCD: 16 Zeichen, 2 Zeilenlcd.begin(16, 2); // Wir schreiben in die erste Zeile:lcd.print("test-"); // Wir setzen den Cursor in die zweite Zeilelcd.setCursor(0, 1);lcd.print("wetterstation.de");} void loop() { // Wir schalten das Display auslcd.noDisplay(); // Und warten ...delay(500); // Und schalten das Display wieder an ...lcd.display(); // Und warten wiederdelay(500);}

Grundsätzliches

Technische Daten (Herstellerangaben)

Der LM35 am Arduino

Temperaturgenauigkeit des LM35 erhöhen:

Schaltplan Arduino mit LM35

Schritt für Schritt Anleitung: Arduino mit LM35 (Video)

Benötigte Elemente

• 5 x LM 35 DZ Temperatur Sensor / Digital Thermometer
• Original Arduino Uno Rev.3 oder UNO-R3 Rev3 Arduino kompatibles Board
• Nettes Set mit Potis, Widerständen und Schaltern
• Steckboard (Breadboard) oder als Set: Breadboard + Kabelbrücken

Sketch Arduino mit LM35

123456789101112131415161718192021222324252627

//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!#include < LiquidCrystal.h > //LCD DisplayLiquidCrystal lcd(12, 11, 5, 4, 3, 2); #define sensorPin 0 // LM35 auf Ausgang A0 (analog) setzen void setup() {lcd.begin(16, 2);} void loop(){ int rawvoltage = analogRead(sensorPin);float millivolts = (rawvoltage/1024.0) * 5000;float celsius = millivolts/10; lcd.setCursor(0, 0);lcd.print("Temperatur:"); lcd.setCursor(11, 0);lcd.print(celsius); //Wartedelay(2000);}

Messwerte des LM35

Der DHT11 am Arduino

Im Gegensatz zu den Sensoren LM35 und DS18B20 ermitteln die Temperatursensoren DHT11 und 22 auch die Luftfeuchtigkeit.

Diese geben wir auf unserem LCD Display aus, werden die Werte aber nicht weiter hinterfragen.
Grundsätzliche Unterschiede der folgenden Sensoren zum LM35 ist der, dass diese Sensoren nun die Daten digital über einen Datenbus übertragen (1-Wire Protocol).  Ausführlicher werden wir uns beim DS18B20 mit dem 1-Wire-Protocol beschäftigen.

Meist wird der DHT11 wie in unserem Beispiel in einer 4-Pin-Version geliefert.

Es sind jedoch auf Versionen mit einem Breakout-Board erhältlich, die nur die notwendigen drei Pins besitzen. Für unsere Zwecke sind beide Versionen nutzbar.

Schaltplan Arduino mit DHT11

Schritt für Schritt Anleitung: Arduino DHT11 (Video)

Benötigte Elemente

• DHT11
• Original Arduino Uno Rev.3 oder UNO-R3 Rev3 Arduino kompatibles Board
• Nettes Set mit Potis, Widerständen und Schaltern
• Steckboard (Breadboard) oder als Set: Breadboard + Kabelbrücken

Sketch Arduino mit DHT11

12345678910111213141516171819202122232425262728293031323334353637

//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!#include < LiquidCrystal.h > //LCD DisplayLiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Adafruit DHT library https://github.com/nethoncho/Arduino-DHT22/tree/a655c6299b019cf53173139dad824466486591c8#include "DHT.h"#define DHTPIN 8 // Ich nutze Digital-PIN 8#define DHTTYPE DHT11DHT dht(DHTPIN, DHTTYPE); void setup() {lcd.begin(16, 2);} void loop() { //Wartedelay(2000); //Lese die Luftfeuchtigkeitfloat h = dht.readHumidity(); // Lese die Temperatur in Celsiusfloat t = dht.readTemperature(); lcd.setCursor(0, 0);lcd.print("Temperatur:");lcd.setCursor(0, 1);lcd.print("Humidity:"); lcd.setCursor(11, 0);lcd.print(t);lcd.setCursor(11, 1);lcd.print(h);}

Messwerte des DHT11

Der DHT22 am Arduino

Video: Schritt für Schritt Anleitung: Arduino DHT22

Benötigte Elemente

• DHT22/AM2302 digital Sensor
• Original Arduino Uno Rev.3 oder UNO-R3 Rev3 Arduino kompatibles Board
• Nettes Set mit Potis, Widerständen und Schaltern
• Steckboard (Breadboard) oder als Set: Breadboard + Kabelbrücken

Schaltplan Arduino mit DHT22

Sketch Arduino mit DHT22

123456789101112131415161718192021222324252627282930313233343536

//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!#include < LiquidCrystal.h >//LCD DisplayLiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Adafruit DHT library https://github.com/nethoncho/Arduino-DHT22/tree/a655c6299b019cf53173139dad824466486591c8#include "DHT.h"#define DHTPIN 8 // Ich nutze Digital-PIN 8#define DHTTYPE DHT22 // DHT 22 (AM2302)DHT dht(DHTPIN, DHTTYPE); void setup() {lcd.begin(16, 2);} void loop() { //Wartedelay(2000); // Lese die Luftfeuchtigkeitfloat h = dht.readHumidity(); // Lese die Temperatur in Celsiusfloat t = dht.readTemperature(); lcd.setCursor(0, 0);lcd.print("Temperatur:");lcd.setCursor(0, 1);lcd.print("Humidity:"); lcd.setCursor(11, 0);lcd.print(t);lcd.setCursor(11, 1);lcd.print(h);}

Messwerte des DHT22

Der DS18B20 am Arduino

Schritt für Schritt Anleitung: Arduino DS18B20 (Video)

Benötigte Elemente

• 10 x DS18B20 Digitale Temperaturfühler
• Original Arduino Uno Rev.3 oder UNO-R3 Rev3 Arduino kompatibles Board
• Nettes Set mit Potis, Widerständen und Schaltern
• Steckboard (Breadboard) oder als Set: Breadboard + Kabelbrücken

Schaltplan Arduino mit DS18B20

Sketch Arduino mit DS18B20

123456789101112131415161718192021222324252627282930313233343536373839404142434445

//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!#include < OneWire.h >#include < DallasTemperature.h >#include < LiquidCrystal.h > LiquidCrystal lcd(12, 11, 5, 4, 3, 2); const unsigned long Baud_Rate = 9600;const unsigned char One_Wire_Bus = 8; OneWire oneWire(One_Wire_Bus);DallasTemperature sensoren(&oneWire); int Anzahl_Sensoren = 0; void setup() {//LCD vorbereitenlcd.begin(16, 2); sensoren.begin();Serial.begin(Baud_Rate); //Hier schauen wir, wieviel Sensoren angeschlossen sindAnzahl_Sensoren = sensoren.getDeviceCount();} void loop() {//Wartedelay(2000); sensoren.requestTemperatures(); //Hier lesen wir den ersten Sensor (0) ausfloat temperatur = sensoren.getTempCByIndex(0); lcd.setCursor(0, 0);lcd.print("Temperatur:");lcd.setCursor(0, 1);lcd.print("Anzahl Sens.:"); lcd.setCursor(11, 0);lcd.print(temperatur);lcd.setCursor(15, 1);lcd.print(Anzahl_Sensoren);}

Messwerte des DS18B20

Fazit

Arduino Lektion 27: Daten loggen mit dem Logging Shield

Arduino Lektion 44: BME280 Temperatur, Luftfeuchtigkeit und Luftdruck Sensor

Temperatur kontrollierter Ventilator

Ein kleiner PC-Lüfter soll abhängig von der Temperatur an- und ausgeschaltet werden. Zur Ermittlung der Temperatur wird ein Thermistor und zur Steuerung ein Arduino Uno verwendet.

Verwendete Bauteile

• Grundlegende Werkzeuge und Hilfsmittel
• Arduino UNO (oder kompatibles Board)
• Thermistor
• 1kΩ Widerstand
• 10kΩ Widerstand
• NPN-Transistor (hier: BC547B)
• Diode IN4007 (o.ä.)
• kleiner Lüfter (hier: ⌀ 60mm)
• Steckkabel ("Jumperkabel")
• Steckbrett ("Breadboard")

Aufbau

Sketches

Der erste Versuch dient nur als Test und soll den Lüfter alle 5 Sekunden ein- und ausschalten:

#define PIN_FAN 10void setup(){    pinMode(PIN_FAN, OUTPUT);}void loop(){    digitalWrite(PIN_FAN, HIGH);    delay(5000);    digitalWrite(PIN_FAN, LOW);    delay(5000);}

#define PIN_FAN        10#define PIN_THERMISTOR A0#define TEMP_FAN_OFF 440#define TEMP_FAN_ON  500#define MEASURE_RESOLUTION 3000 // interval in millisecondsunsigned long lastMeasureTime = 0;int tempValue = 0;bool fanStatus = false;void setup(){    pinMode(PIN_FAN, OUTPUT);    pinMode(PIN_THERMISTOR, INPUT);    Serial.begin(9600);}void loop(){    if ((millis() - lastMeasureTime) > MEASURE_RESOLUTION) {        tempValue = analogRead(PIN_THERMISTOR);        Serial.println(tempValue);        if (tempValue > TEMP_FAN_ON && fanStatus == false) {            Serial.println("Fan: ON");            digitalWrite(PIN_FAN, HIGH);            fanStatus = true;        } else if (tempValue < TEMP_FAN_OFF && fanStatus == true) {            Serial.println("Fan: OFF");            digitalWrite(PIN_FAN, LOW);            fanStatus = false;        }        lastMeasureTime = millis();    }}