Langzeit Messgerät mit Protokollierung der Spannung bei Fehlerbedingten Spannungsänderungen

[Admin]

Wärend den Tests mit den FRAM Bausteinen bin ich jetzt auf ein Gerät gekommen das ich mir bauen möchte. Ein Gerät zum Aufzeichenen einer Spannungsversorgung über Stunden, Tage, Wochen. Ich habe in meiner Arbeitszeit oft ein Gerät vermisst, mit dem ich eine Versorgungsspannung für ein Gerät überwachen möchte, weil ich glaube es fällt manchmal aus, weil sein Netzteil manchmal kurzzeitig die Gretsche macht. Ein Gerät das über lange Zeit die Spannung überwacht, indem es jede Zentel Sekunde über sehr lange Zeiten im Speicher notiert, wenn die Kontrollierte Spannung sich verändert. Es notiert dann, sobald sich die Spannung verändert, die Spannung, die Uhrzeit und das Datum dess Vorfalles. Also immer, wenn sich die Spannung nach unten oder oben, auch nur geringfügig ändert, wird das genau festgehalten.

Ja, das mache ich mir jetzt als Messgerät für mich. Und bringe es dann natürlich hier auch wieder unter fertige Geräte, mit Schaltplan, Programm, Beschreibung und Bildern.

Hier ist mal das Bild der Schaltung wie ich es jetzt fürs erste mal zum Testen verwende. Das 10k Poti am A1 ist später der Messeingang. Im Moment kann ich über das Poti die Eingangsspannung für die Tests verändern. Mit dem Schalter möchte ich die Empfindlichkeit des Gerätes, also die Schwelle auf die das Gerät reagiert dann ändern können. Also im Moment schwebt mir vor, Stellung eins Spannungsänderung vor dem Komma, Stellung zwei, Spannungsänderung, erste Nachkommastelle, Stellung drei, Spannungsänderung, zweite Nachkommastelle. ISt aber alles noch nicht Fertig - Gedacht in der Birne.
.

Spannungsüberwachung mit FRAM.JPG (225.07 KiB) 1132 mal betrachtet

Testaubau_Langzeitmessung.jpg (343.59 KiB) 1131 mal betrachtet

Hier ist das Programm, das jetzt schon in diese Richtung geht, wo ich hin möchte. Da muss ich noch ein paar Dinge dazu schreiben, dann wird es brauchbar, für ein Gerät, das man mal da, mal da, ganz gut gebrauchen kann. Hier mal das Programm:

Code: Alles auswählen

/*
Langzeitmessungen mit ESP32 D1 Mini, I2C-ADS1115, I2C-OLED, I2C-FRAM 32KB.S
Version V2.1 vom 05.01.2026 
*/

Ich habe das Programm nochmal rausgenommen. Ich habe mich zu früh gefreut. Aber ich bleibe dran !!

}

Das Programm macht jetzt alle 18ms eine Messung. Wenn diese Messung sich mindestens an der zweiten Stelle hinterm Komma verändert, zeichnet es Datum, Uhrzeit, Spannung auf. Das sind 8 Byte. Also bei 32000 Byte 4000 Aufzeichungen, dann ist der Speicher voll. Wohlgemerkt nur, wenn sich die Spannung in einem Bereich ändert, wo es nicht sein darf. Wenn die Speicherstelle 20000 erreicht ist, das sind 2500 Aufzeichnungen, wird nur noch auf Veränderungen bis zur ersten Stelle hinterm Komma aufgezeichnet. Wenn 25000 Speicherstellen voll sind, also bei 3125 Aufzeichnungen, wird nur nur noch auf Änderungen vor dem Komma reagiert, also aufgezeichnet. So ist jedenfalls jetzt der Stand dess Programmes. Bei 32000 Speicherstellen, also 4000 Aufzeichungen, wird die Aufzeichung beendet !! Da ändert sich aber sicher noch eine ganze Menge.

Jetzt muss ich noch bei jeder Adresserhöhung, also bei jeder Aufzeichnung, an der Speicherstelle 0 die Adresse für die nächste Aufzeichnung eintragen, so dass das Gerät nach einem Spannungsausfall diesen Zeiger nicht verliert. So kann es beim zurückkommen der Betriebsspannung, erst schauen, ob auf Adresse "0" etwas größer als Null steht, und wenn ja, an dem Punkte weitermachen, wo es aufgehört hat. Ich möchte aber auch noch einen Akku einbauen, dass es eigentlich nicht ausfallen kann. Dann muss ich auch noch einen Programmteil haben, bei dem ich die Daten aus dem Speicher so oft auf einen PC über USB übertragen kann wie ich will. Und wenn ich die Daten nicht mehr brauche, auch löschen kann.

[Admin]

Habe noch Stress mit meinem Programm. Aber ich bleibe dran. Das sind neue Dinge, die nicht soooo einfach sind, wie ein paar Sensoren abfragen und danach irgendwas zu steuern. Aber es kommt.

[Admin]

Ich beschäftige mich mit dem Format der UTC Zeit. Da werden Datum und Uhrzeit in eine Zahl gerechnet, die Sekunden seit 1970 beinhaltet. Das sieht dann z.B. so aus:

Zeitberechnung.jpg (93.76 KiB) 322 mal betrachtet

Hier gehe ich von dem UTC Wert "1.769.353.173 Sek." aus, der zum Zeitpunkt, "25.01.2026 / 15:59:33" mit einem erhobenen Messwert in den FRAM geschrieben wurde. Minus 3600 Sekunden (eine Std.) fallen in unserer Zeitzone in der Winterzeit an. Im Sommer stehen da 7200 Sekunden zuviel, weil wir im Sommer 2 Std. unter der UTC liegen.

In der Grafik hier sieht man wie aus aktuell Datum & Uhrzeit der Wert wird, indem die ganze Invormation gespeichert ist. Also vergangene Sekunden seit 1970.

[Admin]

So jetzt habe ich ein Grundprogramm, auf das ich aufbauen kann. Ich hatte Probleme damit, Datum und Uhrzeitim FRAM zu speichern und aus dem FRAM wieder auszugeben. Da hatte ich heute gute Unterstützen im ArduinoCC Forum. Es geht noch viel weiter, aber die Funktion die ich zu Beginn wollte, ist erreicht. Inzwischen sind die Vorstellungen, was das können soll, stück für Stück gewachsen. Aber das ist ja gut. Es ist ein Hobby mit dem ich immer bischen vordere.

Hier ist mal das aktuelle Programm:

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. 
    Programm im Moment vom 03.02.2026 / ADC_ADS1115_ESP32_Mini_OLE_FRAM_2x4Byte_V10
*/
#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!
// -------------------OLED Display einrichten-------------------------------------------------
#include <U8g2lib.h>  // als U8g2 im Bibliotheksverwalter zu finden
U8G2_SH1106_128X64_NONAME_F_HW_I2C oled(U8G2_R0);
//------------------------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 Spannung2neu = 0;
int Spannung2alt = 0;
float f = 0;
uint8_t buffer[4];  // floats are 4 bytes!
uint32_t Zeitbuffer = 0;
int Speicher = 4;
int Speicher2 = 0;
int Zaehler = 0;
int Kontrollzaehler = 0;
byte LSpin = 27;
byte Messtiefe = 100;
byte Reagieren = 0;
//------------------------- Minuten Tackt zur 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 1 Min ----------------------------------
unsigned long Sekundenablauf02 = 0;  // Zeit für die Ausgabe Aufs Display & Serial
const unsigned long Pausezeit02 = 60000;
//-------------------------------- Zeit Messungen --------------------------------------------
unsigned long Messungstart = 0;
unsigned long Messungende = 0;
unsigned long Laufzeit = 0;

//############################################################################################
// ----------------------------------------------------SETUP----------------------------------
//############################################################################################
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("Analog-Test ESP32");
  //-----------------------------------------------------------
  Serial.println(F("NTP Server Abfrage"));
  NTP_Zeit();

  // ------------------EPROM 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);
  //----------------------- Oled Display ---------------------
  oled.begin();
  oled.clearBuffer();  // Textspeicher löschen
  //------- Erste Displayausgabe gleich nach dem Start -------
  Sekundenablauf01 = 60000;
}
//############################################################################################
// ----------------------------------------------------LOOP-----------------------------------
//############################################################################################
void loop() {
  Messungstart = millis();
  Zeitablauf = millis();

  if (Zeitablauf - Sekundenablauf01 >= Pausezeit01) {  // Eine Minute abgelaufen?
    Displayausgabe();
    Sekundenablauf01 = millis();
  }
  Kontrollen();
  Messen();
  if (Reagieren == 1) {
    SpeicherdatenSchreiben();
    Spannung2alt = Spannung2neu;
    SpeicherdatenLesen();
    testprint();
    Reagieren = 0;
  }
  /*
  Messungende = millis();
  Laufzeit = Messungende - Messungstart;
  if (Laufzeit >= 20){
  Serial.println(Laufzeit);
  }
  */
}  //---------------------------------- 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);
}
//############################################################################################
//---------------------------------- Displayausgabe ------------------------------------------
//############################################################################################
void Displayausgabe() {
  tm local;
  getLocalTime(&local);
  oled.clearBuffer();               // Textspeicher löschen
  oled.setFont(u8g2_font_6x12_tr);  // Kleine Schrift 6x12
  oled.setCursor(10, (1 * 10));
  oled.print(&local, " Datum: %d.%m.%y");
  // Hier das Problem. Die Zeitausgabe
  oled.setCursor(10, (2 * 10));
  oled.print(&local, " Zeit : %H:%M");  // 16 Zeichen neue Zeit schreiben
  oled.sendBuffer();

  // Messung auf das Display ausgeben
  oled.setFont(u8g2_font_10x20_mf);
  //ADS Kanal 0 anzeigen
  oled.setCursor(20, (2 * 20));
  oled.println(F("ADR "));
  oled.print(Speicher);
  //ADS Kanal 1 anzeigen
  oled.setCursor(20, (3 * 20));
  // if (ads_mv1 < 0) { ads_mv1 == 0; }
  oled.print(ads_mv0);
  oled.print(F(" Volt "));
  oled.sendBuffer();

  /*
    struct tm enthält diese Atribute:
    ===============================================
    Member   Type  Meaning                   Range
    tm_sec   int   seconds after the minute  0-60*
    tm_min   int   minutes after the hour    0-59
    tm_hour  int   hours since midnight      0-23
    tm_mday  int   day of the month          1-31
    tm_mon   int   months since January      0-11
    tm_year  int   years since 1900
    tm_wday  int   days since Sunday         0-6
    tm_yday  int   days since January 1      0-365
    tm_isdst int   Daylight Saving Time flag
    ==============================================
    */
}
//------------------------------------------------------------------------------------------
//############################################################################################
// ------------------------------------ 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);
  // oder
  // - differenzielle Messung an Kanal 0/1
  //adc0 = ads.readADC_Differential_0_1();
  //ads_mv = (adc0 * multiplier);
  //Serial.printf("; I2C: %4.2f mV\n", ads_mv);
  //===============================================
  //------------------------Ist die Spannung verändert ? Ja, dann speichern !-----------------
  // Hier wird die Messung "float" durch das *100, um zwei Kommas nach hinten geschoben
  // und in einen "int" übergeben. Dadurch sind die Werte hinter dem Komma abgeschnitten.
  // Das heißt, aus den gemessenen z.B. "3,1255768" Volt werden 312,55768
  // und mit int sind die stellen hinterm Komma weg.
  // Für den Vergleich als <-> neu bleibt also nur noch der Wert "312"
  // Die dritte stelle hinterm Komma ändert sich schon rel. oft.
  // -----------------------------------------------------------------------------------------
  Spannung2neu = ads_mv0 * Messtiefe;
  if (Spannung2alt == Spannung2neu) {
  } else {
    // Messung auf das Display ausgeben
    oled.setFont(u8g2_font_10x20_mf);
    //ADS Kanal 0 anzeigen
    oled.setCursor(20, (2 * 20));
    oled.println(F("ADR "));
    oled.print(Speicher + 4);
    //ADS Kanal 1 anzeigen
    oled.setCursor(20, (3 * 20));
    oled.print(ads_mv0);
    oled.print(F(" Volt "));
    oled.sendBuffer();
    Reagieren = 1;
    tone(LSpin, 1000, 100);  // Piep wenn sich die Spannung ändert.
  }
}
// ------------------------------- Messen Ende ---------------------------------------------

//##########################################################################################
//------------------------------ FRAM Schreiben --------------------------------------------
//##########################################################################################
void SpeicherdatenSchreiben() {
  Speicher = Speicher + 4;
  Zaehler = Zaehler + 1;
  Kontrollzaehler = Kontrollzaehler + 1;
  // Messwert Schreiben--------------------------------------------------------------------
  f = ads_mv0;
  memcpy(buffer, (void *)&f, 4);
  i2ceeprom.write(Speicher, buffer, 4);
  // Zeit & Datum Schreiben----------------------------------------------------------------
  time_t now;
  time(&now);
  Speicher = Speicher + 4;
  memcpy(buffer, (void *)&now, 4);
  i2ceeprom.write(Speicher, buffer, 4);
  // Display aktualisieren-----------------------------------------------------------------
  oled.setCursor(20, (2 * 20));
  oled.println(F("ADR "));
  oled.print(Speicher);
  //ADS Kanal 1 anzeigen
  oled.setCursor(20, (3 * 20));
  oled.print(ads_mv0);
  oled.print(F(" Volt "));
  oled.sendBuffer();
}
//------------------------------ 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 ---------------------------------------------
//
//##########################################################################################
//-------------------------------- Testprint -----------------------------------------------
//##########################################################################################
void testprint() {
  time_t t = Zeitbuffer;
  tm tm;
  localtime_r(&t, &tm);
  tm.tm_year += 1900;
  tm.tm_mon += 1;
  Serial.print(f, 8);
  Serial.print(F(" Volt ->"));
  //Serial.print(F(" ZeitBuffer = "));
  //Serial.print(Zeitbuffer);
  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(F(" ADR = "));
  Serial.print(Speicher);
  Serial.print(F(" # "));
  Serial.println(Zaehler);
}
//-------------------------------- Testprint Ende ------------------------------------------
//##########################################################################################
//-------------------------- Wichtige Kontrollen -------------------------------------------
//##########################################################################################
void Kontrollen() {
  if (Zeitablauf - Sekundenablauf02 >= Pausezeit02) {  // FRAM Aufzeichungen pro Minute messen
    if ((Kontrollzaehler >= 10) && (Messtiefe > 1)) {
      Messtiefe = Messtiefe / 10;
      Serial.print(F("###### Messtiefe Automatisch auf -> "));
      Serial.print(Messtiefe);
      Serial.println(F(" <- verringert #########"));
      Kontrollzaehler = 0;
    }
    Sekundenablauf02 = millis();
    Kontrollzaehler = 0;
  }
  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 -------------------------------------------

Hier ist ein erster Serial Print von den Messungen des Gerätes. Die Werte werden erst am FRAM gespeichert, dann aus dem FRAM Rückgelesen und Serial ausgegeben. Das ganze ist natürlich erst mal eine Testversion. Macht noch keinen Sinn, damit was zu bauen. Da ist noch keine Speicherkontrolle, kein Löschen des Speichers, bei Beginn einer neuen Spannungs Überwachung. Aber das ist keine große Aktion. Auch möchte ich noch einen zweiten Überwachnugnskanal einrichten. Und wenn zu viele Aufzeichnungen in zu kurzer Zeit kommen, wird die Reaktions - Schwelle automatisch angehoben. Ich möchte das Gerät auch mit einem fetten Akku versorgen, dass es auch ein Paar Tage Autark versorgt ist. Das ist der Plan.

Code: Alles auswählen

Rücklesen: 3.29400015 Zeitbuffer = 1770051895 Datum: 2.2.2026 Zeit: 18:4:55 ->  Zeiger = 20 ->  Einträge = 2
 Rücklesen: 3.19475007 Zeitbuffer = 1770051896 Datum: 2.2.2026 Zeit: 18:4:56 ->  Zeiger = 28 ->  Einträge = 3
 Rücklesen: 3.09475017 Zeitbuffer = 1770051896 Datum: 2.2.2026 Zeit: 18:4:56 ->  Zeiger = 36 ->  Einträge = 4
 Rücklesen: 3.10262513 Zeitbuffer = 1770051896 Datum: 2.2.2026 Zeit: 18:4:56 ->  Zeiger = 44 ->  Einträge = 5
 Rücklesen: 3.21737504 Zeitbuffer = 1770051896 Datum: 2.2.2026 Zeit: 18:4:56 ->  Zeiger = 52 ->  Einträge = 6
 Rücklesen: 3.30175018 Zeitbuffer = 1770051896 Datum: 2.2.2026 Zeit: 18:4:56 ->  Zeiger = 60 ->  Einträge = 7
 Rücklesen: 3.29912519 Zeitbuffer = 1770051912 Datum: 2.2.2026 Zeit: 18:5:12 ->  Zeiger = 68 ->  Einträge = 8
 Rücklesen: 3.19987512 Zeitbuffer = 1770051914 Datum: 2.2.2026 Zeit: 18:5:14 ->  Zeiger = 76 ->  Einträge = 9
 Rücklesen: 3.09750009 Zeitbuffer = 1770051916 Datum: 2.2.2026 Zeit: 18:5:16 ->  Zeiger = 84 ->  Einträge = 10
 Rücklesen: 2.99825025 Zeitbuffer = 1770051917 Datum: 2.2.2026 Zeit: 18:5:17 ->  Zeiger = 92 ->  Einträge = 11
 Rücklesen: 2.89975023 Zeitbuffer = 1770051918 Datum: 2.2.2026 Zeit: 18:5:18 ->  Zeiger = 100 ->  Einträge = 12
 Rücklesen: 2.90012503 Zeitbuffer = 1770051919 Datum: 2.2.2026 Zeit: 18:5:19 ->  Zeiger = 108 ->  Einträge = 13
 Rücklesen: 3.00262523 Zeitbuffer = 1770051920 Datum: 2.2.2026 Zeit: 18:5:20 ->  Zeiger = 116 ->  Einträge = 14
 Rücklesen: 3.10075021 Zeitbuffer = 1770051921 Datum: 2.2.2026 Zeit: 18:5:21 ->  Zeiger = 124 ->  Einträge = 15
 Rücklesen: 3.20037508 Zeitbuffer = 1770051923 Datum: 2.2.2026 Zeit: 18:5:23 ->  Zeiger = 132 ->  Einträge = 16
 Rücklesen: 3.30100012 Zeitbuffer = 1770051923 Datum: 2.2.2026 Zeit: 18:5:23 ->  Zeiger = 140 ->  Einträge = 17

Der zuletzt gespeicherte Messwert wie mit dem Zeiger auf die Aktuellen Adresszeiger im FRAM in Display angezeigt.
.

Spannungsüberwachnung 01.jpg (548.09 KiB) 102 mal betrachtet