Code: Alles auswählen
/*
Abfrage von analogen Werten mit dem ESP32
am ADS1115 mit Weitergabe per I2C an den I2C - FRAM,
wenn die Spannung deutlich abweicht vom letzten Messwert.
Taste zum Übertragen auf den PC, Taste zum Löschen, bei 32000 byte ist Schluss.
Schalter für Hohe Schwelle, Autmatische Schwelle, Niedrige Schwelle.
Anzeige im OLED angepasst 06.02.2026
Logeintrag bei Automatischer Schwellen Änderung.
Logeinträge beim Übertrag zum PC auch ausgeben.
Die Hysterese ist jetzt deutlich verbessert. Sie geht jetzt nach +/- 50mV Stufen
Umstieg auf Nextion Display Oled Programmteile entfernt !!
Programm im Moment vom 31.03.2026 / ADC_ADS1115_NodeMCU_ESP32_Nextion_FRAM_2x4Byte_V72
*/
#include <WiFi.h>
//#define NTP_SERVER "de.pool.ntp.org"
#define NTP_SERVER "Fritz.Box"
#define TZ_INFO "WEST-1DWEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00" // Western European Time
//--------------------------------------------------------------------------------------------
#include <Adafruit_ADS1X15.h> // bindet Wire.h für I2C mit ein
Adafruit_ADS1115 ads;
#define ADS_I2C_ADDR 0x48
//-----------------------------FRAM-----------------------------------------------------------
#include "Adafruit_EEPROM_I2C.h"
#include "Adafruit_FRAM_I2C.h"
Adafruit_FRAM_I2C i2ceeprom;
#define EEPROM_ADDR 0x50 // the default address!
//--------------------------Serial für Nextion Display----------------------------------------
HardwareSerial Nextion(2);
byte NexT[3] = { 255, 255, 255 }; // global deklarieren
/*
Wird dann so benutzt:
Serial2.write(NexT, 3);
*/
const byte bufferSize = 64;
int Abfragezaehler = 0;
byte PW = 0;
byte PC = 0;
byte KF = 0;
byte ME = 0;
byte MeIO = 0;
byte Seite = 0; // Nextion Startseite einstellen
//------------------------ADS1115 16Bit Analog-Digital Sensor---------------------------------
const float multiplier = 0.125F; // ADS1115-Multiplikator bei einf. Verstärkung
int A_Value; // Messwert per GPIO
int adc0; // Messwert an Kanal 0 des ADS1115
int adc1; // Messwert an Kanal 1 des ADS1115
int adc2; // Messwert an Kanal 2 des ADS1115
int adc3; // Messwert an Kanal 3 des ADS1115
float A_mv, ads_mv0, ads_mv1; // Messwert in Millivolt umgerechnet
//--------------------------------------------------------------------------------------------
//----------------------- Spannungsmessungen Speichern ---------------------------------------
int Spannungneu = 0;
int Spannung2neu = 0;
int Spannung2alt = 0;
byte Batterie = 1;
float Messung = 0;
float f = 0;
int Hysterese = 50; // Steht für 50mV rauf oder runter
int Hysterese2 = 0;
const int Hysteresemax = 1000;
const int Hysteresemin = 50;
//------------------ Zeitdaten FRAM ----------------------------------------
uint8_t buffer[4]; // floats are 4 bytes!
int Zeitbuffer = 0;
int Speicher = 4;
int Speicher2 = 0;
int Zaehler = 0;
int i = 0;
int UebertragZeiger = 4;
byte DzPja = 0;
int Ausgabezaehler = 0;
int Kontrollzaehler = 0;
byte Reagieren = 0;
int LogZeiger = 32200;
int LogZeiger2 = 32204;
int Uebertragmerker = 0;
//--------------------Tonausgabe PIN 27---------------------------------
const byte TonPin = 27;
const int frequenz = 1000;
unsigned long tonZeit = 100;
//------------------------- Minutentakt zur Zeit - Ausgabe -----------------------------------
unsigned long Sekundenablauf01 = 0; // Zeit für die Ausgabe Aufs Display & Serial
const unsigned long Pausezeit01 = 60000;
unsigned long Zeitablauf = 0;
//------------------------ PLatzverbrauch am FRAM pro 60sec. ---------------------------------
unsigned long Sekundenablauf02 = 0; // Zeit für die Ausgabe Aufs Display & Serial
const unsigned long Pausezeit02 = 60000;
//------------------------ PLatzverbrauch am FRAM pro 1 Std ----------------------------------
unsigned long Sekundenablauf03 = 0; // Zeit für die Ausgabe Aufs Display & Serial
const unsigned long Pausezeit03 = (60000 * 60);
//-------------------------------- Zeit Messungen --------------------------------------------
unsigned long Messungstart = 0;
unsigned long Messungende = 0;
unsigned long Laufzeit = 0;
//############################################################################################
// ----------------------------------------------------SETUP----------------------------------
//############################################################################################
void setup() {
Serial.begin(115200);
delay(500);
Nextion.begin(9600, SERIAL_8N1, 16, 17);
Serial.println("Analog-Spannungsueberwachung mit ESP32");
//-----------------------------------------------------------
Serial.println(F("NTP Server Abfrage"));
NTP_Zeit();
// -------------------FRAM Ereichbar ??----------------------
if (i2ceeprom.begin(0x50)) { // Sie können die neue I2C-Adresse hier einfügen, z. B. begin(0x51);
Serial.println(F("I2C FRAM gefunden"));
} else {
Serial.println(F("I2C-FRAM nicht identifiziert ... überprüfen Sie Ihre Verbindungen.?\r\n"));
while (1) delay(10);
}
//-----------------------ADS 1115---------------------------
ads.begin(ADS_I2C_ADDR, &Wire);
// Werte 1-fach verstärken (ESP32 liefert max. 3,3V)
ads.setGain(GAIN_ONE);
//------- Erste Displayausgabe gleich nach dem Start -------
Sekundenablauf01 = 50000;
// Wichtige Startdaten aus dem FRAM holen
Startdaten_holen();
Messen();
Serial.println("Messungen Starten");
Nextion.print("page 0");
Nextion.write(NexT, 3);
Nextion.print("Startseite.Meldungen.txt=\"Messungen wurden gestartet\"");
Nextion.write(NexT, 3);
Nextion.print("Startseite.MessungStart.txt=\"Messungen Stopp\"");
Nextion.write(NexT, 3);
MeIO = 1;
}
//############################################################################################
// ----------------------------------------------------LOOP-----------------------------------
//############################################################################################
void loop() {
Messungstart = millis();
Zeitablauf = millis();
ESPzuNEXT();
NEXTzuESP();
//-- Wenn der FRAM nicht voll und Betriebsspannung gut --
if ((Reagieren < 2) && (Batterie == 1) && (MeIO == 1)) {
if (Zeitablauf - Sekundenablauf01 >= Pausezeit01) { // Eine Minute abgelaufen?
Displayausgabe();
Sekundenablauf01 = millis();
}
Kontrollen();
Messen();
if (Reagieren == 1) {
SpeicherdatenSchreiben();
Spannung2alt = Spannung2neu;
tone(TonPin, 1000, 100); // Piep wenn sich die Spannung ändert.
Reagieren = 0;
// Diese beiden Zeilen unten, werden nur gebraucht,
// wenn eine Ausgabe auf dem PC, nach Speicherung
// eines Datensatzes, benötigt wird !!
SpeicherdatenLesen();
testprint();
}
}
//------------------------------------------------------
//
//--------------- Ist der FRAM voll ?? -----------------
if (Speicher >= 32000) {
Nextion.print("Startseite.Meldungen.txt=\"FRAM Speicher ist voll !!\"");
Nextion.write(NexT, 3);
tone(TonPin, 440, 1000);
Reagieren = 2;
}
} //---------------------------------- LOOP ENDE --------------------------------------------
//############################################################################################
//-------------------------- WIFI Verbindung und Zeit holen ----------------------------------
//############################################################################################
void NTP_Zeit() {
WiFi.mode(WIFI_STA);
WiFi.begin("FRITZ!Box Gastzugang", "GastvonFranzKoehler");
while (WiFi.status() != WL_CONNECTED) // Ist WLAN Connect?
{
delay(500);
}
struct tm local;
configTzTime(TZ_INFO, NTP_SERVER); // ESP32 Systemzeit mit NTP Synchronisieren
getLocalTime(&local, 10000); // Versuche 10 s zu Synchronisieren
WiFi.mode(WIFI_OFF);
}
//---------------------------WIFI Verbindung und Zeit Ende -----------------------------------
//
//############################################################################################
//---------------------------- Startdaten aus FRAM holen -------------------------------------
//############################################################################################
void Startdaten_holen() {
//------- Speicherzeiger auslesen (Protokoll)---------------
i2ceeprom.read(32100, buffer, 4);
memcpy((void *)&Speicher, buffer, 4);
//--------Letzten Messwert auslesen (Protokoll)-------------
i2ceeprom.read(32104, buffer, 4);
memcpy((void *)&f, buffer, 4);
//--------Letzte Zeit auslesen (Protokoll)------------------
i2ceeprom.read(32108, buffer, 4);
memcpy((void *)&Zeitbuffer, buffer, 4);
time_t t = Zeitbuffer;
tm tm;
//--------Ausgabezähler auslesen (Protokoll)----------------
i2ceeprom.read(32112, buffer, 4);
memcpy((void *)&Zaehler, buffer, 4);
//------- Logzeiger auslesen (Protokoll)--------------------
i2ceeprom.read(32200, buffer, 4);
memcpy((void *)&LogZeiger, buffer, 4);
//------- Logzeiger1 Eintragen wenn nötig ------------------
if (LogZeiger < 32204) {
LogZeiger = 32204;
memcpy(buffer, (void *)&LogZeiger, 4);
i2ceeprom.write(32200, buffer, 4);
}
Serial.print(F("Aktueller Protokoll Ablagezeiger = "));
Serial.println(LogZeiger);
//--------Prokolldaten Ausgeben-----------------------------
if (Speicher <= 4) {
Speicher = 4;
Serial.println(F("########################################"));
Serial.println(F("# Speicher gelöscht-> Startadresse = 4 #"));
Serial.println(F("########################################"));
} else {
testprint();
}
}
//-------------------------------- Startdaten holen Ende -------------------------------------
//
//############################################################################################
//---------------------------------- Displayausgabe ------------------------------------------
//############################################################################################
void Displayausgabe() {
tm local;
getLocalTime(&local);
// ------------------------Ausgabe aufs Nesxtion Display------------------------------------
Nextion.printf("Startseite.Datum.txt=\"");
Nextion.print(&local, "%d.%m.%y");
Nextion.write('"');
Nextion.write(NexT, 3);
//
Nextion.printf("Startseite.Zeit.txt=\"");
Nextion.print(&local, "%H:%M");
Nextion.write('"');
Nextion.write(NexT, 3);
//
Nextion.printf("Startseite.Hysterese.val=");
Nextion.print(Hysterese);
Nextion.write(NexT, 3);
}
//--------------------------------------------------------------------------------------------
//############################################################################################
// ------------------------------------ Messung per ADS1115 ----------------------------------
//############################################################################################
void Messen() {
// - Kanal 0 messen (single-ended)
adc0 = ads.readADC_SingleEnded(0);
ads_mv0 = ads.computeVolts(adc0);
// - Kanal 1 messen (single-ended)
adc1 = ads.readADC_SingleEnded(1);
ads_mv1 = ads.computeVolts(adc1);
//===============================================
ads_mv0 = ads_mv0 * 11;
Spannung2neu = ads_mv0 * 1000;
if ((Spannung2alt + Hysterese < Spannung2neu) || (Spannung2alt - Hysterese > Spannung2neu)) {
Reagieren = 1;
}
// Veränderte Spannung anzeigen
Spannungneu = ads_mv0 * 100;
if (Spannung2alt == Spannungneu) {
} else {
if (Batterie == 1) {
}
}
}
// ------------------------------- Messen Ende ---------------------------------------------
//##########################################################################################
//------------------------------ FRAM Schreiben --------------------------------------------
//##########################################################################################
void SpeicherdatenSchreiben() {
Speicher = Speicher + 4;
Zaehler = Zaehler + 1;
Kontrollzaehler = Kontrollzaehler + 1;
// Messwert Schreiben---------------------------------------------------------------------
f = ads_mv0;
Messung = ads_mv0;
memcpy(buffer, (void *)&f, 4);
i2ceeprom.write(Speicher, buffer, 4);
// Letzen Messwert schreiben (Protokoll)--------------------------------------------------
memcpy(buffer, (void *)&f, 4);
i2ceeprom.write(32104, buffer, 4);
// Zeit & Datum Schreiben-----------------------------------------------------------------
time_t now;
time(&now);
Speicher = Speicher + 4;
memcpy(buffer, (void *)&now, 4);
i2ceeprom.write(Speicher, buffer, 4);
// Zeit vom letzten Messwert Schreiben (Protokoll)----------------------------------------
memcpy(buffer, (void *)&now, 4);
i2ceeprom.write(32108, buffer, 4);
// Speicherzeiger im FRAM schreiben auf 32100 sichern (Protokoll)-------------------------
memcpy(buffer, (void *)&Speicher, 4);
i2ceeprom.write(32100, buffer, 4);
// Zähler von letzten Eintrag schreiben (Protokoll)---------------------------------------
memcpy(buffer, (void *)&Zaehler, 4);
i2ceeprom.write(32112, buffer, 4);
//---------------- Letzte Messung aufs Display -------------------------------------------
}
//------------------------------ Schreiben Ende --------------------------------------------
//
//##########################################################################################
//------------------------------ FRAM Auslesen ---------------------------------------------
//##########################################################################################
void SpeicherdatenLesen() {
// Messwert auslesen----------------------------------------------------------------------
Speicher2 = Speicher - 4;
i2ceeprom.read(Speicher2, buffer, 4);
memcpy((void *)&f, buffer, 4);
// Zeit / Datum auslesen------------------------------------------------------------------
Speicher2 = Speicher;
i2ceeprom.read(Speicher2, buffer, 4);
memcpy((void *)&Zeitbuffer, buffer, 4);
}
//------------------------------ Auslesen Ende --------------------------------------------
//
//#########################################################################################
//-------------------------- Automatik Logs im FRAM ---------------------------------------
//#########################################################################################
void AutoLogschreiben() {
//------- Logzeiger auslesen (Protokoll)-------------------------------------------------
i2ceeprom.read(32200, buffer, 4);
memcpy((void *)&LogZeiger2, buffer, 4);
//------- Ist im FRAM noch Platz für Logeinträge ?? -------------------------------------
if (LogZeiger2 <= 32690) {
//------- Schwelle schreiben ----------------------------------------------------------
memcpy(buffer, (void *)&Hysterese, 4);
i2ceeprom.write(LogZeiger2, buffer, 4);
// Log - Zeit & Datum Schreiben--------------------------------------------------------
time_t now;
time(&now);
LogZeiger2 = LogZeiger2 + 4;
memcpy(buffer, (void *)&now, 4);
i2ceeprom.write(LogZeiger2, buffer, 4);
//Neuen Logzeiger in FRAM schreiben ----------------------------------------------------
LogZeiger2 = LogZeiger2 + 4;
memcpy(buffer, (void *)&LogZeiger2, 4);
i2ceeprom.write(32200, buffer, 4);
//Serial.println(LogZeiger2);
}
}
//--------------------------- Automatik Logs Ende ------------------------------------------
//
//##########################################################################################
//-------------------------- FRAM zum PC Übertragen ----------------------------------------
//##########################################################################################
void DatenzumPC() {
// Messwert auslesen----------------------------------------------------------------------
Serial.println(F("########################################"));
Serial.println(F("### Messprotokoll Übertragung Start ###"));
Ausgabezaehler = 0;
UebertragZeiger = 8;
for (int i = UebertragZeiger; i <= Speicher; i = i + 4) {
i2ceeprom.read(i, buffer, 4);
memcpy((void *)&f, buffer, 4);
// Zeit / Datum auslesen----------------------------------------------------------------
i = i + 4;
i2ceeprom.read(i, buffer, 4);
memcpy((void *)&Zeitbuffer, buffer, 4);
time_t t = Zeitbuffer;
tm tm;
localtime_r(&t, &tm);
tm.tm_year += 1900;
tm.tm_mon += 1;
Ausgabezaehler++;
Serial.print(f, 4);
Serial.print(F(";"));
Serial.print(tm.tm_mday);
Serial.print(F("."));
Serial.print(tm.tm_mon);
Serial.print(F("."));
Serial.print(tm.tm_year);
Serial.print(F(";"));
Serial.print(tm.tm_hour);
Serial.print(F(":"));
Serial.print(tm.tm_min);
Serial.print(F(":"));
Serial.print(tm.tm_sec);
Serial.print(";");
Serial.println(Ausgabezaehler);
}
Serial.println(F("### Messprotokoll Übertragung Ende ###"));
Serial.println(F("########################################"));
Uebertragmerker = 0;
//------- Logzeiger auslesen (Protokoll)--------------------
Serial.println(F("### Messchwellen - Protokoll Ausgabe ###"));
i2ceeprom.read(32200, buffer, 4);
memcpy((void *)&LogZeiger, buffer, 4);
if (LogZeiger >= 32204) {
Ausgabezaehler = 0;
UebertragZeiger = 32204;
for (int i = UebertragZeiger; i < LogZeiger; i = i + 4) {
i2ceeprom.read(i, buffer, 4);
memcpy((void *)&Hysterese2, buffer, 4);
// Zeit / Datum auslesen---------------------------------------------------------------
i = i + 4;
i2ceeprom.read(i, buffer, 4);
memcpy((void *)&Zeitbuffer, buffer, 4);
time_t t = Zeitbuffer;
tm tm;
localtime_r(&t, &tm);
tm.tm_year += 1900;
tm.tm_mon += 1;
Ausgabezaehler++;
Serial.print(Hysterese2);
Serial.print(F(";"));
Serial.print(tm.tm_mday);
Serial.print(F("."));
Serial.print(tm.tm_mon);
Serial.print(F("."));
Serial.print(tm.tm_year);
Serial.print(F(";"));
Serial.print(tm.tm_hour);
Serial.print(F(":"));
Serial.print(tm.tm_min);
Serial.print(F(":"));
Serial.print(tm.tm_sec);
Serial.print(";");
Serial.println(Ausgabezaehler);
}
}
Serial.println(F("# Messchwelle Protokoll - Ausgabe Ende #"));
Serial.println(F("########################################"));
}
//------------------------------ Auslesen Ende ---------------------------------------------
//##########################################################################################
//-------------------------------- Testprint -----------------------------------------------
//##########################################################################################
void testprint() {
time_t t = Zeitbuffer;
tm tm;
localtime_r(&t, &tm);
tm.tm_year += 1900;
tm.tm_mon;
/*
Serial.print(f, 4);
Serial.print(F(" Volt ->"));
Serial.print(&tm, " Datum: %d.%m.%y");
Serial.print(&tm, " Zeit: %H:%M:%S");
Serial.print(F(" ADR = "));
Serial.print(Speicher);
Serial.print(F(" # "));
Serial.println(Zaehler);
*/
Nextion.print("Startseite.LGM.txt=\"");
Nextion.print(f, 2);
Nextion.print(F(" V"));
Nextion.print(&tm, " am %d.%m.%y");
Nextion.print(&tm, " um %H:%M:%S");
Nextion.print(" # ");
Nextion.print(Zaehler);
Nextion.write('"');
Nextion.write(NexT, 3);
//
Nextion.print("Startseite.Datum.txt=\"");
Nextion.print(&tm, "%d.%m.%y");
Nextion.write('"');
Nextion.write(NexT, 3);
//
Nextion.printf("Startseite.Zeit.txt=\"");
Nextion.print(&tm, "%H:%M");
Nextion.write('"');
Nextion.write(NexT, 3);
//
Nextion.printf("Startseite.Hysterese.val=");
Nextion.print(Hysterese);
Nextion.write(NexT, 3);
}
//-------------------------------- Testprint Ende ------------------------------------------
//
//##########################################################################################
//--------------------------------- FRAM löschem -------------------------------------------
//##########################################################################################
void FRAM_Loeschen() {
Serial.println(F("########################################"));
Serial.print(F("# FRAM wird gelöscht "));
for (i = 0; i <= 32700; i = i + 4) {
f = 0;
memcpy(buffer, (void *)&f, 4);
i2ceeprom.write(i, buffer, 4);
}
//------- Speicherzeiger auf Start---------------
// Speicherzeiger = 4 im FRAM auf 32100 sichern
Speicher = 4;
memcpy(buffer, (void *)&Speicher, 4);
i2ceeprom.write(32100, buffer, 4);
Kontrollzaehler = 0;
Zaehler = 0;
Serial.println(F("FRAM IST gelöscht #"));
Serial.println(F("########################################"));
Nextion.print("Startseite.Meldungen.txt=\"FRAM ist geloescht\"");
Nextion.write(NexT, 3);
//------ Lockfile Zeiger auf Start 32204 setzen --
//Neuen Logzeiger in FRAM schreiben -------------------------------------------------------
LogZeiger2 = 32204;
memcpy(buffer, (void *)&LogZeiger2, 4);
i2ceeprom.write(32200, buffer, 4);
//Serial.println(LogZeiger2);
}
//##########################################################################################
//-------------------------- Wichtige Kontrollen -------------------------------------------
//##########################################################################################
void Kontrollen() {
// Prüfen ob die Schwelle zu niedrig ist
if (Zeitablauf - Sekundenablauf02 >= Pausezeit02) { // FRAM Aufzeichungen pro 60sek. messen
if ((Kontrollzaehler > 3) && (Hysterese < Hysteresemax)) {
Hysterese = Hysterese + 50;
Nextion.printf("Startseite.Hysterese.val=");
Nextion.print(Hysterese);
Nextion.write(NexT, 3);
//Serial.print(F("##### Hysterese Automatisch auf -> "));
//Serial.print(Hysterese);
//Serial.println(F(" mVolt erhöht #######"));
Kontrollzaehler = 0;
AutoLogschreiben();
}
Sekundenablauf02 = millis();
Kontrollzaehler = 0;
}
// Prüfen ob die Schwelle wiede abgesenkt werden kann
if (Zeitablauf - Sekundenablauf03 >= Pausezeit03) { // FRAM Aufzeichungen pro Stunde messen
if ((Kontrollzaehler < 2) && (Hysterese > Hysteresemin)) {
Hysterese = Hysterese - 50;
Nextion.printf("Startseite.Hysterese.val=");
Nextion.print(Hysterese);
Nextion.write(NexT, 3);
//Serial.print(F("###### Hysterese Automatisch auf -> "));
//Serial.print(Hysterese);
//Serial.println(F(" mVolt runtergesetz ######"));
Kontrollzaehler = 0;
AutoLogschreiben();
}
Sekundenablauf03 = millis();
Kontrollzaehler = 0;
}
// Prüfen, ob Betriebsspannung des Gerätes zu niedrig
if (ads_mv1 <= 3) {
Batterie = 0;
} else {
Batterie = 1;
}
// Prüfen ob die Zeit wieder vom Server geholt werden muss.
tm local;
//00:00:XX = 3600(=1 Std) * std = 0 + min = 0 * 60 = 0 + sec = maximal 59 sec
uint32_t nbSek = 3600ul * local.tm_hour + local.tm_min * 60ul + local.tm_sec;
if (nbSek <= 2) // zwischen 00:00:00 Uhr und 00:00:59 Uhr Zeit vom NTP holen
{
NTP_Zeit();
}
}
//------------------------------- Kontrollen Ende -----------------------------------------
//#########################################################################################
//########################## Kommunikation mit dem Nextion ################################
//#########################################################################################
//
void ESPzuNEXT() {
Nextion.print("dim=50"); // Display wird etwas gedimmt
Nextion.write(NexT, 3);
if (Seite != 0) {
Nextion.print("page 0"); // Ausgabe Seite ist "page 0"
Nextion.write(NexT, 3);
Seite = 0;
}
Nextion.print("Startseite.Byte.val=");
Nextion.print(Speicher);
Nextion.write(NexT, 3);
Nextion.printf("Startseite.Volt2.txt=\"%5.3f\"", ads_mv0);
Nextion.write(NexT, 3);
}
//######################################################################################
//########################### Rückmeldung vom Nextion auswerten ########################
//######################################################################################
//
void NEXTzuESP() {
static uint8_t bIndex;
static uint8_t buffer[bufferSize];
if (Nextion.available()) {
if (Abfragezaehler == 0) {
delay(300);
}
uint8_t inChar = Nextion.read();
buffer[bIndex++] = inChar;
if ((buffer[0] == 101) || (buffer[0] == 80) || (buffer[0] == 35) || (buffer[0] == 26) || (buffer[0] == 45) || (buffer[0] == 43)) {
Abfragezaehler = 0;
}
Serial.print(Abfragezaehler);
Serial.print(" Buffer = ");
Serial.println(buffer[0]);
//----------------------------------- Menüseite wurde aufgerufen -------------
if ((Abfragezaehler == 0) && (buffer[0] == 35)) { // page 0 Start
Serial.println(F("Seite Null wurde aufgerufen"));
if (MeIO == 1) {
Nextion.print("Startseite.MessungStart.txt=\"Messungen Stopp\"");
Nextion.write(NexT, 3);
}
}
// -------------------------------- Hysterese + Abfragen ---------------------
if ((Abfragezaehler == 0) && (buffer[0] == 43)) { // Hysterese plus ?
if (Hysterese < Hysteresemax) {
Hysterese = Hysterese + 50;
Nextion.printf("Startseite.Hysterese.val=");
Nextion.print(Hysterese);
Nextion.write(NexT, 3);
}
}
// -------------------------------- Hysterese - Abfragen ---------------------
if ((Abfragezaehler == 0) && (buffer[0] == 45)) { // Hysterese minus ?
if (Hysterese > Hysteresemin) {
Hysterese = Hysterese - 50;
Nextion.printf("Startseite.Hysterese.val=");
Nextion.print(Hysterese);
Nextion.write(NexT, 3);
}
}
// -----------------------------FRAM löschen Taste + PW Abfrage --------------
if ((Abfragezaehler == 0) && (buffer[0] == 80)) { // P? für Passwort
PW = PW + 1;
}
if ((Abfragezaehler == 1) && (buffer[0] == 51)) { // 3?
PW = PW + 1;
}
if ((Abfragezaehler == 2) && (buffer[0] == 54)) { // 6?
PW = PW + 1;
}
if ((Abfragezaehler == 3) && (buffer[0] == 57)) { // 9?
PW = PW + 1;
}
if ((Abfragezaehler == 4) && (buffer[0] == 57)) { // 9?
PW = PW + 1;
}
if ((Abfragezaehler == 4) && (PW == 5)) {
Serial.println("Passwort ist korrekt");
Nextion.printf("PasswortAW.t0.txt=\"\""); // Passwort löschen
Nextion.write(NexT, 3);
Nextion.print("page 0");
Nextion.write(NexT, 3);
Nextion.print("Startseite.Meldungen.txt=\"FRAM wird geloescht !!\"");
Nextion.write(NexT, 3);
PW = 0;
FRAM_Loeschen();
}
if ((Abfragezaehler == 4) && (PW < 5)) { // Ist es nicht die FRAM - löschne Taste
PW = 0;
}
//----------------------------------------------------------------------------
// --------------------------------------- Daten zum PC Abfrage --------------
if ((Abfragezaehler == 0) && (buffer[0] == 101)) { // Tasten Event ?
PC = PC + 1;
}
if ((Abfragezaehler == 2) && (buffer[0] == 3)) { // Daten zum PC ?
PC = PC + 1;
}
if ((Abfragezaehler == 7) && (buffer[0] == 50)) { // Taste 2 ?
PC = PC + 1;
}
if ((Abfragezaehler == 7) && (PC < 3)) { // Ist es nicht die Daten zum PC Taste
PC = 0;
}
if ((Abfragezaehler == 7) && (PC == 3)) {
PC = 0;
Serial.println("Daten zum PC übertragen");
Nextion.print("page 0");
Nextion.write(NexT, 3);
Nextion.print("Startseite.Meldungen.txt=\"Daten wurden zum PC uebertragen\"");
Nextion.write(NexT, 3);
DatenzumPC();
}
//----------------------------------------------------------------------------
// ----------------------------------------- Messungen Starten Abfrage -------
if ((Abfragezaehler == 0) && (buffer[0] == 101)) { // Tasten Event ?
ME = ME + 1;
}
if ((Abfragezaehler == 2) && (buffer[0] == 2)) { // Taste Messungen IO ?
ME = ME + 1;
}
if ((Abfragezaehler == 7) && (buffer[0] == 49)) { // Taste 1 ?
ME = ME + 1;
}
if ((Abfragezaehler == 7) && (ME < 3)) { // ist es nicht die ME - Taste
ME = 0;
}
if ((Abfragezaehler == 7) && (ME == 3) && (MeIO == 0)) {
ME = 0;
Serial.println("Messungen Starten");
Nextion.print("page 0");
Nextion.write(NexT, 3);
Nextion.print("Startseite.Meldungen.txt=\"Messungen wurden gestartet\"");
Nextion.write(NexT, 3);
Nextion.print("Startseite.MessungStart.txt=\"Messungen Stopp\"");
Nextion.write(NexT, 3);
MeIO = 1;
}
if ((Abfragezaehler == 7) && (ME == 3) && (MeIO == 1)) {
ME = 0;
Serial.println("Messungen Stoppen");
Nextion.print("page 0");
Nextion.write(NexT, 3);
Nextion.print("Startseite.Meldungen.txt=\"Messungen wurden gestoppt\"");
Nextion.write(NexT, 3);
Nextion.print("Startseite.MessungStart.txt=\"Messungen Start\"");
Nextion.write(NexT, 3);
MeIO = 0;
}
//-------------------- Kommunikations Fehler ESP32 -> Nextion --------------
if ((Abfragezaehler == 0) && (buffer[0] == 26)) { // Fehler ?
KF = KF + 1;
}
if ((Abfragezaehler == 3) && (buffer[0] == 255)) {
KF = KF + 1;
}
if ((Abfragezaehler == 3) && (KF == 2)) {
Serial.println("Kommunikations Fehler"); // Kommunikationsfehler ESP -> Next
KF = 0;
}
if ((Abfragezaehler == 3) && (KF < 2)) {
KF = 0;
}
}
//----------------------------------------------------------------------------
Abfragezaehler++;
bIndex = 0;
}
Franz