beelogger

beelogger-STM32 … Programmcode

Die beelogger-STM32 Multi Sketche unterstützen bis zu vier Waagen an einem beelogger-STM32 mit den Sensoren. Der Programmcode kann nur mit einem EE-Prom verwendet werden. Weitere Informationen hier zu
Details des Aufbaus und dem Sketch
Pinbelegung
Debug-Ausgaben und Messwerte

Das beelogger-Team leistet bei Fragen gerne Unterstützung.

Unbedingt vor dem Laden dieser Sketche die Testprogramme für den beelogger und der Sensoren zum Funktionstest der Komponenten durchführen.
Diverse Testprogramme sind im Download, auf dieser Seite unten, enthalten.

Die Multi-Sketche ermöglichen die Messung der Batteriespannung sowie die Einstellung eines Weckintervalls über die im STM32 integrierte Echtzeituhr.
Ein beelogger-STM32 System wird zwischen den Messungen in einen sehr stromsparenden Schlafmodus mit einem Strombedarf von ca. 20uA versetzt.

Die Multi Sketche sind in Ausführungen für Aufbauten mit bis zu vier Waagen an einem beelogger verfügbar:

– WLAN, GSM, LTE  -MULTI
– LORA
– Bienenzähler, zwei Waagen, WLAN

Hinweise zur Sensorkonfiguration in den STM32-Multi-Sketchen:

In den STM32-Multi-Sketchen sind zahlreiche Sensortypen verfügbar und können komfortabel zugeordnet werden.
Das beelogger-Projekt benötigt diverse Biblotheken, die  als Datei zu Verfügung stehen.

Die Konfiguration ist in einer systemabhängigen “Config_Multi.h” und einer  “Config_WLAN / GSM / LTE.h” enthalten.
Die Einstellungen zur Debug-Option, Pinbelegung oder Detailkonfiguration der Sensoren (I2C-Adressen) finden sich in der “STM32_beelogger_config.h“.

  • Sketche haben optionale Debug-Informationen eingebaut, die über das Debug-Flag aktiviert werden können. Im Dauerbetrieb sollte das Debug-Flag auf “0” gesetzt sein.
#define myDebug 0  // 0 / 1  Debug via Serial Monitor

Es stehen diverse Sensoren konfigurierbar zur Verfügung.

Hinweis:
Der I2C-Bus ist in seiner Leitungslänge sehr eingeschränkt. Je nach Anzahl der I2C-Sensoren, Leitungslängen und Aufbau der Verdrahtung kann es Instabilitäten des beeloggers kommen. In ungünstigen Fällen “hängt” der beelogger und sendet keine Daten.
Insbesondere bei Systemen mit 2 und mehr Waagen sollten I2C-Sensoren zur Beutenüberwachung erst nach längerem Probebetrieb verwendet werden.

Damit ein Sensor für Temperatur, Feuchte oder Luftdruck vom Sketch abgefragt wird, muss dieser aktiviert werden.
Der Sensor muss danach einer Aufgabe zugewiesen werden, damit die Messwerte übertragen werden.
Hinter dem Sensor ist die zugehörige Sensornummer (von 1-9) für die Zuweisung angegeben.

//----------------------------------------------------------------
// Sensorkonfiguration
// 1. Sensor für die Abfrage durch den Sketch aktivieren
// 2. aktive Sensoren für Temperatur/Feuchte in der Sensormatrix zuordnen
// 3. Sensor für Temperatur Wägezelle festlegen
//----------------------------------------------------------------
#define Anzahl_Sensoren_DHT     0   // Mögliche Anzahl: '0','1','2'  --- Nr 1+2 ---- (Temperatur + Luftfeuchte)

#define Anzahl_Sensoren_Si7021  0   // Mögliche Anzahl: '0','1'      --- Nr 3 ----- (Temperatur + Luftfeuchte)

#define Anzahl_Sensoren_SHT31   0   // Mögliche Anzahl: '0','1','2'  --- Nr 4+5 --- (Temperatur + Luftfeuchte)

#define Anzahl_Sensoren_BME280  0   // Mögliche Anzahl: '0','1','2'  --- Nr 6+7 --- (Temperatur + Luftfeuchte)

#define Anzahl_Sensoren_DS18B20 0   // Mögliche Anzahl: '0','1','2'  --- Nr 8+9 --- (Nur Temperatur) 
//                                                          '3','4'  --- Nr 8+9 --- (im Wert Luftfeuchte) 

// 2. Sensormatrix, hier kann die Zuordnung der Sensoren geändert werden
// Nr 1 - 9 aus Liste oben auswählen, wenn kein Sensor gewünscht ist einfach "0" angeben
// wenn kein Sensor für die Aussentemperatur gesetzt ist, wird automatisch der Temperatursensor der RTC verwendet
#define Aussenwerte        0 // 0 oder Nr. 1 - 9 
// Sensor Beute 1 
#define Beute1             0 // 0 oder Nr. 1 - 9 
// Sensor Beute 2 
#define Beute2             0 // 0 oder Nr. 1 - 9 
// Sensor Beute 3
#define Beute3             0 // 0 oder Nr. 1 - 9 
// Sensor Beute 4 
#define Beute4             0 // 0 oder Nr. 1 - 9 

// 3. Temperatur Wägezelle (Duo, Triple, Quad usw.
// Sensor, der die Temperatur der Wägezelle erfasst; vorbelegt der erste DS18B20 
// für Systeme mit einer Waage identisch zum Sensor Aussenwerte eintragen
#define Temp_Zelle         8 // 0 oder Nr. 1 - 9

In diesem Beispiel werden die Werte vom DHT-Sensor der Beute 1 zugeordnet, während die Aussenwerte ihre Daten vom ersten SHT31-Sensor beziehen.

– Zunächst werden die vorhandenen Sensoren für die Verwendung aktiviert.

#define Anzahl_Sensoren_DHT      1   // Mögliche Anzahl: '0','1','2' --- Nr 1+2 ---- (Temperatur + Luftfeuchte) 
#define Anzahl_Sensoren_Si7021   0   // Mögliche Anzahl: '0','1'      --- Nr 3 ----- (Temperatur + Luftfeuchte) 
#define Anzahl_Sensoren_SHT31    1   // Mögliche Anzahl: '0','1','2'  --- Nr 4+5 --- (Temperatur + Luftfeuchte) 
#define Anzahl_Sensoren_BME280   0   // Mögliche Anzahl: '0','1','2'  --- Nr 6+7 --- (Temperatur + Luftfeuchte) 
#define Anzahl_Sensoren_DS18B20  0   // Mögliche Anzahl: '0','1','2'  --- Nr 8+9 --- (Nur Temperatur)

– Im Anschluss kann man die jeweilige  Sensornummer  einfach der entsprechenden Messstelle zuordnen.
– die Sensoren werden ihrer Aufgabe zugeordnet

#define Aussenwerte  4 // 0 oder Nr. 1 - 9 // Sensor Beute 1 
#define Beute1       1 // 0 oder Nr. 1 - 9 // Sensor Beute 2 
#define Beute2       0 // 0 oder Nr. 1 - 9 // Sensor Beute 3 
#define Beute3       0 // 0 oder Nr. 1 - 9 // Sensor Beute 4 
#define Beute4       0 // 0 oder Nr. 1 - 9 

#define Temp_Zelle   4 // 0 oder Nr. 1 - 9

Hinweis: Bisherige Sketche verwenden den ersten DS18B20 oder den Aussentemperaturwert für die Temperaturkompensation automatisch.

Zusätzliche Sensorwerte:

Als zusätzlicher Sensor kann ein Lichtsensor BH1750 konfiguriert werden.
Neben dem Messwert Luftdruck eines BME280 ist der Messwert eines Niederschlagsmessers vorgesehen.
Luftdruckmesswerte zum Vergleich finden sind in den aktuellen Beobachtungswerten des Deutschen Wetterdienstes.
Hinweis: Systeme mit Niederschlagmesser haben einen deutlich höheren Ruhestrombedarf von ca. 1mA gegenüber sonst üblichen Werten unter 20µA.

//----------------------------------------------------------------
// erweiterte Sensoren
//----------------------------------------------------------------
// Luftdruck von BME280
#define Korrektur_Luftdruck 0.0 // Korrekturwert um Abweichungen zu offiziellen Wetterstationen bei Bedarf auszugleichen; Aux[1]

#define Anzahl_Sensoren_Licht 0 // Mögliche Anzahl: '0','1' //BH1750

// Audio mit Sensor GY-MAX4466 
#define beelogger_Audio 0 // Mögliche Anzahl: '0','1' // Aux[0], Aux[2]; Sensor GY-MAX4466

//Niederschlagsensor ACHTUNG: belegt gleichen Messwert wie AudioSensor
#define Anzahl_Sensor_Regen 0 // Mögliche Anzahl: '0','1' // Aux[2]; Sensor Regen
const float Rain_Cal = { 1.0 }; // Hier ist der Wert aus der Kalibrierung einzutragen

Des weiteren sind Anzahl der Waagen sowie die Kalibrierparameter der Waage / HX711 und für die Spannungsmessung einzutragen.
Die “Anzahl_Sensoren_Gewicht” muss zum Server/Serverskript passen, auch wenn eine Waage nicht oder später angeschlossen wird, z.B. 2 = Duo.
Sind keine Kalibrierdaten (Taragewicht  10) eingetragen, wird die Waage vom System ignoriert; d.h. der Sketch läuft auch ohne Waage.

#define Anzahl_Sensoren_Gewicht 1 // Mögliche Anzahl: '1','2','3','4'

// Anschluss / Konfiguration Wägezellen-------------------------------------------------------
// mit Anzahl_Sensoren_Gewicht 1 // HX711(1) Kanal A = Waage1; Serverskript: beeloggerY 
// mit Anzahl_Sensoren_Gewicht 2 zusätzlich: // HX711(1) Kanal B = Waage2; Serverskript: DuoY 
// mit Anzahl_Sensoren_Gewicht 3 zusätzlich: // HX711(2) Kanal A = Waage3; Serverskript: TripleY 
// mit Anzahl_Sensoren_Gewicht 4 zusätzlich: // HX711(2) Kanal B = Waage4; Serverskript: QuadY 
// Kalibrierwerte für die Wägezellen
const long Taragewicht[4] = { 10, 10, 10, 10 }; // Hier ist der Wert aus der Kalibrierung einzutragen
const float Skalierung[4] = { 1.0, 1.0, 1.0, 1.0 }; // Hier ist der Wert aus der Kalibrierung einzutragen
// Kalibrierwerte für die Spannungsmessung Akku
const long Kalib_Spannung = 1000; // Hier muss der Wert aus der Kalibrierung eingetragen werden, sonst funktioniert der Programmcode nicht
const long Kalib_Bitwert = 100; // Hier muss der Wert aus der Kalibrierung eingetragen werden, sonst funktioniert der Programmcode nicht
//Konfiguration Spannungsversorgung
// Li-Ion Akku (bitte nicht verändern)
const float VAlternativ = 3.8; // Minimale Spannung ab der automatisch das alternative Intervall aktiviert wird 
const float VMinimum = 3.75; // Minimale Spannung ab der ab der keine Messungen und auch kein Versand von Daten erfolgt 

Erläuterung:
Bei einer Spannung die höher ist als VAlternativ, werden die Messwerte wie in den Intervallen (im Sketch oder bei aktiver Fernsteuerung über den Webserver) konfiguriert abgefragt und versendet. Ab einer Spannung von VAlternativ und geringer, werden Messungen und Versand der Daten nur noch alle 2 Stunden (120min) durchgeführt. Dieser Wert ist nicht über den Server konfigurierbar.
Bei einer Spannung die kleiner oder gleich VMinimum ist, werden weder Messungen vorgenommen, noch Daten versendet. Sobald der Akku durch die Solarzelle aufgeladen ist und die Akkuspannung die eingestellten Werte erreicht bzw. überschreitet, nimmt der beelogger seinen Betrieb wieder auf.

Schwarmalarm: Parametrierung der automatischen Sendefunktion bei Gewichtsänderung für beelogger mit EE-Prom. Achtung dieser Wert ist in der STM32_beelogger.h enthalten.

//----------------------------------------------------------------
// Änderung Gewicht in Kilogramm bei der Daten versenden erfolgt
//----------------------------------------------------------------
const float Alarm_Gewicht = 1.0;
//----------------------------------------------------------------

Im nächsten Schritt sind die Zugangsparameter für Provider im Mobilfunk-Netz oder die WLAN-Daten anzugeben.

GSM / LTE – Zugangsinformationen:

// Name des Zugangspunktes des Netzwerkproviders 
const char APN[] PROGMEM = {"APN-Name"};

Bei LTE kann für die Anmeldung beim Mobilfunk-Provider APN-Benutzer und APN-Passwort notwendig sein.

// Benutzername zum APN des Netzwerkproviders 
const char APN_Benutzer[] PROGMEM = {"APN-Benutzer"}; 
// Passwort zum APN des Netzwerkproviders 
const char APN_Passwort[] PROGMEM = {"APN-Passwort"};

WLAN-Parameter:

//----------------------------------------------------------------
// WLAN Parameter
// WLan Daten unbedingt nach Verfügbarkeit und Stärke eintragen (stärkstes in Nr. 1)
// Hinweis: ESP-Testsketch zeigt alle Feldstärken an
//----------------------------------------------------------------
#define Anzahl_AP 1 // Mögliche Werte: '1','2'

// Zugangspunkt Nr. 1 Daten = vorrangiger/primärer Zugangspunkt
const char Access_Point1[] PROGMEM = "WLAN-Name_1";
// Passwort des Zugangspunktes Nr. 1
const char AP_Passwort_1[] PROGMEM = "WLAN-Passwort_1";

// Zugangspunkt Nr. 2 Daten
const char Access_Point2[] PROGMEM = "WLAN-Name_2";
// Passwort des Zugangspunktes Nr. 2
const char AP_Passwort_2[] PROGMEM = "WLAN-Passwort_2";

Einstellung Webserver

Danach ist noch der Webserver und das beelogger_log.php -Skript mit Accountname und ‘beelogger-Nummer’ passend zu der Anzahl der Waagen, siehe “Anzahl_Sensoren_Gewicht”, sowie das Passwort für die beelogger_log.php einzutragen.

// Domainname zum Webserver mit beelogger-Skript
// Länge maximal 30 Zeichen
const char serverName[] PROGMEM = "community.beelogger.de";

// GET mit Verzeichnis auf dem Webserver und PHP-Skript für den jeweiligen beelogger
// Mit Anzahl_Sensoren_Gewicht
// 1 - Bsp: "GET /USERX/beeloggerY/beelogger_log.php?"
// 2 - Bsp: "GET /USERX/DuoY/beelogger_log.php?"
// 3 - Bsp: "GET /USERX/TripleY/beelogger_log.php?"
// 4 - Bsp: "GET /USERX/QuadY/beelogger_log.php?"
const char beelogger_pfad[] PROGMEM = {"GET /USERX/SystemY/beelogger_log.php?"}; // "USERX" und "SystemY" ersetzen

// Passwort vom Webserver-Skript
const char Passwort[] PROGMEM = {"Log"}; // hier dein beelogger-log - Passwort

Beispiel: const char beelogger_pfad[] PROGMEM = {“GET /Accountname/beelogger1/beelogger_log.php?”};

beelogger-STM32 Sketch Paket

 ‘beelogger-STM32’ unterstützt alle Sensoren. Es können Systeme mit bis zu vier Waagen an einem beelogger aufgebaut werden.

Kalibrierwerte eines Systems ( ADC / Waage) und andere Konfigurationsdaten können aus bisher verwendeten Daten übernommen werden.
Neukalibrierung ist erforderlich für:
– Waage: bei Tausch einer Wägezelle oder HX711
– ADC-Kalibrierung: bei Austausch des STM32Fxyz- Modul bzw. Tausch der beelogger-Platine

Version Release Notes

  beelogger_STM32 

– Sketch Paket beelogger_STM32_2024-01
   Hinweis:  Benötigt aktuelle beelogger-Arduino-Libs
   

   In der Arduino IDE über den Boardverwalter
  das Paket “STM32 MCU based boards”  Version 2.6.0 installieren/aktualisieren.

   30.01.2024 – Kal-ADC-Sketch mit preset backup RAM, Plausibiltätsprüfung DHT Messwert, CPU-Sensor Temperatur immer auslesen
   15.11.2023 – LTE/GSM/WLAN-Sketche mit erweiterter EE-Prom Nutzung (64kB,128kB)
   08.10.2023 – LORA Frame Counter in Backup-Ram
   02.10.2023 – Update, Wakeup, wenn keine Sensoren konfiguriert
   27.09.2023 – Update der Funktionalität  nicht Senden während Nachststunden / “DO_NOT_SEND_AT_NIGHT”.

   01.09.2023 – überarbeitete Sketche mit neuen/aktuellen Lib-Versionen der
                       STM32RTC (1.3.7) und STM32LowPower (1.2.4)

                       Achtung: Die neuen Lib-Versionen müssen manuell
                       eingepflegt werden, sie sind nicht im Lib-Paket enthalten.

                       Sketch-Paket enthält auch die Sketche 20230711,
                       welche mit den alten Lib-Versionen (1.1.0) arbeiten.

   10.07.2023 – Handling Arbeitsschalter in LORA-Sketch
   10.05.2023 – Speichermanagement für Systeme mit Niederschlagsmesser;
                       SystemCheck: Ergänzung Abfrage ESP8266/SIM7600E
   09.05.2023 – Weckintervallsteuerung für Batterie leer
   21.04.2023 – BME280, SHT31 beelogger-Libs

   06.04.2023 – LTE-Sketch SSL und TCP Version
   04.03.2023 – STM32F401CE ergänzt
   18.02.2023 – HX711 Fehlerbehandlung
   28.01.2023 – DHT-Lib geändert
   18.01.2023 – DS18B20 negative Temperaturen
   22.12.2022 – Code für DHT-bugfix als Option, CPU-Sensoren angepasst
   09.12.2022 – konfigurierbare Option: Signalpegel messen und senden mit Arbeitsschalter forcieren
   12.11.2022 – Niederschlagsensor Test/Kal.
   07.11.2022 – bis zu 8 DS18B20
   25.07.2022 – LTE-Test-Sketch
   13.07.2022 – Arbeitsschalter dauerhaft gesetzt wird ignoriert
   10.07.2022 – LTE/WLAN Test Sketch
   01.07.2022 – SystemCheck
   24.06.2022 – HX711 Nr.2 pins
   22.06.2022 – SI7021 value Check
   13.06.2022 – backup-ram
   11.06.2022 – Scharmalarm, Messzklussteuerung
   08.06.2022 – LORA, save SeqInfo in EEProm updated
   04.06.2022 – Scharmalarm Erkennung
   15.04.2022 – 5-Min Intervall
   08.04.2022 – SystemCheck BME/BMP Typ-Erkennung
   28.03.2022 – LORA mit optimierter Payload / payload-formatter
   17.03.2022 – Regensensor, Bienenzähler u.v.m.)
   11.03.2022 – System_Check, Regensensor(Erprobung)
   07.03.2022 – Typos
   28.02.2022 – Controller Flags
   18.02.2022 – System Init & WakeUp update
   02.01.2022 – EE-Prom error handling update
   24.12.2021 – Blinkcode Auswertung Arbeitsschalter 
 
   Erläuterungen zu den enthaltenen Testsketchen hier

Hier eine Sonderversion als Anregung für besondere Gegebenheiten und Entwicklung weiterer Ideen und Sketche durch die community.

Version Release Notes

 beelogger_STM32-

 LTE-/WLAN-Kombi 

– Sketch beelogger_STM32_WLAN&LTE
  Hinweis:  Benötigt aktuelle beelogger-Arduino-Libs
     

    02.10./28.09.2023 – Sketch für beelogger-STM32 mit WLAN- und LTE- Modul mit automatischer Umschaltung auf
                        LTE-Betrieb, wenn WLAN bzw. ESP8266 nicht verfügbar.
                        notwendige Änderungen an der beelogger-Hardware:
                         Einschalten Transistor des MOSFET für SIM7600E von PIN PB3 (statt PB4, PB4 aktiviert ESP8266) 
                         RX/TX SIM7600E-Modul von PB14/PB15 (statt PA2/PA3, beide verwendet für ESP8266)

 

Erläuterung Sketch Debug-Ausgabe Statusinformation hier.

Blinkcode LED an D13:

    • 1x lang:           -> Einschalten des Arbeitsschalter erkannt
      • löst Messvorgang aus

        Wenn Arbeitsschalter weitere 3 Sekunden aktiv:

      • 4x kurz     -> Sendevorgang wird ausgelöst, Messwert Service wird auf “99” gesetzt.
      •      Wenn Arbeitsschalter dauerhaft eingeschaltet wird im voreingestellten Zyklus “USER_INT_TM” gemessen und gesendet.
      •      Wird der Arbeitsschalter, auch während des Sendevorgangs, ausgeschaltet, wird der normale Messzyklus fortgesetzt.
         
    • 2x kurz    -> System geht in Schlafzustand (wird nur bei aktiver Debugeinstellung angezeigt)
          Nur in diesem Zustand wird das Einschalten des Arbeitsschalter erkannt.

Testprogramme:

System-Check und Testprogramm zur Sensorkonfiguration:

Vor weiteren Schritten im Aufbau und Kalibrierung wird empfohlen zu testen, welche Komponenten und Sensoren im System aktiv sind.
Dazu haben wir ein kleines Testprogramm erstellt, welches

– eine Auflistung aller DS18B20 durchführt,
– die Belegung der I2C-Adressen anzeigt und testet,
– Typerkennung BME/BMP; BME680, BMP280 Test in config.h einstellbar
– den HX711 Nummer 1/2 im System testet,
– die DHT 22 testet,
– den beelogger nach dem Systemtest in den Sleep-Mode versetzt,
– und, wenn konfiguriert:
    – nach den Tests die Stromversorgung für die Sensoren/Module eingeschaltet lässt,

#define _BMP280_    0                // 0 = ohne, 1= mit BMP280
#define _BME280_    0                // 0 = ohne, 1= mit BME280
#define _BME680_    1                // 0 = ohne, 1= mit BME680
#define DBG_MEM_INFO      0      // Memory usage info
#define Power_off_at_End   1      // 1 = aus (=LowPower), 0= Power an
#define Allow_WakeUp_Switch 0  // 0 / 1 = aktiviere Wakup mit Arbeitsschalter

Hinweis: Nach dem Test den Akku vom beelogger trennen.
LORA-Systeme können den Sketch zum Setzen der Systemzeit verwenden, in diesem Fall nicht vom Akku trennen.

 

ADC-Kalibrierung-Programmcode für beelogger

Da die Akkuspannung für eine Software-Funktion zum Akku-Schutz verwendet wird, ist die Kalibrierung zwingend notwendig, damit der Test- und Haupt-Programmcode lauffähig ist.
Alle elektronischen Komponenten des beeloggers mit seinen Spannungsreglern, Widerständen und dem STM32 unterliegen fertigungsbedingten Toleranzen. Um diese Toleranzen bei der Messung der Spannung von Akku und Solarzelle möglichst gut zu kompensieren, muss diese Kalibrierung für jeden beelogger durchgeführt werden.
Ein Wechsel des Akku erfordert keine neue Kalibrierung.
Der Spannungsteiler bestehend aus 1MOhm und 470kOhm wird mit diesem Sketch kalibriert.

Für die Ermittlung der Solarspannung werden die gleichen Werte zur Berechnung verwendet, da diese Messung ohnehin nur eine Momentaufnahme darstellt und auch keine weiteren Auswirkungen auf den Programmablauf hat.

Bevor der Kalibrierung-Programmcode aufgespielt wird, muss die Spannung des Akkus in Millivolt in der Variable ‘Kalib_Spannung’ hinterlegt werden. 

Der Akku muss für diese Messung gut geladen sein.
Der Wert für die Variable ‘Kalib_Spannung’ sollte mit einem möglichst hochwertigen Multimeter erfasst werden.
Gemessen wird die Spannung des Akkus am Akkuhalter der beelogger Platine und im Sketch in Millivolt eingetragen werden.

int Kalib_Spannung = 0; //Hier ist der mit Multimeter gemessene Wert der Akkuspannung in Millivolt einzutragen

Der Wert der Variable ‘Kalib_Bitwert’ wird über den Kalibrier-Programmcode ermittelt. Dieser Wert gibt die mit allen Toleranzen gemessene Akku-Spannung durch den beelogger wieder. Liegt der ‘Kalib_Bitwert’ außerhalb des erlaubten Bereichs wird eine Fehlermeldung angezeigt.

Optional: Test serielle Verbindung zum SIM800, SIM7600 oder ESP8266

Mit diesem Testprogramm kann bei Bedarf die serielle Verbindung zwischen dem STM32Fxyz und dem SIM800,SIM7600 bzw. ESP8266 Anschluss geprüft werden. Eingaben über den Arduino-Monitor werden bei intaktem System dorthin zurück übertragen.
Im Arduino-Monitor im Feld unten die Einstellung “Sowohl NL als auch CR” auswählen.

Mit ausgebauten SIM800/SIM7600/ESP8266-Modul ist eine Brücke zwischen RX und TX auf der Platine herzustellen.
Im Eingabefeld übermittelte Daten werden mit “Empfangen:” … ausgegeben.

Bei gestecktem ESP8266/SIM800l/SIM7600E-Modul sind Abfragen wie “AT” (Antwort “OK”) oder “AT+GMR” (Antwort “Firmwareversion”) möglich.

Mit aufgestecktem SIM800L und eingesteckter SIM-Karte muss folgende Ausgabe erfolgen:
Die Ausgabe bei einem SIM7600E ist ähnlich.

Empfangen:
RDY
+CFUN: 1
Empfangen:
+CPIN: READY
Empfangen:
Call Ready
Empfangen:
SMS Ready

Mit aufgestecktem ESP8266 muss folgende Ausgabe erfolgen:
Die letzte Zeile “ready” ist entscheidend.

Empfangen:
W2H⸮XF
jEJd⸮M
ready

Hinweis: Nach dem Test den Akku vom beelogger trennen.