Datenlogger

http://sites.prenninger.com/arduino-uno-r3/datenlogger

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2016-11-20

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   (Heftrand 15mm / 5mm)     siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_elektronik-home-seiten.normen.fritz.1 (xx Seiten)_1a.pdf


Datenprotokollierung mit ARDUINO Datenlogger


Daten Recorder Shield für Arduino UNO
Recorder Shield Modul Logging für SD-Karte
Daten Logger Modul Logging Shield
Datenlogger-Modul für ARDUINO UNO R3



Datenlogger.zip
https://funduino.de/downloads


SD Card Erweiterung
Datalogger

Data-Logger Shield for Arduino
Data Loggin Shield von Adafruit
Logger Shield Datalogging for Arduino

Adafruit Data loggin shield for Arduino
DS1307 als RTC  (I2C)    http://github.com/adafruit/RTClib
Slot für SD-Card
SD-Card 32MB  FAT32 formatiert   SdFat Library   http://code.google.com/p/sdfatlib/  
http://code.google.com/p/fatlib/
http://www.sdcard.org/consumers/formatter/

DataLogger.ino
Quelltext DS1307_Setup.ino
Quelltext DS1307_Setup_1.ino

date,             time,           data
2019-05-10  123:59:59,  304.6

Hier ist ein praktischer Arduino-Schild:
Viele Leute haben nach einem dedizierten und gut gestalteten Datenprotokollierungsschild gesucht.
Wir haben hart gearbeitet, um ein kostengünstiges, aber abgerundetes Design zu entwickeln.
Mit diesem Schild können Sie Ihrem Arduino ganz einfach eine 'Festplatte' mit Gigabyte Speicher hinzufügen!

Unsere neueste Version dieses beliebten Schildes verfügt über alle Funktionen des beliebten Originals und ist "R3" -kompatibel, sodass Sie sie mit nahezu jedem Arduino oder kompatiblen Gerät verwenden können.
Sie können damit in weniger als 15 Minuten arbeiten und Daten in Dateien auf einer mit FAT16 oder FAT32 formatierten SD-Karte speichern, die von einem Plot-, Tabellen- oder Analyseprogramm gelesen werden können.
Dieses Tutorial zeigt Ihnen auch, wie Sie zwei kostenlose Softwareprogramme zum Plotten Ihrer Daten verwenden.
Die mitgelieferte Echtzeituhr (RTC) kann verwendet werden, um alle Ihre Daten mit der aktuellen Zeit zu versehen, sodass Sie genau wissen, was wann passiert ist!

Der Datenlogger ist ein zuverlässiges, abgerundetes und vielseitiges Design.
Es kann leicht erweitert oder geändert werden und wird durch Online-Dokumentation und -Bibliotheken unterstützt

Eigenschaften:
Die SD-Kartenschnittstelle funktioniert mit FAT16- oder FAT32-formatierten Karten.
Dank der integrierten 3,3V Pegel-Shifter-Schaltung können Sie sehr schnell lesen oder schreiben und Schäden an Ihrer SD-Karte vermeiden
Die Echtzeituhr (RTC) hält die Zeit auch dann aufrecht, wenn das Arduino vom Stromnetz getrennt ist.
Die Pufferbatterie der Knopfzelle hält jahrelang
Mit den enthaltenen Bibliotheken und dem Beispielcode für SD und RTC können Sie schnell loslegen
Prototyping-Bereich zum Löten von Steckverbindern, Schaltkreisen oder Sensoren.
Zwei konfigurierbare Anzeige-LEDs
Der integrierte 3,3V Regler ist sowohl eine zuverlässige Referenzspannung als auch ein zuverlässiger Betrieb von SD-Karten, für deren Betrieb viel Strom benötigt wird
Verwendet die "R3-Layout" -I2C- und ICSP / SPI-Ports, sodass sie mit einer Vielzahl von Arduinos und Arduino-kompatiblen Geräten kompatibel sind

Mit dieser neuen Version können Sie es verwenden mit:

Arduino UNO        oder ATmega328   kompatibel -   4 analoge Kanäle bei 10-bit Auflösung, 6, wenn keine RTC verwendet wird
Arduino Leonardo oder ATmega32u4 kompatibel - 12 analoge Kanäle bei 10-bit Auflösung
Arduino Mega       oder ATmega2560 kompatibel - 16 analoge Eingänge bei 10-bit
Arduino Zero oder ATSAMD21 kompatibel - 6 analoge Eingänge bei 12-bit
Arduino Due kompatibel - 12 analoge Eingänge  12-bit


Natürlich können Sie alles protokollieren, was Sie möchten, einschließlich digitaler Sensoren mit Arduino-Bibliotheken, seriellen Daten, Bit-Timings und vielem mehr!

BUCH: Arduino  -  Hard- und Software  - Open Source Plattform  Seite 61 =  Sketch  DataLogger.ino

http://www.ladyada.net/make/logshield
https://learn.adafruit.com/adafruit-data-logger-shield




Adafruit Assembled Data Logging shield for Arduino
https://www.adafruit.com/products/1141
https://learn.adafruit.com/adafruit-data-logger-shield/overview
https://learn.adafruit.com/downloads/pdf/adafruit-data-logger-shield.pdf
https://learn.adafruit.com/adafruit-data-logger-shield
Licht und Temperatur Datenlogger
http://www.amazon.de/Adafruit-Licht-und-Temperatur-Datenlogger-pack/dp/B008AS4532

http://www.arduino.cc/en/Tutorial/Datalogger
http://arduino-praxis.ch/2012/02/kitreview-sd-card-rtc-logshield/
http://arduino-projekte.webnode.at/meine-projekte/datenubertragung-per-funk-und-visualisierung-am-grafikdisplay/datenlogger/
http://beelogger.de/
http://beelogger.de/
http://computers.tutsplus.com/tutorials/how-to-add-an-sd-card-data-logger-to-an-arduino-project--cms-21713
http://fablab-cottbus.de/index.php/Arduino-Datenlogger
http://forum.arduino.cc/index.php?topic=123416.0
http://physudo.blogspot.co.at/2013/09/sd-karten-mit-dem-arduino-beschreiben.html
http://www.a-d-k.de/20111229_180325-solda.htm
http://www.amazon.de/geekria-Arduino-Datenlogger-Recorder-Logging/dp/B00O43BVES
http://www.daedalus.ei.tum.de/attachments/article/130/Praktikumsbericht_Datenlogger.pdf
http://www.daedalus.ei.tum.de/attachments/article/130/Praktikumsbericht_Datenlogger.pdf
http://www.diss.fu-berlin.de/docs/servlets/MCRFileNodeServlet/FUDOCS_derivate_000000003352/498-2453-1-PB.pdf
http://www.instesre.org/papers/ProgrammingGuide.pdf
http://www.instructables.com/id/Data-Logger-Project/
http://www.instructables.com/id/Logger-Shield-Datalogging-for-Arduino/
http://www.jeremyblum.com/2011/04/05/tutorial-11-for-arduino-sd-cards-and-datalogging/
http://www.kriwanek.de/arduino/komponenten/172-datenerfassung-ds18b20-interrupts-und-rtc-pcf8583.html
http://www.maxpie.de/Data%20Logging%20Shield%20Testmessungen.pdf
http://www.maxpie.de/Data%20Logging%20Shield%20Testmessungen.pdf
http://www.nmea.de/schaltung/openseamap-datenlogger-teil3-SD-karte-schreiben.html
http://www.physi.uni-heidelberg.de/~eisele/lehrer/Arduino-Messsysteme-VortragLehrertreffen.pdf
http://www.rc-network.de/forum/showthread.php/535749-Arduino-GPS-Datenlogger-DIY-Projekt
http://www.reise-urlaubsfotografie.de/tutorial/arduino/temp-logger.php
https://books.google.at/books?id=M_hhCAAAQBAJ&pg=PT432&lpg=PT432&dq=arduino+datenlogger&source=bl&ots=DWPakQuxfW&sig=a1LQm4E-nhnviiadN1ftEOo_-rE&hl=de&sa=X&ved=0ahUKEwjggfeClJDMAhXEWxQKHVXLC-g4HhDoAQgdMAA#v=onepage&q=arduino%20datenlogger&f=false

https://sites.google.com/site/prozessorwelt/ardu/arduino-octologg
https://www.arduino.cc/en/Tutorial/Datalogger
https://www.christians-shop.de/Datenlogger-Modul-Shield-fuer-Arduino-UNO-mit-RTC-und-SD-Card
https://www.mikrocontroller.net/topic/291613







********************************************************I*
[1]    LM75 Digital Temperature Sensor and Thermal Watchdog with Two-Wire Interface
www.national.com/ds/LM/LM75.pd[
[2]    myAVR - Das System zum Lernen und Experimentieren
http ://shop.myarvr.de/index
[3]    Wire Library
http://www.arduino.cc/en/Reference/Wire
[4]    8-bit AVR Microcontroller with 4/8/16/32K Bytes In-System Programmable Flash
http://wvw.watmel.com/dyn/resources/prod_documents/8271.pdf
[5]    PCF8591 8-bit A/D and D/A converter
http://www.nxp.com/acrobat download/datasheets/PCF8591_6.pdf
[6]    I2C-Analogkarte
http://www.horter.de/i2c/i2c-analog-u/analog-u_ 1.html
[7]    Enabled 16x2 LCD - White on Black 5V
http://www.sparkfun.com/commerce/product info,php?products_id=9395
[8]    HD44780 Datasheet
http://www.sparkfun.com/datasheets/LCD/HD44780pdf
[9]    Adafruit Data logging shield for Arduino
http://www.ladyada.net/make/logshield/
[10]    VT 100
http://de.wikipedia.org/wiki/VT100
[11]    VT100 Command Set
http://braun-home.net/michael/info/miscNT100_commands.htm
[12]    PuTTY
http://www.putty.org/
[13]    UNIX Timestamp Converter
http://www.gaijin.at/olsutc.php
[14]    EM 4102 - Read Only Contactless Identification Device
http://www.emmicroelectronic.com/webfiles/Product/RFID/DS/EM4102_DS.pdf
[15]    OEM-SR28e-232, Reader,TTL/RS232 Datasheet
http://www.rss-systems.de/d0a1239be51301b07/d0a123993d0a51b09/d0a12399df0b08205/d  0a123993c0721001.htm
[16]    Arduino Ethernet Shield von Sparkfun (DEV-09026)
http://www.sparkfun.com/commerce/product_info.pho?  products_id=9026
[17]    Wiznet W5100
http://www.wiznet.co.kr/Sub_Modules/en/product/Product Detail.asp?  cate1 =5&cate2=7&cate3=26&pid=1011
[18]    Wiznet Ethernet Shield von Seeed
http://www.seeedstudio.com/depot/wiznet-ethernet-s-hield-w5100-p-518.html?cPath=35
[19]    Arduino Ethernet-Shield Bausatz für Mega/Duemilanove/ Diecimila (NKC)
http://www.watterottcom/de/NKC-Ethernet-Shield
[20]    SC Card Library
http://code.google.com/p/sdfatlib/
[21]    Arduino Ethernet Library
http://arduino.cc/en/Reference/Ethernet
[22]    Datenblatt SHT21
http://www.sensirion.com/de/pdf/product_information/Datasheet-hu-midity-sensor-SHT21.pdf
[23]    NVU - Open Source WYSIWYG HTML Editor
http://net2.com/nvu/
[24]    Automatische Weiterleitung zu anderer Adresse (Forwarding)
http://de.selfhtml.org/html/kopfdaten/meta.htm#weiterleitunq
[25]    Twitter Library
http://www.arduino.cc/playground/Code/TwitterLibrary
[26]    Base64 Codier-/Decodier-Tool
http://www.patshaping.de/projekte/kleinkram/base64.php
[27]    OAuth
http://de.wikipedia.org/wiki/OAuth
[28]    How to Send Email Using Telnet
http://www.wikihow.com/Send-Email-Using-Telnet
[29]    Email versenden per Telnet
http://www.nerd2nerd.org/services/email/email-versenden-per-telnet
[30]    Interrupt - Beschreibung gemäß Wikipedia
http://de.wikipedia.org/wiki/Interrupt

BUCH: Arduino  -  Hard- und Software  - Open Source Plattform  Seite 61 =  Sketch  DataLogger.ino







********************************************************I*
Temperatur-Logger mit dem Arduino

Temperatur- Luftfeuchtigkeit- Helligkeit-Logger mit dem Arduino

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

Aufbau

Abb.: Aufbau des Projektes

Der Aufbau ist eine Zusammenstellung einiger schon verwendeter Module:






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:



Abb.: Ausschnitt der Datentabelle



Abb.: Diagrammdarstellung der Daten

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. CO2, CO, CH4, 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.


Quelle:
htps://elektro.turanis.de/html/prj058/index.html



********************************************************I*
Temperatur-Log mit dem Arduino Uno messen Teil 1

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

Das Arduino Uno Microcontroller-Board bringt alles mit, was man für ein Microcontroller-Projekt braucht, ohne dass aufwändige Elektronik-Kenntnisse zwingend notwendig sind. Gleichzeitig bietet es vielfältige Möglichkeiten für anspruchsvolle Projekte.

Die Programmierung erfolgt über eine USB-Schnittstelle, die auch als serielle Schnittstelle zur Ausgabe von Daten dient.
Die Stromversorgung erfolgt über ein Netzteil oder Batterien mit 9-12 V (beim Stecker auf die Polung achten – innen Plus, außen Minus) oder den USB-Anschluss.

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


Wir starten mit einem Programm, mit dem wir nur die Werte des Temperatursensors auf die serielle Schnittstelle ausgeben:
#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.50
26.20 | 64.50
26.20 | 64.50

Das Display ansteuern

ARD SHD BASE V2 Arduino Shield - Base Shield V2


Für die ersten Schritte mit dem LCD-Display definieren wir eine Instanz des Displays und ein Array mit der Pixelbelegung für ein neues Zeichen.
In setup() wird dieses Zeichen dann beim Display registriert. In loop() stellen wir die Farbe auf Rot und schreiben Text mit dem neuen Zeichen in das Display.
#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

Für eine Anzeige von Temperatur und Luftfeuchtigkeit auf dem Display kombinieren wir die beiden Programme.
Das Display kann noch kein -Zeichen, also definieren wir eines analog zum Herz aus dem vorherigen Programm.

In setup() werden Serielle Schnittstelle, Sensor und Display initialisiert und das neue Symbol beim Display registriert.
In loop() werden Temperatur und Luftfeuchtigkeit abgefragt, aus der Temperatur die Farbwerte berechnen und alles angezeigt.

Die Formeln sind so gewählt, dass das Display intensiv blau ist, wenn die Temperatur gleich oder kleiner dem Wert von coldest ist, und intensiv rot wenn die Temperatur gleich oder größer dem Wert von hottest ist. Wenn der Grün-Wert auf 0 bleibt, geht der Übergang von Blau nach Rot über Violett.
Soll der Übergang stattdessen Weiß sein und das Display nur an den Enden farbig, dann kann man die alternative Formel einkommentieren.
Die Methode limit(float color) sorgt dafür, dass die Farbwerte im zulässigen Bereich von 0.255 bleiben – Temperaturen kleiner als coldest würden sonst zum Beispiel negative Farbwerte ergeben.
Die Umwandlung von einer Fließkommazahl (float) zu einem ganzzahligen Farbwert (int) erfolgt automatisch, die Nachkommastellen fallen weg.



#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ß!


Quelle.
https://www.reichelt.de/magazin/how-to/arduino-uno-temperatur-luftfeuchtigkeit-messen/?




Temperatur-Log mit dem Arduino Uno programmieren Teil 2

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


Fortsetzung: Temperatur-Log mit dem Arduino Uno programmieren

Im letzten Arduino-How-To haben wir eine Anzeige für Temperatur und Luftfeuchtigkeit gebaut.
Diese wird jetzt um das Speichern der Daten auf eine SD-Karte erweitert, zu jeder Messung wird außerdem der jeweilige Zeitpunkt erfasst.
Neu hinzukommen damit ein Shield für eine SD-Karte sowie eine Echtzeituhr.
Das Display kann weiter am Grove-Shield verbleiben. Wenn man den Datenlogger ohne Display betreiben möchte, kann man es einfach abstecken.

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

Der Datenlogger speichert seine Daten auf eine handelsübliche SD, SDHC oder MicroSD-Karte (dann mit Adapter).
Dafür gibt es ein Shield, das zwischen den Arduino und dem Base-Shield gesteckt wird – das Base-Shield bleibt wegen der Stecker oben.
Die für das SD-Shield notwendigen Bibliotheken sind bereits im Arduino Studio enthalten, müssen also nicht separat installiert werden.
Die Dokumentation ist in der Arduino-Referenz zu finden:

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");
 }
}
Zunächst werden zwei Variablen definiert: SELECTED_CHIP gibt an, welche Hardware beim SD-Shield verwendet wird.
Den Wert erhält man vom Hersteller des SD-Shields.
Die Variable count dient lediglich dazu, die fortlaufenden Schreibvorgänge mitzuzählen um die Nummer mit auf die Karte zu schreiben.

In setup() wird zuerst eine serielle Verbindung zum Debuggen hergestellt, danach eine Verbindung zur SD-Karte.
Die Methode SD.begin() gibt zurück, ob die Verbindung erfolgreich hergestellt werden konnte.

In loop() wird die Zeile aufgebaut, die anschließend mit writeToSD() auf die SD-Karte geschrieben wird.
Wir verwenden dazu die String-Klasse, die eine flexible Arbeit mit Zeichenketten ermöglicht.
Der Operator + verbindet zwei Strings, die Variable count wird deswegen mit String(count) zuerst in einen String umgewandelt. Der Wert von count wird noch um eins erhöht und schließlich eine Sekunde gewartet.

Das Schreiben passiert in writeToSD().
Dort wird zunächst mit SD.open() eine Datei geöffnet oder neu erstellt, wenn diese noch nicht existiert (wichtig:
der Dateiname darf maximal 8 Zeichen lang sein). FILE_WRITE gibt an, dass die Datei schreibbar geöffnet werden soll.

Wenn das Öffnen erfolgreich war enthält file ein Objekt der Klasse File, mit dem wir die in loop() zusammengesetzte Zeile schreiben.
Danach schließen wir die Datei wieder.
Damit wird sichergestellt, dass die Datei nicht beschädigt wird, wenn die Karte zwischen zwei Schreibvorgängen entfernt wird oder der Strom ausfällt.
Zum Debuggen geben wir den Wert von line auch noch auf der seriellen Schnittstelle aus.

War das Öffnen nicht erfolgreich (etwa, weil die SD-Karte fehlt), dann ist file leer und es wird eine Fehlermeldung auf die serielle Schnittstelle ausgegeben.

Die Echtzeituhr

Beschreibung und Einbauen

Anders als ein PC verfügt ein Arduino nicht über eine eingebaute Uhr, weil diese für viele Anwendungen nicht benötigt wird.
Für den Datenlogger verwenden wir daher das Grove-RTC-Modul, welches einen DS1307 Taktgeber-Chip enthält.
Die Echtzeituhr benötigt eine zusätzliche Spannungsquelle in Form einer 3V Knopfzelle (CR1225), damit die eingestellte Zeit auch dann erhalten bleibt, wenn der Arduino selbst keinen Strom hat.
Umgekehrt hat das zur Folge, dass die Echtzeituhr ohne Batterie nicht korrekt funktioniert – man kann also nicht darauf verzichten, selbst wenn der Arduino fest an einer Stromquelle angeschlossen bleibt.
Die Kommunikation läuft über das I²C-Bussystem, es kann ein beliebiger I²C-Anschluss verwendet werden.
Für die Echtzeituhr muss wie für das Display eine Bibliothek installiert werden:

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

Um die Zeit einzustellen, verwenden wir ein eigenes Sketch anstelle der setup()-Methode im endgültigen Programm.
Sonst würde die Zeit bei jedem Arduino-Start wieder zurückgesetzt werden:
#include <Wire.h>
#include <DS1307.h>

DS1307 clock; // ein Uhr-Objekt anlegen

void 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();
}

In setup() öffnen wir erst die Verbindung zum seriellen Port, um die Uhrzeit zur Kontrolle an den PC zu schicken.
Mit clock.begin() wird dann die Verbindung zur Uhr geöffnet, Datum, Uhrzeit und Wochentag vorbereitet und schließlich mit clock.setTime() an die Echtzeituhr geschickt (die Werte vorher mit der aktuellen Zeit ersetzen ;-)).
In loop() wird erst die Zeit ausgegeben und dann eine Sekunde gewartet.
Im Arduino Studio erscheint die Ausgabe unter “Werkzeuge” → “Serieller Monitor”.
Wichtig:
Das Senden des Programms an den Arduino dauert ein paar Sekunden, es ist also schwierig, die Zeit exakt zu stellen.
Für diese Anwendung ist das kein Problem – wenn alle paar Minuten ein Messwert aufgezeichnet wird um den Verlauf der Messwerte über den Tag aufzuzeichnen, dann macht eine Abweichung von einigen Sekunden keinen Unterschied.

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 Millisekunden
unsigned long WRITE_INTERVAL = 60000; // 1 Minuten

unsigned 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;
 }
}

Neu bei diesem Programm ist, dass es zwei Prozesse mit unterschiedlicher Taktrate gibt.
Das Display sollte für eine aktuelle Anzeige und fließende Farbübergänge mehrmals in der Sekunde aktualisiert werden.
Für das Schreiben der Messwerte auf die Karte reicht aber ein Minutentakt. Einfache Pausen mit delay() sind daher nicht mehr möglich.

Die Lösung: Mit der Funktion millis() lassen sich die vergangenen Millisekunden seit Start des Arduino abfragen.
In lastDisplayUpdate und lastWrite werden dann jeweils der letzte Zeitpunkt der Display-Aktualisierung bzw. Schreibens auf die SD-Karte abgespeichert.
Bei jedem Durchlauf von loop() wird dann verglichen, ob die Differenz dieser Werte zu millis() größer ist als die Werte von DISPLAY_UPDATE_INTERVAL bzw. WRITE_INTERVAL und nur dann die jeweiligen Aktionen ausgeführt.
Die Variablen lastWrite und lastDisplayUpdate werden mit der Länge des jeweiligen Intervalls initialisiert damit die beiden Aktionen beim Programmstart unmittelbar erfolgen.

In loop() werden schließlich zunächst die Werte vom Sensor geholt und geprüft.
Wenn es beim Abholen der Werte Probleme gab, wird ein Fehler ausgegeben und die Ausführung von loop() an dieser Stelle beendet und wieder von vorne gestartet (d.h. wieder Werte vom Sensor geholt).

Anschließend wird geprüft, ob es wieder Zeit ist, das Display zu aktualisieren.
Dies ist der Fall, wenn die Differenz vom aktuellen Zeitpunkt und lastDisplayUpdate größer ist als DISPLAY_UPDATE_INTERVAL.
Dann wird wieder die Farbe bestimmt und die Daten an das Display gesendet.
Der Lesbarkeit halber gibt es dafür jetzt die Methode updateDisplay().
Anschließend wird lastDisplayUpdate auf den aktuellen Zeitpunkt gesetzt.

Das Gleiche geschieht für das Schreiben der Daten auf die SD-Karte.
Wenn der Zeitpunkt des letzten Schreibvorgangs länger her ist als WRITE_INTERVAL, dann wird die aktuelle Uhrzeit von der Echtzeituhr ermittelt, die Daten auf die SD-Karte geschrieben und lastWrite auf den aktuellen Zeitpunkt gesetzt.

Die Uhrzeit wird in der Methode getTime() ermittelt, die die Uhrzeit von der Echtzeituhr abfragt und einen String mit Datum und Uhrzeit erstellt.
Der Operator += hängt den Wert des rechten Strings an den linken an.

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ß!




Quelle.
https://www.reichelt.de/magazin/how-to/temperatur-log-arduino-uno-fortsetzung/


********************************************************I*
Az-Delivery Data Logger
Moritz SprangerAug 06, 2018

Hallo Community,
um den hohen Temperaturen der letzten Tage etwas Gutes abzugewinnen habe ich die Lichtschachtabdeckung meines Kellers entfernt und das Fenster geöffnet, in der Hoffnung etwas Feuchtigkeit nach draußen zu bringen.
Aufgrund der großen Nachfrage für unser praktisches DataLogger Shield möchten wir den heutigen Blogbeitrag nutzen um zu zeigen, wie einfach sich damit Messdaten aufzeichnen lassen.
Im Prinzip enthält das Shield alles was man zum aufzeichnen von Daten benötigt um diese später grafisch auszuwerten.
Excel bietet hierbei nahezu unbegrenzte Möglichkeiten.
Wir haben sogar die Möglichkeit eine kleine Schaltung direkt auf das Shield aufzulöten.
Es spielt dabei keine große Rolle welchen Sensor wir benutzen. Für meinen Keller habe ich mich für einen DHT22 entschieden.

Wir verwenden für das Shield die RTC-Libary von Stephan Fink und die Standart-SD-Libary welche in der Arduino IDE enthalten ist.
Als Beispiel schließen wir unseren DHT22 an und loggen die Daten zusammen mit der eingebauten RTC.
Die SD-Karte formatieren wir mit fat32 Dateisystem.
Sollten Sie Probleme beim Einstellen der RTC haben empfehlen wir Ihnen unser E-Book zu DS3231.
Den DHT, als Modul, verbinden wir an Pin 2 des Shields.

Hier der Beispielcode:
#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 Shield
const int zeit = 5000; //Messintervall

long 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(); 
}



Quelle:
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/data-logger-shield





********************************************************I*
Temperaturmessung

Im heutigen Artikel basieren unsere Messungen auf einen Arduino Uno Bord.
Uns stellt sich die Frage, wie man Temperatursensoren an diesen kleinen Alleskönner anschließen kann.
Doch weiter interessiert uns auch die Frage, wie genau die Sensoren die Temperatur messen.
Für den heutigen Test haben wir die Temperatursensoren LM35, DHT11, DHT22 und den DS18B20 einem genauen Test unterzogen.
Auch wenn sich die je zwei Sensoren von außen stark ähneln, unterscheiden sie sich zum Teil grundlegend in ihrer technischen Beschaffenheit und der Art und Weise, wie die Ermittlung der Temperatur zustande kommt.
Ferner weichen die Sensoren auch im Preis zum Teil deutlich voneinander ab.
Daher liegen die folgenden Fragen förmlich auf der Zunge:
Welcher Sensor liefert die besten Ergebnisse?
Und:
Welches ist der günstigste Temperatursensor, der noch akzeptable Ergebnisse liefert?

DHT22 / AM2302-Luftfeuchte und Temperatursensor


Im Praxistest: Der LM35, DHT11, DHT22 und DS18B20. Alle Temperatursensoren mussten zeigen, wie genau sie die Temperatur ermitteln.

 

Arduino: Das LCD Display

Die Ausgabe von Daten erfolgt bei dem kleinen Bastelcomputer in der Regel über die serielle Schnittstelle.
Für einen Test ist diese Ausgabe durchaus ausreichend.
Wenn man den Arduino jedoch unabhängig von einem Rechner betreiben möchte, muss man die Daten anderweitig visualisieren.
Hier bietet sich ein LCD-Display an. In unserem Test benutzen wir ein Hitachi-kompatibles Display, welches recht einfach über den Arduino anzusprechen ist.
Auch sind die Kosten von rund 2,50 Euro für ein solches Display, direkt aus China geliefert, überschaubar.
Leider sind für den Aufbau mehr Kabel notwendig, als Anfängern lieb sein dürfte.
Doch mit ein wenig Begeisterung sollte diese Hürde schnell zu meistern sein.

Schaltplan Arduino mit LCD Display



 

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

 

Benötigte Elemente

 

Sketch Arduino mit LCD Display

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//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 Zeilen
lcd.begin(16, 2);
 
// Wir schreiben in die erste Zeile:
lcd.print("test-");
 
// Wir setzen den Cursor in die zweite Zeile
lcd.setCursor(0, 1);
lcd.print("wetterstation.de");
}
 
void loop() {
 
// Wir schalten das Display aus
lcd.noDisplay();
 
// Und warten ...
delay(500);
 
// Und schalten das Display wieder an ...
lcd.display();
 
// Und warten wieder
delay(500);
}

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
// Definition von LCD: 16 Zeichen, 2 Zeilen
lcd.begin(16, 2);

// Wir schreiben in die erste Zeile:
lcd.print("test-");

// Wir setzen den Cursor in die zweite Zeile
lcd.setCursor(0, 1);
lcd.print("wetterstation.de");
}

void loop() {

// Wir schalten das Display aus
lcd.noDisplay();

// Und warten …
delay(500);

// Und schalten das Display wieder an …
lcd.display();

// Und warten wieder
delay(500);
}

 

Grundsätzliches

Da einige Sensoren eine gewisse „Aufwärmzeit“ benötigen, starten wir im Sketch (Programmcode) bei allen Sensoren zuerst mit einem „delay(2000);“, also einer Wartezeit von zwei Sekunden. Vorher sind keine vernünftigen Messwerte zu erwarten.
Auch sind die hier vorgestellten Sensoren nicht dazu geeignet, in Sekundenbruchteilen Messungen zu wiederholen.
Eine Wartezeit von ein bis zwei Sekunden zwischen zwei Messungen sollte in der Praxis zu guten Messwerten führen.

 

Technische Daten (Herstellerangaben)

Typ LM35 DHT11 DHT22 DS18B20
Temperaturbereich: -40 bis +110 °C 0 bis 50 °C, ±2 °C -40 bis +80 °C, ±0.5 -55 bis 125°C,
± 0,5°C bei -10° bis +85°C
Messbereich Feuchte: keine 20 – 90 RH 0 – 100 RH keine
Versorgungsspannung: -0,2 bis +35 VDC 3,3 bis 5,5 VDC 3,3 bis 5,5 VDC 3,3 bis 5 VDC
Größe (L x B x H): 5 (20) x 4 x 5mm 16 (24) x 13 x 6mm 20 (33) x 5 x 8mm 5 (20) x 4 x 5mm
Amazon-Preis:* 3,94 EUR 4,29 EUR 5,23 EUR 6,49 EUR

Bei Amazon kaufen Bei Amazon kaufen Bei Amazon kaufen Bei Amazon kaufen

 

Der LM35 am Arduino

Beim LM35 handelt es sich um einen analogen Temperatursensor. Im Gegensatz zu digitalen Sensoren liefert der Sensor temperaturabhängig eine Ausgangsspannung, die über den analogen Eingang des Arduino gemessen wird.
Eine Formel rechnet die Spannung in eine Temperatur um. Das Problem bei analogen Temperatursensoren ist, dass sie eine Spannung abhängig von der Eingangsspannung liefern. Wenn die Versorgungsspannung des Board schwankt, zum Beispiel beim Betrieb mittels einer Batterie, schwankt somit auch die Temperaturgenauigkeit.
Daher kann nur bei einer gleichbleibender Versorgungsspannung – beispielsweise durch ein Netzteil – eine konstante Temperaturgenauigkeit erreicht werden.
Dies haben wir in unseren Messungen beachtet, wenn auch in den Videos ein Batteriepack zum Einsatz kam.

 

Temperaturgenauigkeit des LM35 erhöhen:

Prinzipiell sollte man sich nie auf nur einen Messwert verlassen, wenn man beabsichtigt, temperaturabhängige Aktionen auszuführen.
Hier bieten sich mehrere Messungen hintereinander an, aus denen dann ein Durchschnitt gebildet wird.
Es macht auch Sinn, extreme „Ausreißer“ in einem Messzyklus zu eliminieren.
Kalibrieren kann man den LM35, wenn man mittels eines Referenzmessgerätes die Temperatur-Differenz ermittelt und diese Ungenauigkeit im Programmcode berücksichtigt.

 

Schaltplan Arduino mit LM35



 

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

 

Benötigte Elemente

 

Sketch Arduino mit LM35

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!
#include < LiquidCrystal.h >
 
//LCD Display
LiquidCrystal 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);
 
//Warte
delay(2000);
}

//LCD Display
LiquidCrystal 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);

//Warte
delay(2000);
}

 

Messwerte des LM35

  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
LM35 26,37 °C 21,48 °C 20,02 °C 20,00 °C
Referenz 19,7 °C 19,9 °C 20,3 °C 19,5 °C
Abweichung 6,67 °C 1,58 °C -0,28 °C 0,5 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
LM35 6,84 °C 6,84 °C 6,84 °C 4,88 °C
Referenz 6,2 °C 6,3 °C 6,4 °C 2,2 °C
Abweichung 0,64 °C 0,54 °C 0,44 °C 2,68 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
LM35 28,81 °C 31,74 °C 34,18 °C 36,13 °C
Referenz 28,4 °C 28,2 °C 28,5 °C 28,5 °C
Abweichung 0,41 °C 3,54 °C 5,68 °C 7,63 °C

 

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

 

Sketch Arduino mit DHT11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!
#include < LiquidCrystal.h >
 
//LCD Display
LiquidCrystal 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 DHT11
DHT dht(DHTPIN, DHTTYPE);
 
void setup() {
lcd.begin(16, 2);
}
 
void loop() {
 
//Warte
delay(2000);
 
//Lese die Luftfeuchtigkeit
float h = dht.readHumidity();
 
// Lese die Temperatur in Celsius
float 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);
}

//LCD Display
LiquidCrystal 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 DHT11
DHT dht(DHTPIN, DHTTYPE);

void setup() {
lcd.begin(16, 2);
}

void loop() {

//Warte
delay(2000);

//Lese die Luftfeuchtigkeit
float h = dht.readHumidity();

// Lese die Temperatur in Celsius
float 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

  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DHT11 23,0 °C 21,0 °C 20,0 °C 20,0 °C
Referenz 17,9 °C 17,8 °C 17,6 °C 17,3 °C
Abweichung 5,1 °C 3,2 °C 2,4 °C 2,7 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DHT11 8,0 °C 9,0 °C 8,0 °C 9,0 °C
Referenz 6,1 °C 6,0 °C 5,3 °C 5,7 °C
Abweichung 1,9 °C 3,0 °C 2,7 °C 3,3 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DHT11 29,0 °C 29,0 °C 29,0 °C 30,0 °C
Referenz 29,5 °C 28,3 °C 29,2 °C 28,8 °C
Abweichung -0,5 °C 0,7 °C -0,2 °C 1,2 °C

 

Der DHT22 am Arduino

Der DHT22 hat eine gewisse Ähnlichkeit mit dem DHT11. Doch schon beim Blick auf die technischen Daten zeigt sich, dass hier deutliche Unterschiede bestehen.
Der DHT 11 hat laut Herstellerangaben einen Temperaturbereich von 0 bis 50 Grad Celsius bei einer Abweichung von +/- 2 Grad.
Der DHT22 misst dagegen zwischen -40 und +80 Grad Celsius bei einer Abweichung von +/- 0,5 Grad Celsius.
Dieser Vorteil schlägt sich auch im Preis nieder. Je nach Bezugsquelle ist der DHT22 rund zwei Euro teurer.
Auch der Messbereich der Luftfeuchtigkeit, die in diesem Test nicht weiter betrachtet wird, ist gegenüber dem DHT11 deutlich höher und genauer.

 

Video: Schritt für Schritt Anleitung: Arduino DHT22

 

Benötigte Elemente

 

Schaltplan Arduino mit DHT22



 

Sketch Arduino mit DHT22

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!
#include < LiquidCrystal.h >
//LCD Display
LiquidCrystal 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() {
 
//Warte
delay(2000);
 
// Lese die Luftfeuchtigkeit
float h = dht.readHumidity();
 
// Lese die Temperatur in Celsius
float 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);
}

//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() {

//Warte
delay(2000);

// Lese die Luftfeuchtigkeit
float h = dht.readHumidity();

// Lese die Temperatur in Celsius
float 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

  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DHT22 21,3 °C 19,8 °C 18,1 °C 17,6 °C
Referenz 17,2 °C 17,2 °C 17,1 °C 17,6 °C
Abweichung 4,1 °C 2,6 °C 1,0 °C 0,0 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DHT22 7,8 °C 7,6 °C 7,8 °C 7,9 °C
Referenz 7,2 °C 7,6 °C 7,7 °C 7,9 °C
Abweichung 0,6 °C 0,0 °C 0,1 °C 0,0 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DHT22 28,6 °C 28,3 °C 29,1 °C 29,4 °C
Referenz 28,5 °C 28,6 °C 29,0 °C 29,2 °C
Abweichung 0,1 °C -0,3 °C 0,1 °C 0,2 °C

 

Der DS18B20 am Arduino

Auch wenn die Äußerlichkeiten zwischen dem LM35 und dem DS18B20 nicht von der Hand zu weisen sind, unterscheiden sich die Sensoren grundlegend.
Bei einem Blick auf das Schaltbild fällt auf, dass der DS18B20 nicht am analogen Pin, wie der LM35, sondern an einem digitalen Pin angeschlossen wird.
Analoge Temperatursensoren liefern temperatur- und eingangsspannungsabhängig eine Zielspannung zurück.
Diese Spannung wird gemäß Spezifikation in einen Temperaturwert umgerechnet.
Durch schwankende Versorgungsspannungen des Arduino treten bei analogen Sensoren dadurch Ungenauigkeiten auf.
Diese Ungenuigkeit tritt bei einem digitalen Sensor nicht auf.
Auch die Kabellänge zum Sensors ist bei einem digitalen Temperatursensor nicht mehr so stark begrenzt, wie bei einem analogen Sensor.
Somit ist dieser Sensor der optimale Kandidat, wenn ständig mehrere unterschiedliche Messungen vorgenommen werden sollen.
Des Weiteren ist dieser Sensor recht günstig und sogar in einer wasserdichten Version zu haben.
Diese Vorteile sprechen für die Beliebtheit, die dem DS18B20 widerfährt.

In unserem Testaufbau installieren wir den Sensor im sogenannten „normal mode“.
Hier werden drei Kabel zum Anschluss benötigt. Im sogenannten „parasitären Modus“ („parasite mode“) reichen zwei Kabel für den Anschluss.
Der Sensor wird dann über die Datenleitung im Strom versorgt.
Wenn mehr als ein Sensor an ein Board angeschlossen werden und auch die Länge der Versorgungsleitung länger als in unserem Test sein soll, ist der „normal mode“ von Vorteil.

Das zugrunde liegende 1-Wire-Protokoll ist relativ kompliziert. Dankenswerter Weise gibt es die entsprechende Bibliothek „MAX31850 DallasTemp“, die über den Library-Manager der Arduino-Programmierumgebung installiert werden kann.

 

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

 

Benötigte Elemente

 

Schaltplan Arduino mit DS18B20



 

Sketch Arduino mit DS18B20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//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 vorbereiten
lcd.begin(16, 2);
 
sensoren.begin();
Serial.begin(Baud_Rate);
 
//Hier schauen wir, wieviel Sensoren angeschlossen sind
Anzahl_Sensoren = sensoren.getDeviceCount();
}
 
void loop() {
//Warte
delay(2000);
 
sensoren.requestTemperatures();
 
//Hier lesen wir den ersten Sensor (0) aus
float 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);
}

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 vorbereiten
lcd.begin(16, 2);

sensoren.begin();
Serial.begin(Baud_Rate);

//Hier schauen wir, wieviel Sensoren angeschlossen sind
Anzahl_Sensoren = sensoren.getDeviceCount();
}

void loop() {
//Warte
delay(2000);

sensoren.requestTemperatures();

//Hier lesen wir den ersten Sensor (0) aus
float 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

  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DS18B20 24,81 °C 22,19 °C 21,25 °C 21,1 °C
Referenz 20,8 °C 20,8 °C 21,1 °C 21,12 °C
Abweichung 4,01 °C 1,39 °C 0,15 °C -0,02 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DS18B20 6,44 °C 6,5 °C 6,56 °C 6,56 °C
Referenz 5,0 °C 5,1 °C 5,2 °C 5,6 °C
Abweichung 1,44 °C 1,4 °C 1,36 °C 0,96 °C
  Start nach 1 Minute nach 5 Minuten nach 10 Minuten
DS18B20 33,13 °C 30,69 °C 28,69 °C 30,25 °C
Referenz 30,6 °C 31,8 °C 34,9 °C 33,3 °C
Abweichung 2,53 °C -1,11 °C -6,21 °C -3,05 °C

 

Fazit

Leider können wir keinen eindeutigen Sieger küren.
Der LM35 mag für viele Anwendungen reichen, hat uns aber nicht überzeugt.
Gleiches gilt für den digitalen DHT11.
Hier würden wir in jedem Fall auf den DHT22 zurückgreifen, der zwar deutlich teurer, aber auch genauere Ergebnisse liefert.
Eine Sonderstellung nimmt der DS18B20 ein.
Im 10´er Pack, direkt aus China geliefert, ist dieser Sensor für rund fünf Euro zu haben.
Seine Messgenauigkeit reicht zwar nicht an die des DHT22, doch wenn auch auf die Messung der Feuchte verzichtet werden kann, sollte dieser Temperatursensor für die meisten Anwendungen genügen.



Quelle:

https://test-wetterstation.de/temperaturmessung-mit-dem-arduino







********************************************************I*

Arduino Lektion 27: Daten loggen mit dem Logging Shield

Das Data Logging Shield von „Deek-Robot“ wird mit einer RTC  (DS1307)geliefert und hat somit ein extra Fach für eine Knopfzelle (CR1220 – 3V).
Des Weiteren besitzt dieses Shield ein Mini SD Karten Schacht.

Deek-Robot – Data logging board



Quelle:
https://draeger-it.blog/arduino-lektion-27-datenloggen-mit-dem-logging-shield/



Arduino Lektion 44: BME280 Temperatur, Luftfeuchtigkeit und Luftdruck Sensor

Quelle:
https://draeger-it.blog/arduino-lektion-44-bme280-temperatur-luftfeuchtigkeit-und-luftdruck-sensor/





********************************************************I*

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.

Video: Live-Demonstration

Verwendete Bauteile

Aufbau

In der Schaltung ist zu beachten, dass der Lüfter eine separate (höhere) Stromversorgung bekommt, als der Rest der Steuerungslogik.
Durch einen Transitor wird der Stromfluss für den Lüfter geregelt.



Abb.: Aufbau der Schaltung

Sketches

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

#define PIN_FAN 10

void setup()
{
    pinMode(PIN_FAN, OUTPUT);
}

void loop()
{
    digitalWrite(PIN_FAN, HIGH);
    delay(5000);
    digitalWrite(PIN_FAN, LOW);
    delay(5000);
}

Der zweite Sketch ist die temperaturanhängige Steuerung.
Es wird in bestimmten Zeit-Intervallen die Wärme durch den Thermistor gemessen und bei einer bestimmten Schwelle der Lüfter ein- bzw. wieder ausgeschaltet.
In der seriellen Konsole kann dies zusätzlich überwacht werden.

#define PIN_FAN        10
#define PIN_THERMISTOR A0

#define TEMP_FAN_OFF 440
#define TEMP_FAN_ON  500
#define MEASURE_RESOLUTION 3000 // interval in milliseconds

unsigned 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();
    }
}



Abb.: Ausgabe in der seriellen Konsole

Quelle:

https://elektro.turanis.de/html/prj074/index.html







DIN A4  ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE









Comments