Briefkasten mit E-Mail-Benachrichtigung und Solarmodul

Der folgende Blogbeitrag wurde uns von unserem Kunden Helmut Schmidt zugesandt. Dabei handelt es sich um einen Briefkasten, der Benachrichtigungen per E-Mail versendet, wenn Post eingeworfen wurde. Die Stromversorgung wurde mit kleinen Solarpanels und Akkus realisiert. Viel Spaß beim Lesen und Nachbasteln:

Der Briefkasten wurde zusammen mit einer Werkgruppe eines Senioren- und Pflegeheims gebaut. Die Überlegung war die Briefkasten mit einer E-Mail-Benachrichtigung auszustatten. Sobald jemand einen Wunschzettel einwirft, wird eine E-Mail an eine Gruppe ehrenamtlicher Mitarbeiter, die Grünen Damen, verschickt. Schließlich wird ja keiner die Briefkästen täglich kontrollieren. Herausgekommen war ein Briefkasten mit Solarmodul und einem ESP8266 D1 mini. Das Programm verwendet Deep Sleep, bis ein Wunschzettel eingeworfen wird, oder die Tür des Briefkastens geöffnet wird.

Benötigte Hardware

Vorbereitungen

Download zusätzlicher Boardverwalter-ULR
Datei > Voreinstellungen:
http://arduino.esp8266.com/stable/package_esp8266com_index.json

Installieren der neun Pakete mit dem Boardveralter
Werkzeuge > Board > Boardverwalter:
esp8266 by ESP8266 Community

Nach der Installation finden Sie alle ESP8266 Boards. Wählen Sie LOLIN(WEMOS) D1 mini&R2 aus.

Unter Datei > Beispiele für D1 mini > ESP8266 befindet sich das LowPowerDemo mit 10 Tests für modem sleep, light sleep und deep sleep.

In diesem Blogbeitrag wurde bereits eingehend beschrieben, wie sich G-Mails per ESP8266 versenden lassen:
https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/g-mails-per-esp

In dem Blogbeitrag G-Mails per ESP8266 versenden wurde bereits eingehend beschrieben, wie sich G-Mails per ESP8266 versenden lassen. Hierzu muss noch eine eigene Library von github.com geladen werden. Anschließend können sie über Sketch > Datei hinzufügen > Öffnen die soeben heruntergeladene .zip-Datei auswählen. Über Datei > Beispiele aus eigenen Bibliotheken > ESP8266SMTP finden Sie das G-Mail Programm.

Es empfiehlt sich dringendst, ein eigenes E-Mail-Konto zu erstellen, um die E-Mails an Ihre persönliche Haupt-E-Mail-Adresse zu senden. Verwenden Sie nicht Ihre persönliche Haupt-E-Mail-Adresse um zu vermeiden, dass aus Versehen Ihr Konto gesperrt oder vorübergehend deaktiviert wird. Für Versuche empfiehlt sich ein Gmail.com - Konto zum Senden der E-Mails. Die Empfänger-E-Mail kann Ihre persönliche E-Mail sein.

Alle Details zum Einrichten eines Gmail.com-Kontos und einer E-Mail-Adresse finden Sie unter folgendem Link.

Verbindung zwischen Solarmodul, Akku und ESP8266

Die Vorgaben waren eine möglichst preisgünstigen Anwendung mit einem oder zwei Solarpanels. Normale Ni-MH Akkus haben den Nachteil einer relativ hohen Selbstentladung, monatlich um 15-25%. Inzwischen gibt es schon bessere Ni-MH Akkus mit einer Selbstentladung von nur 15% Verlust innerhalb eines Jahren, preislich aber dann ähnlich wie Li-Ion. Zwei Solarpanels liefern bei üblicher Zimmerhelligkeit über 5 V und meist über 10 V. Unter Last bricht die Spannung in der Regel unter die maximale Ladespannung. Durch die Schutzfunktion im Li-Ion-Akku selbst (oder mit LM2596S DC-DC Netzteil Adapter) sind auch Spannungen von 7 V kein Problem. Ni-MH Akkus sollten aber bis maximal 1,4 V geladen werden. Als Li-Ion-Akku wurde auch ein 18650, 3,7 V, 2600 mAh, inkl. MicroUSB Ladebuchse ausgewählt. Damit ist die Schutzschaltung bereits im Akku integriert. Die ersten Versuche im Freien zeigten eine ausreichende Ladung durch die Solarpanels, sowohl mit NiMH - als auch LiIon - Akkus. Bei Zimmerhelligkeit hatten Ni-MH die Nase vorn. offensichtlich verbraucht die Schutzschaltung bei geringen Ladeströmen mehr Strom als in den Akkus gespeichert werden. Eine Möglichkeit wäre, einen Li-Ion-Akku ohne eingebaute Schutzschaltung allein durch die Strombegrenzung durch Schaltung mit dem ESP8266.

Damit keine Überladung auftritt, wird kurzzeitig der Deep Sleep für eine Spannungsmessung durch den RTC-timer unterbrochen. Sollte, bei heißen Tagen, die Spannung an der Nähe der maximalen Ladespannung sein, wird das Wifi aktiviert und die Spannung wieder in die Norm gebracht. Die Messung erfolgt mit analogRead(pin_Spannung) am GPIO A0. Im Wemos D1 mini ist bereits ein Spannungsteiler aus 220 kOhm / 100 kOhm eingebaut, mit einem Innenwiderstand von 320 kOhm. Setzt man einen weiteren Widerstand von 680 kOhm zwischen A0 und Vin dazu, wird der Spannungsbereich von 1 V auf (1MOhm)/100kOhm * 1 V = 10 V erweitert. Die gemessene Spannung muss somit mit dem Faktor 9,3 multipliziert werden.

Sollte die Spannung in die Nähe der Entladeschlussspannung sinken, wird als erstes der Akku für einige Zeit geladen. Für Li-Ion-Akku ist die Entladeschlussspannung 3,5 V, bei Ni-MH Akkus 1,1 V. Damit ein Rückstrom vom Akku zum Solarpanel sicher ausgeschlossen ist, sind Solarpanel und Konverter über eine Diode BYV 27/200 verbunden. Die eigentliche Aufgabe des ESP8266 wird durch WAKEUP erledigt. Es empfiehlt sich, das LowPowerDemo vor ab auf den ESP8266 zu laden, um alle Möglichkeiten mal auszuprobieren. Am besten ist es, den ESP8266 mit einer externen Spannungsquelle zu betreiben und sich die Stromaufnahmen mit einem Messgerät anzeigen zu lassen. Bei dem runTest6 im Forced Light Sleep ist der minimale Stromverbrauch 0,9 mA, im Deep Sleep nur 0,15 mA. Allerdings erlaubt Deep Sleep nur ein einziges externes Signal für den wakeup. Der RTC-Timer läuft auch im Deep Sleep. Sobald die Zeit von ESP.deepSleep(microseconds) abgelaufen ist, liegt an D0/GPIO16 LOW an. Sind also D0 und RST verbunden, wird der EPS8266 resettet. Damit weitere Signale ausgewertet werden können, braucht es noch Spannungsteiler aus jeweils einem Widerstand und einem Kondensator (s. Schaltung).

Die Symbole der LEDs hinter der BYV 27/200 Diode stellen die Solarmodule dar. Der Schalter (auf den Fotos als Dip-Schaltermodul zu sehen) trennt oder öffnet die Verbindung zum Akku.

Sobald ein Brief eingeworfen wird, liegt über einen Mikroschalter D5 LOW an. Bei Öffnung des Briefkastens ist LOW an D7. Über den Kondensator wird kurzzeitig der Reset ausgeführt. Der ESP8266 läuft an und registriert die Eingänge von D5 und D7. Die Zeitkonstante muss so kurz als möglich sein, dass der Spike den Reset sicher ausführt, aber der Input an D5 und D7 noch LOW ist. Die Diode zwischen RST und D0 erlaubt es, den ESP8266 auch zu programmieren.

Wichtig ist auch noch eine Überwachung des WiFi Status. Sollte eine Verbindung zum Netzwerk ausbleiben, wird der Versuch zur Verbindung nach wifiTimeout = 60 Sekunden abgebrochen. Der nächste Versuch erfolgt durch den Timer nach etwa 71 min. Sollte nach längerer Zeit noch immer keine Verbindung zum Netzwerk vorhanden sein, wird die Spannung unter die Minimalspannung sinken und, wie oben beschrieben, erst mal der Akku wieder aufgeladen. Das auslösende Ereignis wird im EEPROM gespeichert.

Kallkulation des Stromverbrauchs

Ohne Solarpanels ist der Verbrauch im Deep Sleep 0,15 mA . Geht man von einer E-Mail pro Tag aus, ist der Verbrauch etwa 60 mA für etwa 30 Sekunden. Pro Tag macht dies 0,15 mA * 24 h + 60 mA * 1/60 / 2 h = 4,1 mAh. Mit einem Li-Ion-Akku mit 2600 mAh könnte damit das D1 mini 2600 * 70% / 4.1 h = 440 Tage ununterbrochen betrieben werden. Bereits bei Zimmerhelligkeit liefern die beiden Solarmodule etwa 0,5 mA, das macht etwa 0,5 mA * 12 h = 6 mAh. Dies sollte den Stromverbrauch komplett decken. Im Freien wäre die Leistung der Solarmodule noch deutlich besser. Zur Sicherheit wird bei jeder E-Mail der Ladezustand des Akkus mit angezeigt. Beim Senden ergeben sich Spitzen bis 200 mA. Nach einer email-Versendung (mit 3 NiMH-Akkus) wurde nach 3 Stunden die gleiche Spannung gemessen, wie vor der E-Mail. Die Messungen für Lade- und Entladespannung durch ein Amperemeter sind mit Vorsicht zu genießen. Gerade am Umkehrpunkt (etwa U = 0 und I = 0) mit einem elektronischen Messgerät hängt die Anzeige von dessen Innenwiderstand ab. Treten also ungewöhnliche Werte auf, ist die Abhilfe den Messbereich auf 10 A einzustellen, mit 10 mA Schritte.

Alle Akkus haben Vor- und Nachteile. Ein LiFePO4 Akku hat eine Spannung von 3,3 V und wäre somit geeignet, erfordert aber auch eine sichere Schutzschaltung, da er nicht über 3,65 V geladen werden darf. NiMH Akkus haben den Nachteil einer höheren Selbstentladung. Am besten sind LSD-NiMH (low self-discharge). Die Verwendung von LiIon-Akkus hängt von der Umgebungshelligkeit ab. Für Li-Ion-Akkus ohne Schutzschaltung wird keine Garantie übernommen. Alternativ wurde auch ein NodeMCU-32S ausprobiert. Der Stromverbrauch war während des „Deep Sleeps“ 9,8 mA. Man kann sagen, der NodeMCU-32S war eher im Halbschlaf als Tiefschlaf. Beim NodeMCU-32S wird der USB Anschluss im Deep Sleep nicht deaktiviert. Stromaufnahmen unter 20 µA sind beim DFRobot FireBeetle ESP32 IoT und DFRobot FireBeetle ESP-12F (ESP8266) IoT möglich.

Fazit

Die langfristige Erprobung des Briefkastens mit E-Mail-Benachrichtung und Solarmodul steht noch aus. Das große Problem ist, die dauerhafte Stromversorgung zu realisieren. Solarpanels liefern nicht immer genug Spannung und der gespeicherte Strom in den Akkus reicht unter Umständen nicht aus. Ein Wechsel vom ESP32 zum ESP8266 hat wegen des geringeren Stromverbrauchs  etwas geholfen. Wichtig war es aber auch zu zeigen, wie man drei Eingänge trotz Deep Sleep nutzen kann.

Anregung von einem opensource-wettersensor:
https://www.ltspiceusers.ch/threads/opensource-wettersensor-werdegang.392/

ESP8266WiFi-Bibliotheksdokumentation:
https://arduino-esp8266.readthedocs.io/en/latest/libraries.html

Anbei das gesamte Programm mit Anmerkungen oder hier als Download:

Denken Sie daran, Ihre W-Lan und E-Mail-Kontodaten einzutragen (ab Zeile 36 und 90)

 //    MINI_SOLARPANEL 5V und AKKU über Ultraschnelle Avalanche-Sinterglasdiode BYV 27/200 verbinden  //
 ​
 //Author:
 //Dr. Helmut Schmidt <grueneengel17@gmail.com>
 ​
 #include <ESP8266WiFi.h>
 #include <ESP8266SMTP.h>
 #include <EEPROM.h>
 ​
 // LiIon_Akku
 // const int Ladespannung_max = 5500;   // Die ideale Ladespannung für Lithium-Ionen-Akkus beträgt um die 4,2 Volt. LiIon-Akku bereits vor Überspannung geschützt
 // const int Ladespannung_min = 3500;   //   Entladeschlussspannung
 ​
 //  für  NiMH_Akkus
 byte n_Akkus = 3;
 const int Ladespannung_max = n_Akkus * 1400;  //  Ladeungsspannung max. 1.4 V   für NiMH_Akku
 const int Ladespannung_min = n_Akkus * 1100;  //  Entladeschlussspannung  = 3.3 V   Minimum unter Last
 ​
 ​
 int Spannung;
 const int pin_Spannung = A0;
 ​
 byte flag_Post = false, flag_Leerung = false,
 ​
 uint16_t Ausstehende_email = 0;
 uint16_t email = 0;
 uint32_t timeout = 60E3;  // 60 second timeout on the WiFi connection
 ​
 //   F Ü R    W A K E U P   //
 #define Taster_Leerung 13   // D7/GPIO13
 #define Taster_Post 14      // D5/GPIO14
 #define WAKE_UP_PIN 0       // WAKE_UP_timer ist im ESP8266 mit D0/GPIO16 verbunden >> D0 bewirkt einen reset
 ​
 //     F Ü R    WiFi     //
 //enter your WiFi configuration below
 const char* AP_SSID = "WIFI network name";                // WIFI network name
 const char* AP_PASS = "WIFI network password";            // WIFI network password
 ​
 ​
 void setup() {
   pinMode(WAKE_UP_PIN, INPUT_PULLUP);
   pinMode(Taster_Leerung, INPUT_PULLUP);
   pinMode(Taster_Post, INPUT_PULLUP);
 ​
   if (digitalRead(Taster_Leerung) == LOW) flag_Leerung = true;    //      Taster gedrückt
   if (digitalRead(Taster_Post) == LOW) flag_Post = true;
 ​
// S P A N N U N G S K O N T R O L L E
 // Der Spannungsteiler im Wemos D1 mini ist 100kOhm + 220 kOhm = 320 kOhm  mit einem externen Widerstand 680kOhm sollte
 // rechnerisch ist Umrechnungsfaktor  1MOhm/100kOhm = 10 sein.  Spannung in mVolt.
   Spannung = analogRead(pin_Spannung) * 10;
 ////////////////  zum testen ohne Spannungsteiler  ///////////
 //Spannung = 4000;
 ​
   //  DATEN AUS DEM EEPROM
   EEPROM.begin(512);
   Ausstehende_email = EEPROM.read(0); email = EEPROM.read(4);
 ​
   if (flag_Post == false && flag_Leerung == false && Spannung < Ladespannung_max && Ausstehende_email == 0)  ESP.deepSleep(0xFFFFFFFF);   // weiter schlafen
 ​
 // bei Post und Unterspannung  Wifi nicht aktivieren
   if (Spannung < Ladespannung_min) {
     if (flag_Post == true) {                //  Deepsleep  o h n e  wifi
       Ausstehende_email++;
       EEPROM.write(0, Ausstehende_email);  EEPROM.commit();
       Serial.begin(115200);  Serial.println("Ausstehende_email" + String (Ausstehende_email)); // nur zum testen
     }
     ESP.deepSleep(0xFFFFFFFF);               // weiterschafen
   }
 ​
   EEPROM.begin(512);
   Serial.begin(115200);
   Serial.println();                                    
   Serial.println("Spannung = " + String(Spannung) + "mVolt");
   Serial.println("Start Up");
 ​
   WiFi.persistent(false);    // don't store the connection each time to save wear on the flash
   WiFi.mode(WIFI_STA);
   WiFi.setOutputPower(10);   // reduce RF output power, increase if it won't connect
   WiFi.begin(AP_SSID, AP_PASS);
   Serial.print(F("connecting to WiFi "));            
   Serial.println(AP_SSID);
 ​
   int wifiTimeout = millis() + timeout;          //         oder 60 sec
   while (WiFi.status() != WL_CONNECTED && wifiTimeout > millis()) {
     Serial.print(".") ;                       
     delay (1000);
   }
   if (WiFi.status() == WL_CONNECTED) {
     SMTP.setEmail("Sender@gmail.com")
     .setPassword("password")
     .Subject("Subject")
     .setFrom("From")
     .setForGmail();                        // simply sets port to 465 and setServer("smtp.gmail.com");
 ​
     if (flag_Post == true || Ausstehende_email > 0) {
       email++;  EEPROM.write(4, email); Ausstehende_email = 0; EEPROM.write(0, Ausstehende_email);
       SMTP.Send("dr.h.schmidt@online.de", String(Spannung) + " mVolt\r " + String(email) + " Ein Wunschzettel ist im Briefkasten auf der Station 2 eingegangen");
     }
     else if (flag_Leerung == true ) {
       SMTP.Send("dr.h.schmidt@online.de", String(Spannung) + " mVolt\r Briefkasten auf der Station 2 geleert");
       Ausstehende_email = 0; EEPROM.write(0, Ausstehende_email); EEPROM.write(4, 0);
     }
     else if (Spannung > Ladespannung_max) {
       SMTP.Send("dr.h.schmidt@online.de", " Überspannung  Spannung = " + String(Spannung) + " mVolt   email = " + String(email) + " Ausstehende email = " + String(Ausstehende_email));      //   ggf.    Kommentieren
       EEPROM.commit();
       ESP.deepSleep(0x10000000) ;      ///  alle 10 sec   zum  Abbau von Überspannung
     }
 ///////      nur zum Testen des timers
        else if (true) {
           SMTP.Send("dr.h.schmidt@online.de", " email = " + String(email) + " Ausstehende email = " + String(Ausstehende_email) +  " Spannung = " + String(Spannung) + " mVolt ");      //   ggf.    Kommentieren
         }  
 ///////   Testende
   }
 ​
   EEPROM.commit();
   ESP.deepSleep(0xffffffff); //microsecondsAnzahl der Mikrosekunden zum Schlafen. Der maximale Wert beträgt 4294967295us oder ~71 Minuten.
   //    it will never get here!
 }
 ​
 void loop() {   //    it will never get here!
 }
 ​
 /////////   Für den richtigen Einsatz           alle  Serialprint - Befehle      auskommentieren     ///////////