Bumped version to 1.2.1 - Improved Stack info, if stack is exhausted, added flush to HexDump, improved examples.

Author: ArminJo

README.md

@@ -1,7 +1,8 @@
 <div align = center>
 
 # [ArduinoUtils](https://github.com/ArminJo/Arduino-Utils)
-My utility collection for Arduino
+My utility collection for Arduino<br/>
+Contains utilities for fast and flexible ADC conversions, Voltage and Resitance measurement, RAM, heap and stack info, Hex dumps, EMA filters etc.
 
 [![Badge License: GPLv3](https://img.shields.io/badge/License-GPLv3-brightgreen.svg)](https://www.gnu.org/licenses/gpl-3.0)
  &nbsp; &nbsp;
@@ -291,6 +292,9 @@ If you are using [Sloeber](https://eclipse.baeyens.it) as your IDE, you can easi
 
 # Revision History
 
+### Version 1.2.1
+- Improved Stack info, if stack is exhausted, added flush to HexDump, improved examples.
+
 ### Version 1.2.0
 - Updated AVRUtils, ADCUtils, HexDump and ShowInfo.
 - Added Optiboot 8.1.

examples/AVRUtilsDemo/AVRUtilsDemo.ino

@@ -4,7 +4,7 @@
  *  Demo of 2 seconds sleep with watchdog
  *  Demo of printRAMInfo() and printStackUnusedAndUsedBytes ()
  *
- *  Copyright (C) 2020-2024  Armin Joachimsmeyer
+ *  Copyright (C) 2020-2026  Armin Joachimsmeyer
  *  armin.joachimsmeyer@gmail.com
  *
  *  This file is part of Arduino-Utils https://github.com/ArminJo/Arduino-Utils.
@@ -134,12 +134,17 @@ void setup() {
     Serial.begin(115200);
     // Just to know which program is running on my Arduino
     Serial.println(F("START " __FILE__ "\r\nVersion " VERSION_EXAMPLE " from  " __DATE__));
+
+    Serial.println();
+    Serial.println(F("Print base RAM data"));
     printBaseRAMData(&Serial);
     Serial.flush();
 
     initStackFreeMeasurement();
 
 #endif // defined(CODE_FOR_ATTINY)
+    Serial.println();
+    Serial.println(F("Print MCUSR, Brown-out level and dummy array info"));
 
     Serial.flush();
 
@@ -186,33 +191,40 @@ void setup() {
     tone(TONE_OUT_PIN, 2200, 400);
     delay(400);
 
-    Serial.println();
-
 #if !defined(CODE_FOR_ATTINY)
-    printRAMInfo(&Serial);
-    printStackMaxUsedAndUnusedSizes(&Serial);
+    Serial.println();
+    Serial.println(F("Print RAM and Stack info"));
+    printRAMAndStackInfo(&Serial);
 
+    Serial.println();
     Serial.println(F("Dump 288 bytes of stack / end of RAM"));
     printStackMemory(288);
-    printRAMInfo(&Serial);
 
     Serial.println();
+    Serial.println(F("Print RAM and Stack info, stack usage has increased"));
+    printRAMAndStackInfo(&Serial);
 
     /*
      * Test calloc sizes
      */
+    Serial.println();
+    Serial.println(F("Test calloc sizes"));
     testCallocSizesAndPrint(&Serial);
 
+    Serial.println();
+    Serial.println(F("Print base RAM data again"));
     printBaseRAMData(&Serial);
-    printRAMInfo(&Serial);
-    printStackMaxUsedAndUnusedSizes(&Serial); // test this function, it works different from function used in printRAMInfo
+    Serial.println();
+    Serial.println(F("Print RAM and Stack info again"));
+    printRAMAndStackInfo(&Serial);
 #endif
 
-    Serial.println(F("Dump current stack"));
+    Serial.println();
+    Serial.print(F("Dump current stack: "));
     printStackDump();
-
-    Serial.println(F("Show return address for current function \"setup()\""));
+    Serial.print(F("\"__builtin_return_address(0)\" yields the return address of the current function \"setup()\" =0x"));
     Serial.println((uint16_t) __builtin_return_address(0), HEX);
+    Serial.println();
 
     /*
      * init sleep mode and wakeup period
@@ -230,30 +242,43 @@ void setup() {
      * Otherwise ADC can NOT disabled by (ADCSRA = 0) anymore and always consumes 200 uA!
      */
 //    PRR = _BV(PRTIM1) | _BV(PRTIM0) | _BV(PRUSI); // Disable timer 0 and USI - has no effect on Power Down current
+    Serial.println(F("Start of loop:"));
+
 }
 
 void loop() {
 
     digitalWrite(LED_PIN, HIGH);
     delay(400);
-    if (sNumberOfSleeps == 4) {
-        Serial.println(F("Wait 5 seconds to force watchdog reset"));
+    if (sNumberOfSleeps >= 4) {
+        Serial.println(F("Wait 3 seconds to see timeout message after 2 seconds"));
+        initTimeoutWithWatchdog(WDTO_2S);
+        delay(3000);
+
+        Serial.println(F("Now wait 3 seconds to wait for watchdog reset after 2 seconds"));
+        Serial.println();
         strncpy(sWatchdogResetInfoString, "4. loop", WATCHDOG_INFO_STRING_SIZE - 1);
-        wdt_enable(WDTO_2S); // Resets after 2 seconds if wdt_disable() is not called before;
-        delay(5000);
+        wdt_enable(WDTO_2S); // Resets the CPU after 2 seconds. To avoid this you must call wdt_disable() or wdt_reset() before.
+        delay(3000);
+
+        Serial.println(F("We will never see this, because watchdog does a reset before!"));
     }
     strncpy(sWatchdogResetInfoString, "unknown reason", WATCHDOG_INFO_STRING_SIZE - 1);
     digitalWrite(LED_PIN, LOW);
-    Serial.print(F("Sleep 2 seconds with watchdog reset sNumberOfSleeps="));
+    Serial.print(F("Sleep 2 seconds with watchdog timer sNumberOfSleeps="));
     Serial.println(sNumberOfSleeps);
     Serial.flush(); // Otherwise the USART interrupt will wake us up
-    sleepWithWatchdog(WDTO_2S, true); // Sleep 2 seconds
+    sleepWithWatchdog(WDTO_2S, true); // Sleep 2 seconds, then continue with loop
 }
 
 /*
  * This interrupt wakes up the cpu from sleep
  */
 ISR(WDT_vect) {
+    if (sNumberOfSleeps >= 4) {
+        wdt_reset(); // restart watchdog time
+        Serial.println(F("Timeout detected!"));
+    }
     sNumberOfSleeps++;
 }
 

examples/HCSR04Demo/HCSR04Demo.ino

@@ -39,7 +39,7 @@
 
 #include "HCSR04.hpp"
 
-#if !defined(STR_HELPER)
+#if !defined(STR_HELPER) && !defined(STR)
 #define STR_HELPER(x) #x
 #define STR(x) STR_HELPER(x)
 #endif

library.json

@@ -0,0 +1,25 @@
+{
+  "name": "ArduinoUtils",
+  "version": "1.2.1",
+  "description": "Contains utilities for fast and flexible ADC conversions, Voltage and Resitance measurement, RAM, heap and stack info, Hex dumps, EMA filters etc.",
+  "keywords": "ADC, EMA, Hex dump, RAM info",
+  "homepage": "https://github.com/ArminJo/Arduino-Utils",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/ArminJo/Arduino-Utils.git"
+  },
+  "authors" :
+  [
+     {
+       "name":"Armin Joachimsmeyer",
+       "email":"armin.arduino@gmail.com",
+       "maintainer": true
+     }
+  ],
+  "license": "GPL-3.0-or-later",
+  "frameworks": "arduino",
+  "platforms": ["atmelavr"],
+  "examples": "examples/*/*.ino",
+  "export": {"exclude": [".github", "pictures"]}
+}

library.properties

@@ -1,9 +1,9 @@
 name=ArduinoUtils
-version=1.2.0
+version=1.2.1
 author=Armin Joachimsmeyer
 maintainer=Armin Joachimsmeyer <armin.arduino@gmail.com>
 sentence=Utilities library for Arduino.
-paragraph=Contains utilities for fast and flexible ADC conversions,
+paragraph=Contains utilities for fast and flexible ADC conversions, Voltage and Resistance measurement, RAM, heap and stack info, Hex dumps, EMA filters etc.
 category=Signal Input/Output
 url=https://github.com/ArminJo/Arduino-Utils
 architectures=avr

src/AVRUtils.cpp

@@ -42,9 +42,9 @@
 
 uint8_t* getStartOfAvailableHeap(void) {
     if (__brkval == 0) {
-        // __brkval is 0 if no malloc() has happened before
+// __brkval is 0 if no malloc() has happened before
 //        __brkval = __malloc_heap_start;
-        __brkval = &__heap_start;
+        __brkval = &__heap_start; // = __bss_end, the linker address of heap start
     }
     return (uint8_t*) __brkval;
 }
@@ -87,7 +87,7 @@ int16_t getStackMaxUsedAndUnusedSizes(uint16_t *aStackUnusedSizePointer) {
         tStackUnused++;
     }
 
-    int16_t tStackMaxUsedSize = (RAMEND + 1) - (uint16_t) tHeapPtr;
+    int16_t tStackMaxUsedSize = (RAMEND + 1) - (int16_t) tHeapPtr;
 
     *aStackUnusedSizePointer = tStackUnused;
     if (tStackUnused == 0) {
@@ -109,17 +109,25 @@ void printStackMaxUsedAndUnusedSizes(Print *aSerial) {
     aSerial->print(F(", unused="));
     aSerial->print(tStackUnusedBytes);
     aSerial->print(F(" of current total "));
-    aSerial->println((RAMEND + 1) - (uint16_t) getStartOfAvailableHeap());
+    aSerial->println((RAMEND + 1) - (int16_t) getStartOfAvailableHeap());
 }
 
 /*
  * Search upwards the first two HEAP_STACK_UNTOUCHED_VALUE values after current begin of heap
+ * If stack uses total heap, we see the current available stack size here :-(
  */
-uint16_t getHeapMaxUsedSize() {
+int16_t getHeapMaxUsedSize() {
     uint8_t *tHeapPtr = getStartOfAvailableHeap();
     while (*tHeapPtr != HEAP_STACK_UNTOUCHED_VALUE && *(tHeapPtr + 1) != HEAP_STACK_UNTOUCHED_VALUE && tHeapPtr <= (uint8_t*) SP) {
         tHeapPtr++;
     }
+//    Serial.print(F("tHeapPtr=0x"));
+//    Serial.print((uint16_t)tHeapPtr, HEX);
+//    Serial.print(F(" SP=0x"));
+//    Serial.println((uint16_t)SP, HEX);
+    if ((tHeapPtr-1) == (uint8_t*) SP) {
+        return -1;
+    }
     // tHeapPtr points now to lowest untouched stack position or to lowest current stack byte
     return tHeapPtr - (uint8_t*) __malloc_heap_start;
 }
@@ -185,7 +193,7 @@ uint16_t getTheoreticalMaximumAvailableHeapSize(void) {
     if (RAMEND <= __malloc_margin) {
         return 0;
     }
-    return (RAMEND - RAMSTART) -__malloc_margin; // (128)
+    return (RAMEND - RAMSTART) - __malloc_margin; // (128)
 }
 
 /*
@@ -202,11 +210,11 @@ void printCurrentAvailableHeapSize(Print *aSerial) {
  */
 void printCurrentAvailableHeapSizeSimple(Print *aSerial) {
     aSerial->print(F("available="));
-    aSerial->println(SP - (uint16_t) __brkval + 1 - ((uint16_t) __malloc_margin));
+    aSerial->println(SP - (int16_t) __brkval + 1 - ((int16_t) __malloc_margin));
 }
 
 // This define is in AVRUtils.h
-//#define PRINT_AVAILABLE_HEAP   Serial.print(F("available="));Serial.println(SP - (uint16_t) __brkval + 1 - HEURISTIC_ADDITIONAL_MALLOC_MARGIN - ((uint16_t) __malloc_margin))
+//#define PRINT_AVAILABLE_HEAP   Serial.print(F("available="));Serial.println(SP - (int16_t) __brkval + 1 - HEURISTIC_ADDITIONAL_MALLOC_MARGIN - ((int16_t) __malloc_margin))
 
 void printBaseRAMData(Print *aSerial) {
     // __malloc_heap_end seems to be 0
@@ -259,32 +267,36 @@ void printBaseRAMData(Print *aSerial) {
  * Heap available + __malloc_margin (128) = Stack available
  * Data+BSS + Heap max used + Stack unused + Stack max used = RAMSIZE
  */
-void printRAMInfo(Print *aSerial) {
+void printRAMAndStackInfo(Print *aSerial) {
 
     aSerial->print(F("Data+BSS="));
-    aSerial->print((uint16_t) &__heap_start - RAMSTART);
+    aSerial->print((int16_t) &__heap_start - RAMSTART);
 
     aSerial->print(F(". Heap: used="));
-    aSerial->print((uint16_t) getStartOfAvailableHeap() - (uint16_t) &__heap_start);
-    aSerial->print(F(", max written=")); // if Stack uses total heap, we see the stack size here :-(
+    aSerial->print((uint16_t) getStartOfAvailableHeap() - (int16_t) &__heap_start);
+    aSerial->print(F(", max written=")); // If stack uses total heap, we see the stack size here :-(
     aSerial->print(getHeapMaxUsedSize());
     aSerial->print(F(", max available="));
-    aSerial->print(RAMEND - (uint16_t) getStartOfAvailableHeap() + 1 - (uint16_t) __malloc_margin);
+    aSerial->print(RAMEND - (int16_t) getStartOfAvailableHeap() + 1 - (int16_t) __malloc_margin);
 
     aSerial->print(F(". Stack: available="));
-    aSerial->print(SP - (uint16_t) getStartOfAvailableHeap() + 1);
+    aSerial->print((SP + 1) - (int16_t) getStartOfAvailableHeap());
     aSerial->print(F(", used="));
     aSerial->print(RAMEND - SP);
+
     uint16_t tStackUnusedBytes;
     aSerial->print(F(", max used="));
     aSerial->print(getStackMaxUsedAndUnusedSizes(&tStackUnusedBytes));
     aSerial->print(F(", unused="));
     aSerial->print(tStackUnusedBytes);
     aSerial->print(F(" of current total "));
-    aSerial->print((RAMEND + 1) - (uint16_t) getStartOfAvailableHeap()); // getStartOfAvailableHeap()
+    aSerial->print((RAMEND + 1) - (int16_t) getStartOfAvailableHeap()); // getStartOfAvailableHeap()
 
     aSerial->println();
 }
+void printRAMInfo(Print *aSerial) {
+    printRAMAndStackInfo(aSerial);
+}
 
 /*
  * The minimal margin from Heap End to to Stack Start for malloc()
@@ -317,9 +329,9 @@ void testCallocSizesAndPrint(Print *aSerial) {
         aSerial->print(F("SP=0x"));
         aSerial->print(SP, HEX);
         aSerial->print(F(" available="));
-        aSerial->print(SP - (uint16_t) __brkval + 1 - ((uint16_t) __malloc_margin)- HEURISTIC_ADDITIONAL_MALLOC_MARGIN);
+        aSerial->print(SP - (int16_t) __brkval + 1 - ((int16_t) __malloc_margin) - HEURISTIC_ADDITIONAL_MALLOC_MARGIN);
         aSerial->print(F(" max available="));
-        aSerial->print(RAMEND - (uint16_t) __brkval + 1 - ((uint16_t) __malloc_margin));
+        aSerial->print(RAMEND - (int16_t) __brkval + 1 - ((int16_t) __malloc_margin));
         uint8_t *tMallocPtr = (uint8_t*) calloc(tMallocSize, 1);
 
         aSerial->print(F(" -> calloc("));
@@ -377,7 +389,7 @@ void initSleep(uint8_t tSleepMode) {
 }
 
 /*
- * Watchdog wakes CPU periodically and all we have to do is call sleep_cpu();
+ * Watchdog wakes CPU periodically and all we have to do is call sleep_cpu() - see AVRUtilsDemo
  * aWatchdogPrescaler (see wdt.h) can be one of
  * WDTO_15MS, 30, 60, 120, 250, WDTO_500MS
  * WDTO_1S to WDTO_8S
@@ -399,6 +411,27 @@ void initPeriodicSleepWithWatchdog(uint8_t tSleepMode, uint8_t aWatchdogPrescale
     WDTCSR = tWDTCSR; // set final Value
 }
 
+/*
+ * Watchdog interrupts CPU periodically and ISR can be used to handle timeout  - see AVRUtilsDemo
+ * The reason for timeout is NOT removed, i.e. an endless loop will not be exited.
+ * aWatchdogPrescaler (see wdt.h) can be one of
+ * WDTO_15MS, 30, 60, 120, 250, WDTO_500MS
+ * WDTO_1S to WDTO_8S
+ */
+void initTimeoutWithWatchdog(uint8_t aWatchdogPrescaler) {
+    MCUSR = ~_BV(WDRF); // Clear WDRF in MCUSR
+
+#if defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) \
+    || defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) \
+    || defined(__AVR_ATtiny87__) || defined(__AVR_ATtiny167__)
+#define WDTCSR  WDTCR
+#endif
+    // Watchdog interrupt enable + reset interrupt flag -> needs ISR(WDT_vect)
+    uint8_t tWDTCSR = _BV(WDIE) | _BV(WDIF) | (aWatchdogPrescaler & 0x08 ? _WD_PS3_MASK : 0x00) | (aWatchdogPrescaler & 0x07); // handles that the WDP3 bit is in bit 5 of the WDTCSR register,
+    WDTCSR = _BV(WDCE) | _BV(WDE); // clear lock bit for 4 cycles by writing 1 to WDCE AND WDE
+    WDTCSR = tWDTCSR; // set final Value
+}
+
 /*
  * @param aWatchdogPrescaler (see wdt.h) can be one of WDTO_15MS, 30, 60, 120, 250, WDTO_500MS, WDTO_1S to WDTO_8S
  *                           0 (15 ms) to 3(120 ms), 4 (250 ms) up to 9 (8000 ms)
@@ -455,6 +488,15 @@ void sleepWithWatchdog(uint8_t aWatchdogPrescaler, bool aAdjustMillis) {
     }
 }
 
+/*
+ * Sample ISR for Watchdog
+ * This interrupt prints the timeout message
+ */
+//ISR(WDT_vect) {
+//    wdt_reset();
+//    myLCD.setCursor(0, 3);
+//    myLCD.print(F("No voltage detected "));
+//}
 /*
  * 0 -> %1
  * _BV(CLKPS0) -> %2

src/AVRUtils.h

@@ -70,6 +70,7 @@ extern volatile unsigned long timer0_millis;
 
 void initSleep(uint8_t tSleepMode);
 void initPeriodicSleepWithWatchdog(uint8_t tSleepMode, uint8_t aWatchdogPrescaler);
+void initTimeoutWithWatchdog(uint8_t aWatchdogPrescaler);
 uint16_t computeSleepMillis(uint8_t aWatchdogPrescaler);
 void sleepWithWatchdog(uint8_t aWatchdogPrescaler, bool aAdjustMillis = false);
 
@@ -92,11 +93,13 @@ void printCurrentAvailableHeapSizeSimple(Print *aSerial);
 void initStackFreeMeasurement();
 
 int16_t getStackMaxUsedAndUnusedSizes(uint16_t *aStackUnusedSizePointer);
+int16_t getHeapMaxUsedSize();
 void printStackMaxUsedAndUnusedSizes(Print *aSerial);
 bool printStackMaxUsedAndUnusedSizesIfChanged(Print *aSerial);
 
 void printBaseRAMData(Print *aSerial);
-void printRAMInfo(Print *aSerial);
+void printRAMAndStackInfo(Print *aSerial);
+void printRAMInfo(Print *aSerial) __attribute__ ((deprecated ("Renamed to printRAMAndStackInfo()")));
 
 bool isAddressInRAM(void *aAddressToCheck);
 bool isAddressBelowAvailableHeapStart(void *aAddressToCheck);