refactor: heap info

data/index.html

@@ -99,7 +99,7 @@
               </tr>
               <tr>
                 <th scope="row">Free memory:</th>
-                <td><b class="free-heap"></b> of <b class="total-heap"></b> bytes, max free block: <b class="max-free-block-heap"></b> bytes</td>
+                <td><b class="free-heap"></b> of <b class="total-heap"></b> bytes (min: <b class="min-free-heap"></b> bytes)<br>max free block: <b class="max-free-block-heap"></b> bytes (min: <b class="min-max-free-block-heap"></b> bytes)</td>
               </tr>
               <tr>
                 <th scope="row">Last reset reason:</th>

src/MainTask.h

@@ -33,8 +33,8 @@ protected:
   bool blinkerInitialized = false;
   unsigned long firstFailConnect = 0;
   unsigned long lastHeapInfo = 0;
-  unsigned int minFreeHeapSize = 0;
+  unsigned int minFreeHeap = 0;
-  unsigned int minMaxFreeHeapBlockSize = 0;
+  unsigned int minMaxFreeBlockHeap = 0;
   unsigned long restartSignalTime = 0;
   bool heatingEnabled = false;
   unsigned long heatingDisabledTime = 0;
@@ -64,9 +64,6 @@ protected:
       pinMode(settings.externalPump.pin, OUTPUT);
       digitalWrite(settings.externalPump.pin, false);
     }
-
-    this->minFreeHeapSize = getTotalHeap();
-    this->minMaxFreeHeapBlockSize = getTotalHeap();
   }
 
   void loop() {
@@ -179,48 +176,36 @@ protected:
   }
 
   void heap() {
-    unsigned int freeHeapSize = getFreeHeap();
+    unsigned int freeHeap = getFreeHeap();
-    #if defined(ARDUINO_ARCH_ESP32)
+    unsigned int maxFreeBlockHeap = getMaxFreeBlockHeap();
-      unsigned int maxFreeBlockSize = ESP.getMaxAllocHeap();
-    #else
-      unsigned int maxFreeBlockSize = ESP.getMaxFreeBlockSize();
-    #endif
 
-    if (!vars.actions.restart && (freeHeapSize < 2048 || maxFreeBlockSize < 2048)) {
+    if (!vars.actions.restart && (freeHeap < 2048 || maxFreeBlockHeap < 2048)) {
       vars.actions.restart = true;
-      return;
     }
 
     if (!settings.system.debug) {
       return;
     }
 
-    unsigned int minFreeHeapSizeDiff = 0;
+    size_t minFreeHeap = getFreeHeap(true);
-    #if defined(ARDUINO_ARCH_ESP32)
+    size_t minFreeHeapDiff = 0;
-    unsigned int currentMinFreeHeapSize = ESP.getMinFreeHeap();
+    if (minFreeHeap < this->minFreeHeap || this->minFreeHeap == 0) {
-    if (currentMinFreeHeapSize < this->minFreeHeapSize) {
+      minFreeHeapDiff = this->minFreeHeap - minFreeHeap;
-      minFreeHeapSizeDiff = this->minFreeHeapSize - currentMinFreeHeapSize;
+      this->minFreeHeap = minFreeHeap;
-      this->minFreeHeapSize = currentMinFreeHeapSize;
     }
-    #else
+    
-    if (freeHeapSize < this->minFreeHeapSize) {
+    size_t minMaxFreeBlockHeap = getMaxFreeBlockHeap(true);
-      minFreeHeapSizeDiff = this->minFreeHeapSize - freeHeapSize;
+    size_t minMaxFreeBlockHeapDiff = 0;
-      this->minFreeHeapSize = freeHeapSize;
+    if (minMaxFreeBlockHeap < this->minMaxFreeBlockHeap || this->minMaxFreeBlockHeap == 0) {
-    }
+      minMaxFreeBlockHeapDiff = this->minMaxFreeBlockHeap - minMaxFreeBlockHeap;
-    #endif
+      this->minMaxFreeBlockHeap = minMaxFreeBlockHeap;
-
-    unsigned int minMaxFreeBlockSizeDiff = 0;
-    if (maxFreeBlockSize < this->minMaxFreeHeapBlockSize) {
-      minMaxFreeBlockSizeDiff = this->minMaxFreeHeapBlockSize - maxFreeBlockSize;
-      this->minMaxFreeHeapBlockSize = maxFreeBlockSize;
     }
 
-    uint8_t heapFrag = 100 - maxFreeBlockSize * 100.0 / freeHeapSize;
+    if (millis() - this->lastHeapInfo > 20000 || minFreeHeapDiff > 0 || minMaxFreeBlockHeapDiff > 0) {
-    if (millis() - this->lastHeapInfo > 20000 || minFreeHeapSizeDiff > 0 || minMaxFreeBlockSizeDiff > 0) {
       Log.sverboseln(
         FPSTR(L_MAIN),
         F("Free heap size: %u of %u bytes (min: %u, diff: %u), max free block: %u (min: %u, diff: %u, frag: %hhu%%)"),
-        freeHeapSize, getTotalHeap(), this->minFreeHeapSize, minFreeHeapSizeDiff, maxFreeBlockSize, this->minMaxFreeHeapBlockSize, minMaxFreeBlockSizeDiff, heapFrag
+        freeHeap, getTotalHeap(), this->minFreeHeap, minFreeHeapDiff, maxFreeBlockHeap, this->minMaxFreeBlockHeap, minMaxFreeBlockHeapDiff, getHeapFrag()
       );
       this->lastHeapInfo = millis();
     }

src/PortalTask.h

@@ -447,9 +447,11 @@ protected:
       doc["system"]["version"] = PROJECT_VERSION;
       doc["system"]["buildDate"] = __DATE__ " " __TIME__;
       doc["system"]["uptime"] = millis() / 1000ul;
-      doc["system"]["freeHeap"] = getFreeHeap();
       doc["system"]["totalHeap"] = getTotalHeap();
+      doc["system"]["freeHeap"] = getFreeHeap();
+      doc["system"]["minFreeHeap"] = getFreeHeap(true);
       doc["system"]["maxFreeBlockHeap"] = getMaxFreeBlockHeap();
+      doc["system"]["minMaxFreeBlockHeap"] = getMaxFreeBlockHeap(true);
       doc["system"]["resetReason"] = getResetReason();
       doc["system"]["mqttConnected"] = tMqtt->isConnected();
       doc.shrinkToFit();

src/utils.h

@@ -13,28 +13,60 @@ double roundd(double value, uint8_t decimals = 2) {
   return (int)(value * multiplier) / multiplier;
 }
 
-size_t getFreeHeap() {
-  return ESP.getFreeHeap();
-}
-
 size_t getTotalHeap() {
   #if defined(ARDUINO_ARCH_ESP32)
-    return ESP.getHeapSize();
+  return ESP.getHeapSize();
   #elif defined(ARDUINO_ARCH_ESP8266)
-    return 81920;
+  return 81920;
   #else
-    return 99999;
+  return 99999;
   #endif
 }
 
-size_t getMaxFreeBlockHeap() {
+size_t getFreeHeap(bool getMinValue = false) {
   #if defined(ARDUINO_ARCH_ESP32)
-    return ESP.getMaxAllocHeap();
+    return getMinValue ? ESP.getMinFreeHeap() : ESP.getFreeHeap();
+    
+  #elif defined(ARDUINO_ARCH_ESP8266)
+    static size_t minValue = 0;
+    size_t value = ESP.getFreeHeap();
+    
+    if (value < minValue || minValue == 0) {
+      minValue = value;
+    }
+
+    return getMinValue ? minValue : value;
   #else
-    return ESP.getMaxFreeBlockSize();
+    return 0;
   #endif
 }
 
+size_t getMaxFreeBlockHeap(bool getMinValue = false) {
+  static size_t minValue = 0;
+  size_t value = 0;
+  
+  #if defined(ARDUINO_ARCH_ESP32)
+  value = ESP.getMaxAllocHeap();
+
+  size_t minHeapValue = getFreeHeap(true);
+  if (minHeapValue < minValue || minValue == 0) {
+    minValue = minHeapValue;
+  }
+  #elif defined(ARDUINO_ARCH_ESP8266)
+  value = ESP.getMaxFreeBlockSize();
+  #endif
+
+  if (value < minValue || minValue == 0) {
+    minValue = value;
+  }
+
+  return getMinValue ? minValue : value;
+}
+
+uint8_t getHeapFrag() {
+  return 100 - getMaxFreeBlockHeap() * 100.0 / getFreeHeap();
+}
+
 String getResetReason() {
   String value;
 

src_data/static/app.js

@@ -550,9 +550,11 @@ async function loadVars() {
   setValue('.uptime-hours', Math.floor(result.system.uptime % 86400 / 3600));
   setValue('.uptime-min', Math.floor(result.system.uptime % 3600 / 60));
   setValue('.uptime-sec', Math.floor(result.system.uptime % 60));
-  setValue('.free-heap', result.system.freeHeap);
   setValue('.total-heap', result.system.totalHeap);
+  setValue('.free-heap', result.system.freeHeap);
+  setValue('.min-free-heap', result.system.minFreeHeap);
   setValue('.max-free-block-heap', result.system.maxFreeBlockHeap);
+  setValue('.min-max-free-block-heap', result.system.minMaxFreeBlockHeap);
   setValue('.reset-reason', result.system.resetReason);
   setState('.mqtt-connected', result.system.mqttConnected);