www-messdatenerfassung-sas:platinenschaltung

Zuletzt angesehen: • raspi_rtc_hw111 • unterrichtseinsatz • platinenschaltung-aussenbox • sensoren_einbinden • platinenschaltung
Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== WWW: Platinen mit TESTCODE======

  * [[platinenschaltung-Außenbox|WWW: Platinen mit TESTCODE für die Außenbox]]

^ Seite  ^ Inhalt  ^
| [[www-messdatenerfassung-sas:startseite|Startseite]]                                                 | Übersicht                                                                                                                                                  |   |
| [[www-messdatenerfassung-sas:klimastation|Hauptanleitung]]                                           | Gesamtüberblick, Begriffsklärung, Teil 1–3 (FRITZ!Box, Raspberry Pi/EmonCMS, Sensor-Boxen), Ein-/Ausschalten, Zugänge-Checkliste, SENSOR_ID-Übersicht  |   |
| [[www-messdatenerfassung-sas:sensoren_einbinden|Sensoren in EmonCMS einbinden]]                      | Wiederkehrender Ablauf für jede neue Sensor-Box: API-Key, Inputs, Feeds, Dashboard                                                                         |   |
| [[www-messdatenerfassung-sas:sensor_code|Programmcode der Sensor-Boxen]]                             | Vollständiger Arduino-Code: Testsensor, einfacher BME280-Sensor, Klimamessbox, Raummessbox                                                                 |   |
| [[www-messdatenerfassung-sas:raspi_rtc_hw111|Raspberry Pi um Echtzeituhr (RTC) erweitern – HW-111]]  | Nachrüstung eines DS1307-RTC-Moduls, Shutdown-Taster                                                                                                       |   |
| [[Platinenschaltung|Schaltung]] | **Platine** |
| [[3D-Gehäuse|Gehäuse]] | 3D-Druck oder LASER-Cutter |
| [[Unterrichtseinsatz|Schule]]  | Einsatz im Unterricht |
| [[Sonstiges|Sonstiges]]| dies und das....|




  * [[https://easyeda.com|Platinenerstellung - extern]]
    * Nach Erstellung benötigt die günstigste "Verschiffung" 2 Wochen (kostet aber unter 5 EURO)
    * Bei unseren Platinen kostete eine Platine 1,5 Euro

  * [[https://www.youtube.com/watch?v=WAt0aocWS6w&t=121s|Nach diesem Video hat es bei uns auf Anhieb funktioniert ;-)]]


  * [[lehrer:arduino:p52d1-raumklima-feinstaub-licht|nur intern für SAS-Lehrer: P52-D1-mini]]

  * [[info:3d-druck:sds-011-feinstaubsensor|Gehäuse - intern]]

===== Raumklima - Messbox =====

  * [[info:arduino:p42d1-raumklima|P-42  intern]]
  * [[lehrer:arduino:p42d1-raumklima|L-P42  intern]]

{{:info:arduino:esp8266-wemos-d1-mini-pinout-gpio-pin-2.png?300|}}


^ Sensor   ^ Pin am D1 mini                                              ^ GPIO   ^ Verwendung  ^ Status       ^
| DHT22    | D7                                                          | 13     |             | ✅ gut       |
| MH-Z19B  | Tx nach Rx D6 beim D1 OHNE Spannungsteiler!; Rx nach Tx D5  | 14 12  | UART        | ✅           |
| BMP180   | D1 (SCL) + D2 (SDA)                                         | 5 + 4  | I2C         | ✅ Standard  |
| LED      | D4                                                          | 2      |             | ✅           |
| LDR      | A0                                                          | A0     | analogRead  | ✅ Standard  |

==== D1-mini ====

  * Inzwischen wird der DHT22 mit BMP180 bei neueren Messboxen durch den BME280 ersetzt, was den Aufbau und den Code nochmalig vereinfacht.
  * Der MHZ19B wird inzwischen **ohne Spannungsteiler** betrieben - Der D1-mini ist 5V tolerant!
  * Bei einem ESP32 wäre es nicht ratsam, da dieser nicht 5V tolerant ist...

{{:www-messdatenerfassung-sas:d1-mini-raumklima-2026-01-08-dht22-bmp180.png?400 |Verkabelung der Klimamessbox, erstellt mit Fritzing}}

{{:www-messdatenerfassung-sas:uart-mhz-19b-rxd-d6-spannungsteiler-nicht-notwendig.png?400 |}}


==== Bestückung ====
=== Materialliste ===

  * auf Vollständigkeit prüfen

{{:www-messdatenerfassung-sas:0-raumklima-platine-loeten-2026-06-13-01.png?400 |}}

=== 1. Drahtbrücke ===

  * überstehende Reste entfernen



{{:www-messdatenerfassung-sas:1-raumklima-platine-loeten-2026-06-13-02.png?800 |}}
=== 2. Winkelstifte LED und BMP ===

  * ACHTUNG: auf die genaue Position achten

{{:www-messdatenerfassung-sas:2-raumklima-platine-loeten-2026-06-13-03.png?800 |}}
=== 3.  3er Stifte DHT22 ===

  * auf senkrechte Montage achten

{{:www-messdatenerfassung-sas:3-raumklima-platine-loeten-2026-06-13-04.png?800 |}}
=== 4. 8er Buchsen D1-mini ==

  * auf senkrechte Montage achten
  * Reste nach dem Löten entfernen

{{:www-messdatenerfassung-sas:4-raumklima-platine-loeten-2026-06-13-05.png?800 |}}
=== 5. 4er- und 5er-Buchse MHZ19B ===

  * auf senkrechte Montage achten
  * Reste nach dem Löten entfernen

{{:www-messdatenerfassung-sas:5-raumklima-platine-loeten-2026-06-13-06.png?800 |}}
=== 6. Widerstand 470kΩ ===

  * Reste nach dem Löten entfernen

{{:www-messdatenerfassung-sas:6-raumklima-platine-loeten-2026-06-13-07.png?800 |}}
=== 7.  2er-Buchse LDR ===

  * auf senkrechte Montage achten
  * Reste nach dem Löten entfernen


{{:www-messdatenerfassung-sas:7-raumklima-platine-loeten-2026-06-13-08.png?800 |}}
=== 8. Externe Sensoren ===

{{:www-messdatenerfassung-sas:8-raumklima-platine-loeten-2026-06-13-09.png?800 |}}
=== 9.  fertiges Modul ===


{{:info:platinen:raumklima-platine-loeten-2026-06-13-10.png?800|}}



====== Testcode - Raumklima ======

[[lehrer:arduino:p42d1-raumklima#testcode|Vollständiger TESTCODE]]

===== BMP180 =====

<code>
/********************************************************************************************
 *  BMP180 Test - Luftdruck und Temperatur
 *  
 *  Verdrahtung (I2C):
 *  - SCL: D1 (GPIO5)
 *  - SDA: D2 (GPIO4)
 *  - VCC: 3.3V
 *  - GND: GND
 ********************************************************************************************/

#include <Wire.h>
#include <SFE_BMP180.h>

#define ALTITUDE 42.0  // Höhe über Meeresspiegel in Metern (anpassen!)

SFE_BMP180 pressure;

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("\n=== BMP180 Test ===");
  
  // I2C initialisieren (Standard-Pins D1=SCL, D2=SDA)
  Wire.begin();
  
  if (pressure.begin()) {
    Serial.println("BMP180 erfolgreich initialisiert!");
  } else {
    Serial.println("FEHLER: BMP180 nicht gefunden!");
    Serial.println("Prüfe:");
    Serial.println("  - I2C-Verbindung (D1=SCL, D2=SDA)");
    Serial.println("  - 3.3V Versorgung");
    Serial.println("  - GND-Verbindung");
    while(1) delay(10);
  }
  
  Serial.println("\nStarte Messungen (alle 2 Sekunden)...\n");
}

void loop() {
  char status;
  double T, P, p0;
  
  // 1. Temperatur messen
  status = pressure.startTemperature();
  if (status != 0) {
    delay(status);  // Warte auf Messung
    
    status = pressure.getTemperature(T);
    if (status != 0) {
      Serial.print("Temperatur: ");
      Serial.print(T, 2);
      Serial.println(" °C");
      
      // 2. Luftdruck messen (benötigt Temperatur)
      status = pressure.startPressure(3);  // Oversampling Level 3 (höchste Genauigkeit)
      if (status != 0) {
        delay(status);
        
        status = pressure.getPressure(P, T);
        if (status != 0) {
          Serial.print("Stationsdruck: ");
          Serial.print(P, 2);
          Serial.println(" hPa");
          
          // 3. Auf Meereshöhe korrigierter Druck
          p0 = pressure.sealevel(P, ALTITUDE);
          Serial.print("Meereshöhe (p0): ");
          Serial.print(p0, 2);
          Serial.println(" hPa");
        }
      }
    }
  } else {
    Serial.println("FEHLER: Messung fehlgeschlagen!");
  }
  
  Serial.println("---");
  delay(2000);
}
</code>

<code>
18:33:53.491 -> ---
18:33:55.487 -> Temperatur: 24.95 °C
18:33:55.518 -> Stationsdruck: 1003.11 hPa
18:33:55.518 -> Meereshöhe (p0): 1008.12 hPa
18:33:55.518 -> ---
</code>
===== DHT22 =====
<code>
/********************************************************************************************
 *  DHT22 Test - Luftfeuchtigkeit und Temperatur
 *  
 *  Verdrahtung:
 *  - DATA: D7 (GPIO13)
 *  - VCC: 3.3V oder 5V
 *  - GND: GND
 *  - Pull-up Widerstand (4.7k-10k) zwischen DATA und VCC (oft schon auf Modul vorhanden)
 ********************************************************************************************/

#include "DHT.h"

#define DHTPIN 13      // D7
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("\n=== DHT22 Test ===");
  
  dht.begin();
  Serial.println("DHT22 initialisiert");
  Serial.println("Warte 2 Sekunden auf ersten Messwert...\n");
  
  delay(2000);  // DHT22 braucht kurze Aufwärmzeit
}

void loop() {
  // Luftfeuchtigkeit und Temperatur auslesen
  float humidity = dht.readHumidity();
  float temperature = dht.readTemperature();
  
  // Prüfen ob Messung erfolgreich
  if (isnan(humidity) || isnan(temperature)) {
    Serial.println("FEHLER: DHT22-Messung fehlgeschlagen!");
    Serial.println("Prüfe:");
    Serial.println("  - Datenpin (D7)");
    Serial.println("  - Versorgungsspannung (3.3V oder 5V)");
    Serial.println("  - Pull-up Widerstand vorhanden?");
  } else {
    Serial.print("Luftfeuchtigkeit: ");
    Serial.print(humidity, 1);
    Serial.println(" %");
    
    Serial.print("Temperatur: ");
    Serial.print(temperature, 1);
    Serial.println(" °C");
    
    // Taupunkt berechnen (optional)
    float dewPoint = temperature - ((100 - humidity) / 5.0);
    Serial.print("Taupunkt (ca.): ");
    Serial.print(dewPoint, 1);
    Serial.println(" °C");
  }
  
  Serial.println("---");
  delay(2500);  // DHT22 sollte max. alle 2 Sekunden ausgelesen werden
}
</code>
<code>
18:41:12.618 -> ---
18:41:15.127 -> Luftfeuchtigkeit: 43.9 %
18:41:15.127 -> Temperatur: 22.3 °C
18:41:15.127 -> Taupunkt (ca.): 11.1 °C
18:41:15.127 -> ---
</code>

===== MHZ19B =====
<code>
/********************************************************************************************
 *  MH-Z19B Test - CO₂-Sensor
 *  
 *  Verdrahtung (UART):
 *  - RX (Sensor) → TX (D5 / GPIO14) des D1 Mini
 *  - TX (Sensor) → RX (D6 / GPIO12) des D1 Mini
 *  - VCC: 5V (wichtig! Sensor braucht 5V)
 *  - GND: GND
 *  
 *  Hinweis: Sensor braucht ~3 Minuten Aufwärmzeit für stabile Werte!
 ********************************************************************************************/

#include <SoftwareSerial.h>

// Software Serial: RX=D6 (GPIO12), TX=D5 (GPIO14)
SoftwareSerial mhzSerial(12, 14);

// Kommando zum Auslesen der CO₂-Konzentration
byte cmdReadCO2[] = {0xFF, 0x01, 0x86, 0, 0, 0, 0, 0, 0x79};

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("\n=== MH-Z19B CO₂-Sensor Test ===");
  
  mhzSerial.begin(9600);
  Serial.println("UART (9600 baud) initialisiert");
  Serial.println("\nHinweis: Sensor braucht ~3 Min. Aufwärmzeit!");
  Serial.println("Starte Messungen alle 5 Sekunden...\n");
  
  delay(2000);
}

void loop() {
  int ppm = -1;
  int temp = -999;
  
  if (readMHZ19B(ppm, temp)) {
    Serial.print("CO₂: ");
    Serial.print(ppm);
    Serial.print(" ppm");
    
    // Bewertung
    if (ppm < 700) {
      Serial.print(" [Sehr gut - Außenluftniveau]");
    } else if (ppm < 1000) {
      Serial.print(" [Gut - Innenraumluft]");
    } else if (ppm < 1500) {
      Serial.print(" [Mäßig - Lüften empfohlen]");
    } else if (ppm < 2000) {
      Serial.print(" [Schlecht - Dringend lüften!]");
    } else {
      Serial.print(" [Sehr schlecht - SOFORT lüften!]");
    }
    Serial.println();
    
    Serial.print("Sensor-Temperatur: ");
    Serial.print(temp);
    Serial.println(" °C");
    
  } else {
    Serial.println("FEHLER: Keine gültigen Daten vom Sensor!");
    Serial.println("Prüfe:");
    Serial.println("  - RX/TX vertauscht? (RX Sensor → TX D1, TX Sensor → RX D1)");
    Serial.println("  - 5V Versorgung vorhanden?");
    Serial.println("  - Sensor aufgewärmt? (3 Min. warten)");
  }
  
  Serial.println("---");
  delay(5000);  // Alle 5 Sekunden (Sensor kann häufiger, aber nicht nötig)
}

// MH-Z19B auslesen mit Checksummen-Prüfung
bool readMHZ19B(int &ppm, int &tempC) {
  // Puffer leeren (alte Daten verwerfen)
  while (mhzSerial.available()) {
    mhzSerial.read();
  }
  
  // Kommando senden
  mhzSerial.write(cmdReadCO2, 9);
  
  // Antwort lesen (9 Bytes, max. 200ms warten)
  byte response[9];
  int bytesRead = 0;
  unsigned long startTime = millis();
  
  while (bytesRead < 9 && millis() - startTime < 200) {
    if (mhzSerial.available()) {
      response[bytesRead++] = mhzSerial.read();
    }
    delay(1);
  }
  
  // Prüfen ob vollständiges Paket empfangen
  if (bytesRead != 9) {
    Serial.print("Nur ");
    Serial.print(bytesRead);
    Serial.println(" von 9 Bytes empfangen");
    return false;
  }
  
  // Header prüfen (sollte 0xFF 0x86 sein)
  if (response[0] != 0xFF || response[1] != 0x86) {
    Serial.print("Falscher Header: 0x");
    Serial.print(response[0], HEX);
    Serial.print(" 0x");
    Serial.println(response[1], HEX);
    return false;
  }
  
  // Checksumme berechnen und prüfen
  byte checksum = 0;
  for (int i = 1; i < 8; i++) {
    checksum += response[i];
  }
  checksum = 0xFF - checksum + 1;
  
  if (checksum != response[8]) {
    Serial.print("Checksumme falsch! Erwartet: 0x");
    Serial.print(checksum, HEX);
    Serial.print(" Erhalten: 0x");
    Serial.println(response[8], HEX);
    return false;
  }
  
  // Werte extrahieren
  ppm = response[2] * 256 + response[3];
  tempC = response[4] - 40;  // Temperatur ist offset um 40°C
  
  // Plausibilitätsprüfung
  if (ppm < 0 || ppm > 5000) {
    Serial.print("Unplausibel: ppm=");
    Serial.println(ppm);
    return false;
  }
  
  return true;
}
</code>
<code>
18:44:51.629 -> ---
18:44:56.637 -> CO₂: 1349 ppm [Mäßig - Lüften empfohlen]
18:44:56.637 -> Sensor-Temperatur: 18 °C
18:44:56.637 -> ---
</code>

==== Kalibrierung ====

Falls der MHZ-19B falsche Werte anzeigt hilft vielleicht eine Kalibrierung an der frischen Luft ;-)

  ⚡ Start → ABC wird sofort ausgeschaltet
  ⏱️ 20 Minuten → Sensor stabilisiert sich in Frischluft (zeigt Countdown)
  🎯 Kalibrierung → Zero Point Calibration auf Frischluft
  📊 Messbetrieb → Kontinuierliche Messung alle 10 Sekunden

Vorgehensweise:

  * Code auf den D1 mini hochladen
  * Sofort mit Powerbank vor die Tür legen (wichtig: nicht erst drinnen testen!)
  * 20 Minuten warten (Sie sehen den Countdown am seriellen Monitor)
  * Nach Kalibrierung können Sie das Gerät wieder reinholen
  * Fertig - der Sensor zeigt jetzt korrekte Werte!

<code>
/********************************************************************************************
 *  MH-Z19B CO2-Sensor KALIBRIERUNGS-PROGRAMM
 *  für D1 mini (ESP8266)
 *  
 *  ABLAUF:
 *  =======
 *  1. Start: ABC (Automatic Baseline Correction) wird ausgeschaltet
 *  2. Warten: 20 Minuten Stabilisierungszeit in Frischluft
 *  3. Kalibrierung: Zero Point Calibration auf Frischluft (~420 ppm)
 *  4. Messbetrieb: Kontinuierliche Messung alle 10 Sekunden
 *  
 *  VERWENDUNG:
 *  ===========
 *  - Sensor mit Powerbank versorgen
 *  - SOFORT nach dem Start vor die Tür legen (Frischluft!)
 *  - 20 Minuten warten
 *  - Nach Kalibrierung kann Sensor wieder ins Haus
 *  
 *  VERDRAHTUNG MH-Z19B:
 *  ====================
 *  MH-Z19B  →  D1 mini
 *  Vin      →  5V (oder VIN bei Powerbank)
 *  GND      →  GND
 *  TX       →  D6 (GPIO12) = RX vom D1 mini
 *  RX       →  D5 (GPIO14) = TX vom D1 mini
 *  
 *  Erstellt: 2025-01-08
 ********************************************************************************************/

#include <SoftwareSerial.h>

/********************************************************************************************
 *  KONFIGURATION
 ********************************************************************************************/

// Serielle Schnittstelle für MH-Z19B (Software Serial)
#define MHZ_RX_PIN D6    // D1 mini D6 → MH-Z19B TX
#define MHZ_TX_PIN D5    // D1 mini D5 → MH-Z19B RX

// Zeitsteuerung
const unsigned long WARTEZEIT_MS = 20UL * 60UL * 1000UL;  // 20 Minuten in Millisekunden
const unsigned long MESS_INTERVALL = 10000;                // 10 Sekunden Messintervall

/********************************************************************************************
 *  GLOBALE VARIABLEN
 ********************************************************************************************/

SoftwareSerial mhzSerial(MHZ_RX_PIN, MHZ_TX_PIN);

// Status-Flags
bool abcDeaktiviert = false;
bool kalibriert = false;
unsigned long startzeit = 0;

/********************************************************************************************
 *  MH-Z19B BEFEHLE
 ********************************************************************************************/

// Befehl: CO2-Wert lesen
byte cmdReadCO2[9] = {0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79};

// Befehl: ABC ausschalten
byte cmdABCoff[9] = {0xFF, 0x01, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86};

// Befehl: Zero Point Calibration (Frischluft-Kalibrierung)
byte cmdCalibrate[9] = {0xFF, 0x01, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78};

/********************************************************************************************
 *  SETUP
 ********************************************************************************************/
void setup() {
  // Serielle Schnittstelle zum PC starten
  Serial.begin(115200);
  delay(200);
  
  Serial.println();
  Serial.println("============================================================");
  Serial.println("   MH-Z19B KALIBRIERUNGS-PROGRAMM");
  Serial.println("============================================================");
  Serial.println();
  Serial.println("⚠️  WICHTIG: Sensor JETZT sofort in Frischluft bringen!");
  Serial.println("    (Fenster öffnen oder vor die Tür legen)");
  Serial.println();
  
  // Serielle Schnittstelle zum MH-Z19B starten (9600 Baud)
  mhzSerial.begin(9600);
  delay(500);
  
  // SCHRITT 1: ABC ausschalten
  Serial.println("SCHRITT 1: ABC (Automatic Baseline Correction) ausschalten...");
  mhzSerial.write(cmdABCoff, 9);
  delay(1000);
  abcDeaktiviert = true;
  Serial.println("✓ ABC deaktiviert");
  Serial.println();
  
  // Startzeit merken
  startzeit = millis();
  
  // Berechne Kalibrierungszeitpunkt
  unsigned long minuten = WARTEZEIT_MS / 60000;
  Serial.println("============================================================");
  Serial.println("SCHRITT 2: Wartezeit für Stabilisierung");
  Serial.println("============================================================");
  Serial.printf("Kalibrierung erfolgt in %lu Minuten\n", minuten);
  Serial.println();
  Serial.println("Der Sensor stabilisiert sich jetzt in der Frischluft.");
  Serial.println("Sie können den Fortschritt am seriellen Monitor beobachten.");
  Serial.println();
  Serial.println("------------------------------------------------------------");
  Serial.println("  MESSWERTE WÄHREND STABILISIERUNG:");
  Serial.println("------------------------------------------------------------");
  Serial.println();
}

/********************************************************************************************
 *  LOOP
 ********************************************************************************************/
void loop() {
  unsigned long jetzt = millis();
  unsigned long vergangen = jetzt - startzeit;
  
  // CO2-Wert auslesen
  int co2 = leseCO2();
  
  // ========== VOR DER KALIBRIERUNG ==========
  if (!kalibriert && vergangen < WARTEZEIT_MS) {
    // Zeit bis zur Kalibrierung berechnen
    unsigned long verbleibend = WARTEZEIT_MS - vergangen;
    unsigned long minutenVerbleibend = verbleibend / 60000;
    unsigned long sekundenVerbleibend = (verbleibend % 60000) / 1000;
    
    // Fortschritt anzeigen
    Serial.print("⏱️  ");
    Serial.printf("%02lu:%02lu", minutenVerbleibend, sekundenVerbleibend);
    Serial.print("  |  CO2: ");
    
    if (co2 > 0) {
      Serial.print(co2);
      Serial.println(" ppm  (Stabilisierung läuft...)");
    } else {
      Serial.println("---  (Lesefehler)");
    }
    
    // Warte 10 Sekunden bis zur nächsten Messung
    delay(MESS_INTERVALL);
  }
  
  // ========== KALIBRIERUNG DURCHFÜHREN ==========
  else if (!kalibriert && vergangen >= WARTEZEIT_MS) {
    Serial.println();
    Serial.println("============================================================");
    Serial.println("SCHRITT 3: KALIBRIERUNG AUF FRISCHLUFT");
    Serial.println("============================================================");
    Serial.println();
    
    // Aktuellen Wert vor Kalibrierung anzeigen
    Serial.print("CO2-Wert vor Kalibrierung: ");
    if (co2 > 0) {
      Serial.print(co2);
      Serial.println(" ppm");
    } else {
      Serial.println("nicht verfügbar");
    }
    Serial.println();
    
    // Kalibrierungs-Befehl senden
    Serial.println("Sende Zero Point Calibration Befehl...");
    mhzSerial.write(cmdCalibrate, 9);
    delay(2000);  // Warten auf Verarbeitung
    
    Serial.println("✓ Kalibrierung abgeschlossen!");
    Serial.println();
    Serial.println("Der Sensor verwendet jetzt den aktuellen Wert als");
    Serial.println("Frischluft-Referenz (~420 ppm).");
    Serial.println();
    
    kalibriert = true;
    
    Serial.println("============================================================");
    Serial.println("SCHRITT 4: NORMALER MESSBETRIEB");
    Serial.println("============================================================");
    Serial.println();
    Serial.println("✓ Sensor ist kalibriert und einsatzbereit!");
    Serial.println();
    Serial.println("Sie können den Sensor jetzt wieder ins Haus bringen.");
    Serial.println("Die Messwerte werden jetzt alle 10 Sekunden angezeigt.");
    Serial.println();
    Serial.println("------------------------------------------------------------");
    Serial.println("  MESSWERTE:");
    Serial.println("------------------------------------------------------------");
    Serial.println();
  }
  
  // ========== NORMALER MESSBETRIEB ==========
  else if (kalibriert) {
    // Betriebszeit berechnen
    unsigned long betriebszeit = (jetzt - startzeit) / 1000;  // in Sekunden
    unsigned long stunden = betriebszeit / 3600;
    unsigned long minuten = (betriebszeit % 3600) / 60;
    unsigned long sekunden = betriebszeit % 60;
    
    // Messwert anzeigen
    Serial.printf("%02lu:%02lu:%02lu  |  ", stunden, minuten, sekunden);
    Serial.print("CO2: ");
    
    if (co2 > 0) {
      Serial.print(co2);
      Serial.print(" ppm");
      
      // Bewertung hinzufügen
      if (co2 < 600) {
        Serial.println("  ✓ Sehr gut (Frischluft)");
      } else if (co2 < 1000) {
        Serial.println("  ✓ Gut (normale Raumluft)");
      } else if (co2 < 1500) {
        Serial.println("  ⚠️  Mäßig (Lüften empfohlen)");
      } else {
        Serial.println("  ⚠️  Schlecht (Dringend lüften!)");
      }
    } else {
      Serial.println("---  (Lesefehler)");
    }
    
    delay(MESS_INTERVALL);
  }
}

/********************************************************************************************
 *  HILFSFUNKTIONEN
 ********************************************************************************************/

/**
 * Liest den CO2-Wert vom MH-Z19B Sensor
 * @return CO2-Wert in ppm (0 bei Fehler)
 */
int leseCO2() {
  // Puffer leeren
  while (mhzSerial.available()) {
    mhzSerial.read();
  }
  
  // Read-Befehl senden
  mhzSerial.write(cmdReadCO2, 9);
  
  // Auf Antwort warten (max. 1 Sekunde)
  unsigned long timeout = millis() + 1000;
  while (mhzSerial.available() < 9 && millis() < timeout) {
    delay(10);
  }
  
  // Prüfen, ob genug Daten empfangen wurden
  if (mhzSerial.available() < 9) {
    return 0;  // Timeout
  }
  
  // 9 Bytes lesen
  byte response[9];
  for (int i = 0; i < 9; i++) {
    response[i] = mhzSerial.read();
  }
  
  // Prüfen, ob Antwort gültig ist
  if (response[0] != 0xFF || response[1] != 0x86) {
    return 0;  // Ungültige Antwort
  }
  
  // Checksum überprüfen (optional, für mehr Zuverlässigkeit)
  byte checksum = 0;
  for (int i = 1; i < 8; i++) {
    checksum += response[i];
  }
  checksum = 0xFF - checksum + 1;
  
  if (checksum != response[8]) {
    return 0;  // Checksum-Fehler
  }
  
  // CO2-Wert aus Bytes 2 und 3 extrahieren
  int co2 = (response[2] << 8) | response[3];
  
  return co2;
}

/********************************************************************************************
 *  ZUSÄTZLICHE INFORMATIONEN
 ********************************************************************************************
 *  
 *  MH-Z19B KALIBRIERUNG - HINTERGRUND:
 *  ====================================
 *  
 *  Warum kalibrieren?
 *  ------------------
 *  - CO2-Sensoren können im Laufe der Zeit "driften"
 *  - Referenzwert verschiebt sich → falsche Messwerte
 *  - Kalibrierung stellt bekannten Referenzpunkt wieder her
 *  
 *  
 *  Was ist ABC (Automatic Baseline Correction)?
 *  --------------------------------------------
 *  - Sensor nimmt an: niedrigster CO2-Wert in 24h = Frischluft
 *  - Passt Referenz automatisch an
 *  - Problem: In geschlossenen Räumen ohne Lüftung funktioniert das nicht
 *  - Kann zu falschen Kalibrierungen führen (z.B. 800 ppm als "Frischluft")
 *  - Deshalb: ABC für manuelle Kalibrierung ausschalten!
 *  
 *  
 *  Zero Point Calibration:
 *  -----------------------
 *  - Manuelle Kalibrierung auf bekannten Referenzwert
 *  - Frischluft hat ca. 420 ppm CO2 (weltweiter Durchschnitt)
 *  - Sensor speichert diesen Wert als neue Referenz
 *  - Wichtig: Muss wirklich in Frischluft durchgeführt werden!
 *  
 *  
 *  Wartezeit 20 Minuten:
 *  ---------------------
 *  - Sensor braucht Zeit zur Stabilisierung
 *  - Temperatur muss sich angleichen
 *  - Interne Elektronik muss sich einpendeln
 *  - Erste Messwerte sind oft ungenau
 *  
 *  
 *  Typische CO2-Werte:
 *  -------------------
 *  400-420 ppm:  Frischluft (Außenluft)
 *  400-600 ppm:  Sehr gute Raumluft
 *  600-1000 ppm: Normale Raumluft
 *  1000-1500 ppm: Mäßig, Lüften empfohlen
 *  > 1500 ppm:   Schlecht, dringend lüften!
 *  > 2000 ppm:   Gesundheitlich bedenklich
 *  
 *  
 *  Fehlersuche:
 *  ------------
 *  - "Lesefehler": Verkabelung prüfen (TX/RX vertauscht?)
 *  - Wert ändert sich nicht: ABC ist noch aktiv oder Sensor defekt
 *  - Zu niedrige Werte: In Innenraum kalibriert statt in Frischluft
 *  - Zu hohe Werte: Sensor muss neu kalibriert werden
 *  
 ********************************************************************************************/
</code>
===== LDR =====
<code>
/********************************************************************************************
 *  LDR Test - Lichtsensor (Light Dependent Resistor)
 *  
 *  Verdrahtung:
 *  - Analog Pin: A0
 *  - LDR in Spannungsteiler-Schaltung:
 *    - 3.3V → LDR → A0 → Widerstand (z.B. 10k) → GND
 *    oder
 *    - 3.3V → Widerstand → A0 → LDR → GND
 *  
 *  Hinweis: Im Hauptcode ist invertiert (hell=klein, dunkel=groß)
 ********************************************************************************************/

#define LDR_PIN A0

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("\n=== LDR Helligkeitssensor Test ===");
  Serial.println("\nZeigt Rohwert (0-1023) und invertiert wie im Hauptcode\n");
  
  pinMode(LDR_PIN, INPUT);
  
  delay(1000);
}

void loop() {
  // Rohwert auslesen (0-1023)
  int rawValue = analogRead(LDR_PIN);
  
  // Invertiert wie im Hauptcode (450 - raw)
  // → hell wird zu kleinem Wert, dunkel zu großem Wert
  int inverted = 450 - rawValue;
  
  // Bargraph für Rohwert erstellen
  Serial.print("Rohwert: ");
  printBar(rawValue, 1023);
  Serial.print(" ");
  Serial.print(rawValue);
  Serial.print(" / 1023");
  
  // Interpretation
  if (rawValue > 800) {
    Serial.print(" [SEHR HELL]");
  } else if (rawValue > 500) {
    Serial.print(" [Hell]");
  } else if (rawValue > 200) {
    Serial.print(" [Mittel]");
  } else if (rawValue > 50) {
    Serial.print(" [Dunkel]");
  } else {
    Serial.print(" [SEHR DUNKEL]");
  }
  Serial.println();
  
  // Invertierter Wert (wie er an EmonCMS gesendet wird)
  Serial.print("Invertiert (für EmonCMS): ");
  Serial.println(inverted);
  
  Serial.println("---");
  delay(500);  // Schnelles Update zum Testen
}

// Hilfsfunktion: Bargraph im Serial Monitor
void printBar(int value, int maxValue) {
  int barLength = map(value, 0, maxValue, 0, 40);
  Serial.print("[");
  for (int i = 0; i < 40; i++) {
    if (i < barLength) {
      Serial.print("=");
    } else {
      Serial.print(" ");
    }
  }
  Serial.print("]");
}
</code>

<code
18:47:21.985 -> ---
18:47:22.468 -> Rohwert: [===                                     ] 69 / 1023 [Dunkel]
18:47:22.501 -> Invertiert (für EmonCMS): 381
18:47:22.501 -> ---
</code>

===== LED-Band =====
===== LED-Band =====
<code>
/********************************************************************************************
 *  LED-Band Test - NeoPixel / WS2812B LED-Streifen (CO₂-Ampel)
 *  
 *  Verdrahtung:
 *  - DATA: D4 (GPIO2)
 *  - VCC: 5V (für volle Helligkeit, 3.3V funktioniert auch mit reduzierter Leistung)
 *  - GND: GND
 *  
 *  Hinweis: 5 LEDs, wie im Hauptcode definiert
 ********************************************************************************************/

#include <Adafruit_NeoPixel.h>

#define LED_PIN   2        // D4
#define NUM_LEDS  5

Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("\n=== LED-Band NeoPixel Test ===");
  Serial.println("5 LEDs an D4 (GPIO2)\n");
  
  strip.begin();
  strip.show();  // Alle LEDs aus
  
  Serial.println("Test-Sequenz startet...\n");
}

void loop() {
  // 1. Einzelne LEDs durchgehen (Rot)
  Serial.println("Test 1: Einzelne LEDs (Rot)");
  strip.clear();
  for (int i = 0; i < NUM_LEDS; i++) {
    strip.setPixelColor(i, strip.Color(255, 0, 0));
    strip.show();
    delay(300);
  }
  delay(1000);
  
  // 2. Alle LEDs in verschiedenen Farben
  Serial.println("Test 2: Alle LEDs - verschiedene Farben");
  
  Serial.println("  - Rot");
  strip.fill(strip.Color(255, 0, 0));
  strip.show();
  delay(1000);
  
  Serial.println("  - Grün");
  strip.fill(strip.Color(0, 255, 0));
  strip.show();
  delay(1000);
  
  Serial.println("  - Blau");
  strip.fill(strip.Color(0, 0, 255));
  strip.show();
  delay(1000);
  
  Serial.println("  - Gelb");
  strip.fill(strip.Color(255, 255, 0));
  strip.show();
  delay(1000);
  
  Serial.println("  - Weiß");
  strip.fill(strip.Color(255, 255, 255));
  strip.show();
  delay(1000);
  
  // 3. CO₂-Ampel Simulation (wie im Hauptcode)
  Serial.println("\nTest 3: CO₂-Ampel Simulation");
  
  Serial.println("  - 600 ppm: BLAU (sehr gut)");
  setCO2Color(600);
  delay(2000);
  
  Serial.println("  - 900 ppm: GRÜN (gut)");
  setCO2Color(900);
  delay(2000);
  
  Serial.println("  - 1400 ppm: GELB (mittel)");
  setCO2Color(1400);
  delay(2000);
  
  Serial.println("  - 2000 ppm: ROT (schlecht)");
  setCO2Color(2000);
  delay(2000);
  
  Serial.println("  - 2600 ppm: ALARM (blinken)");
  setCO2Color(2600);
  delay(3000);
  
  // 4. Helligkeitstest
  Serial.println("\nTest 4: Helligkeit (Rot)");
  for (int brightness = 0; brightness <= 255; brightness += 25) {
    Serial.print("  Helligkeit: ");
    Serial.println(brightness);
    strip.setBrightness(brightness);
    strip.fill(strip.Color(255, 0, 0));
    strip.show();
    delay(500);
  }
  
  // 5. Regenbogen-Effekt
  Serial.println("\nTest 5: Regenbogen");
  rainbowCycle(5);
  
  Serial.println("\n=== Sequenz beendet, wiederhole... ===\n");
  delay(2000);
}

// CO₂-Ampel Funktion (aus Hauptcode übernommen)
void setCO2Color(int co2) {
  if (co2 < 700) {
    strip.setBrightness(2);
    strip.fill(strip.Color(0, 0, 255));  // Blau
  } else if (co2 < 1100) {
    strip.setBrightness(3);
    strip.fill(strip.Color(0, 255, 0));  // Grün
  } else if (co2 < 1800) {
    strip.setBrightness(4);
    strip.fill(strip.Color(255, 255, 0));  // Gelb
  } else if (co2 < 2500) {
    strip.setBrightness(120);
    strip.fill(strip.Color(255, 0, 0));  // Rot
  } else {
    // Alarm: Rot-Weiß blitzen
    for (int i = 0; i < 5; i++) {
      strip.setBrightness(255);
      strip.fill(strip.Color(255, 0, 0));
      strip.show();
      delay(200);
      strip.fill(strip.Color(255, 255, 255));
      strip.show();
      delay(200);
      strip.clear();
      strip.show();
      delay(200);
    }
    strip.setBrightness(120);
    strip.fill(strip.Color(255, 0, 0));
    strip.show();
    return;
  }
  strip.show();
}

// Regenbogen-Effekt
void rainbowCycle(int cycles) {
  for (int j = 0; j < 256 * cycles; j++) {
    for (int i = 0; i < NUM_LEDS; i++) {
      strip.setPixelColor(i, Wheel((i * 256 / NUM_LEDS + j) & 255));
    }
    strip.show();
    delay(5);
  }
}

// Hilfsfunktion für Regenbogen (Farbrad)
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if (WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if (WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
</code>
Sie befinden sich hier: start » www-messdatenerfassung-sas » platinenschaltung
Suche

Werkzeuge

QR-Code
