helperStuff.ino

/*
***************************************************************************
**  Program  : helperStuff
**  Version 1.9.1
**
**
**  Copyright (c) 2021 Rob Roos
**     based on Framework ESP8266 from Willem Aandewiel and modifications
**     from Robert van Breemen
**
**  TERMS OF USE: MIT License. See bottom of file.
***************************************************************************
*/


//===========================================================================================
bool compare(String x, String y)
{
    for (int i = 0; i < min(x.length(), y.length()); i++) {
      if (x[i] != y[i])
      {
        return (bool)(x[i] < y[i]);
      }
    }
    return x.length() < y.length();

} // compare()


//===========================================================================================
bool isNumericp(const char *timeStamp, int8_t len)
{
  for (int i=0; (i<len && i<12);i++)
  {
    if (timeStamp[i] < '0' || timeStamp[i] > '9')
    {
      return false;
    }
  }
  return true;

} // isNumericp()

//===========================================================================================
// Note: This function returns a pointer to a substring of the original string.
// If the given string was allocated dynamically, the caller must not overwrite
// that pointer with the returned value, since the original pointer must be
// deallocated using the same allocator with which it was allocated.  The return
// value must NOT be deallocated using free() etc.
char *trimwhitespace(char *str)
{
  char *end;

  // Trim leading space
  while(isspace((unsigned char)*str)) str++;

  if(*str == 0)  // All spaces?
    return str;

  // Trim trailing space
  end = str + strlen(str) - 1;
  while(end > str && isspace((unsigned char)*end)) end--;

  // Write new null terminator character
  end[1] = '\0';

  return str;
}


bool splitCString(char *sIn, const char *del, char *cKey, char *cValue)
{
  //printf("sIn=[%s]\r\n", sIn);
  static char _key[128];
  static char _value[256];

  char * token = strtok(sIn, del);
  // loop through the string to extract all other tokens
  while( token != NULL ) {
      //now trim spaces from token and copy it to wOut
      //strlcpy(wOut[wc++], trimwhitespace(token), sizeof(wOut[0]));
      token = strtok(NULL, del);
  }

  return true;
}

int8_t splitCString(char *sIn, const char *del, char wOut[][10], const int maxWords)
{
    //printf("sIn=[%s]\r\n", sIn);
    int wc=0;
    for(int i = 0; i<maxWords; i++){
        memset(wOut[i], '\0', sizeof(wOut[0]));  //make sure the c-strings are blank
    }
    char * token = strtok(sIn, del);
    // loop through the string to extract all other tokens
    while( token != NULL  && wc < maxWords) {
        //now trim spaces from token and copy it to wOut
        strlcpy(wOut[wc++], trimwhitespace(token), sizeof(wOut[0]));
        token = strtok(NULL, del);
    }

    // for (int i = 0; i<maxWords; i++){
    //     printf("wOut[%d]=[%s]\r\n", i, wOut[i]);
    // }

    return wc;
}

//===========================================================================================
int8_t splitString(String inStrng, char delimiter, String wOut[], uint8_t maxWords)
{
  int16_t inxS = 0, inxE = 0, wordCount = 0;

    inStrng.trim();
    while(inxE < inStrng.length() && wordCount < maxWords)
    {
      inxE  = inStrng.indexOf(delimiter, inxS);         //finds location of first ,
      wOut[wordCount] = inStrng.substring(inxS, inxE);  //captures first data String
      wOut[wordCount].trim();
      //DebugTf("[%d] => [%c] @[%d] found[%s]\r\n", wordCount, delimiter, inxE, wOut[wordCount].c_str());
      inxS = inxE;
      inxS++;
      wordCount++;
    }
    // zero rest of the words
    for(int i=wordCount; i< maxWords; i++)
    {
      wOut[wordCount][0] = 0;
    }
    // if not whole string processed place rest in last word
    if (inxS < inStrng.length())
    {
      wOut[maxWords-1] = inStrng.substring(inxS, inStrng.length());  // store rest of String
    }

    return wordCount;

} // splitString()



//===========================================================================================
void strConcat(char *dest, int maxLen, const char *src)
{
  if (strlen(dest) + strlen(src) < maxLen)
  {
    strcat(dest, src);
  }
  else
  {
    DebugTf("Combined string > %d chars\r\n", maxLen);
  }

} // strConcat()


//===========================================================================================
void strConcat(char *dest, int maxLen, float v, int dec)
{
  static char buff[25];
  if (dec == 0)       sprintf(buff,"%.0f", v);
  else if (dec == 1)  sprintf(buff,"%.1f", v);
  else if (dec == 2)  sprintf(buff,"%.2f", v);
  else if (dec == 3)  sprintf(buff,"%.3f", v);
  else if (dec == 4)  sprintf(buff,"%.4f", v);
  else if (dec == 5)  sprintf(buff,"%.5f", v);
  else                sprintf(buff,"%f",   v);

  if (strlen(dest) + strlen(buff) < maxLen)
  {
    strcat(dest, buff);
  }
  else
  {
    DebugTf("Combined string > %d chars\r\n", maxLen);
  }

} // strConcat()


//===========================================================================================
void strConcat(char *dest, int maxLen, int v)
{
  static char buff[25];
  sprintf(buff,"%d", v);

  if (strlen(dest) + strlen(buff) < maxLen)
  {
    strcat(dest, buff);
  }
  else
  {
    DebugTf("Combined string > %d chars\r\n", maxLen);
  }

} // strConcat()


//===========================================================================================
void strToLower(char *src)
{
  for (int i = 0; i < strlen(src); i++)
  {
    if (src[i] == '\0') return;
    if (src[i] >= 'A' && src[i] <= 'Z')
        src[i] += 32;
  }
} // strToLower()

//===========================================================================================
// a 'save' string copy
void strCopy(char *dest, int maxLen, const char *src, int frm, int to)
{
  int d=0;
//DebugTf("dest[%s], src[%s] max[%d], frm[%d], to[%d] =>\r\n", dest, src, maxLen, frm, to);
  dest[0] = '\0';
  for (int i=0; i<=frm; i++)
  {
    if (src[i] == 0) return;
  }
  for (int i=frm; (src[i] != 0  && i<=to && d<maxLen); i++)
  {
    dest[d++] = src[i];
  }
  dest[d] = '\0';

} // strCopy()

//===========================================================================================
// a 'save' version of strncpy() that does not put a '\0' at
// the end of dest if src >= maxLen!
void strCopy(char *dest, int maxLen, const char *src)
{
  dest[0] = '\0';
  strcat(dest, src);

} // strCopy()

//===========================================================================================
// 'tttABCtDEtFGHttt' => 'ABCtDEtFGHttt'
void strLTrim(char *dest, int maxLen, const char tChar )
{
  char tmp[maxLen];
  int  tPos = 0;
  bool done = false;

  tmp[0] = '\0';

  for (int dPos=0; (dPos<maxLen && dest[dPos] != '\0'); dPos++)
  {
    if (dest[dPos] != tChar || done)
    {
      tmp[tPos++] = dest[dPos];
      done = true;
    }
  }
  tmp[tPos] = '\0';
  strCopy(dest, maxLen, tmp);

} // strLTrim()

//===========================================================================================
// 'tttABCtDEtFGHttt' => 'tttABCtDEtFGH'
void strRTrim(char *dest, int maxLen, const char tChar )
{
  char tmp[maxLen];
  int dPos, tPos, dMax;
  bool done = false;

  for(dMax=0; dMax<maxLen; dMax++) { tmp[dMax] = '\0'; }

  dMax = strlen(dest)-1;
  for (dPos=dMax; (dPos>=0 && !done); dPos--)
  {
    if (dest[dPos] == tChar)
    {
      tPos = dPos;
      tmp[tPos] = '\0';
    }
    else done = true;
  }
  dPos++;
  for(dMax = 0; dMax <= dPos; dMax++)
  {
    tmp[dMax] = dest[dMax];
  }
  tmp[dMax+1] = '\0';
  strCopy(dest, maxLen, tmp);

} // strRTrim()

//===========================================================================================
// 'tttABCtDEtFGHttt' => 'ABCtDEtFGH'
void strTrim(char *dest, int maxLen, const char tChar )
{
  char sTmp[maxLen];

  strCopy(sTmp, maxLen, dest);
  strLTrim(sTmp, maxLen, tChar);
  strRTrim(sTmp, maxLen, tChar);
  strCopy(dest, maxLen, sTmp);

} // strTrim()

//===========================================================================================
void strRemoveAll(char *dest, int maxLen, const char tChar)
{
  char tmp[maxLen];
  int  tPos = 0;
  tmp[0] = '\0';
  for (int dPos=0; (dPos<maxLen && dest[dPos] != '\0'); dPos++)
  {
    if (dest[dPos] != tChar)
    {
      tmp[tPos++] = dest[dPos];
    }
  }
  tmp[tPos] = '\0';
  strCopy(dest, maxLen, tmp);

} // strRemoveAll()


//===========================================================================================
void strTrimCntr(char *dest, int maxLen)
{
  char tmp[maxLen];
  int tPos = 0;
  tmp[0] = '\0';
  for (int dPos=0; (dPos<maxLen && dest[dPos] != '\0'); dPos++)
  {
    if (dest[dPos] >= ' ' && dest[dPos] <= '~')  // space = 32, '~' = 127
    {
      tmp[tPos++] = dest[dPos];
    }
  }
  tmp[tPos] = '\0';
  strCopy(dest, maxLen, tmp);

} // strTrimCntr()

//===========================================================================================
int strIndex(const char *haystack, const char *needle, int start)
{
  char *p = strstr (haystack+start, needle);
  if (p) {
    //DebugTf("found [%s] at position [%d]\r\n", needle, (p - haystack));
    return (p - haystack);
  }
  return -1;

} // strIndex()

//===========================================================================================
int strIndex(const char *haystack, const char *needle)
{
  return strIndex(haystack, needle, 0);

} // strIndex()

//===========================================================================================
int stricmp(const char *a, const char *b)
{
    for (;; a++, b++) {
        int d = tolower((unsigned char)*a) - tolower((unsigned char)*b);
        if (d != 0 || !*a)
            return d;
    }

} // stricmp()

//===========================================================================================
char *intToStr(int32_t v)
{
  static char buff[25];
  sprintf(buff,"%d", v);
  return buff;

} // intToStr()

//===========================================================================================
char *floatToStr(float v, int dec)
{
  static char buff[25];
  if (dec == 0)       sprintf(buff,"%.0f", v);
  else if (dec == 1)  sprintf(buff,"%.1f", v);
  else if (dec == 2)  sprintf(buff,"%.2f", v);
  else if (dec == 3)  sprintf(buff,"%.3f", v);
  else if (dec == 4)  sprintf(buff,"%.4f", v);
  else if (dec == 5)  sprintf(buff,"%.5f", v);
  else                sprintf(buff,"%f",   v);
  return buff;

} // floattToStr()

//===========================================================================================
float formatFloat(float v, int dec)
{
  return (String(v, dec).toFloat());

} //  formatFloat()

//===========================================================================================
float strToFloat(const char *s, int dec)
{
  float r =  0.0;
  int   p =  0;
  int   d = -1;

  r = strtof(s, NULL);
  p = (int)(r*pow(10, dec));
  r = p / pow(10, dec);
  //DebugTf("[%s][%d] => p[%d] -> r[%f]\r\n", s, dec, p, r);
  return r;

} //  strToFloat()

//===========================================================================================
void parseJsonKey(const char *sIn, const char *key, char *val, int valLen)
{
  // json key-value pair looks like:
  //      "samenv": "Zwaar bewolkt",
  // or   "samenv": "Zwaar bewolkt"}
  int keyStart   = strIndex(sIn, key);
  int sepStart   = strIndex(sIn, ",", keyStart);
  if (sepStart == -1)
  {
    sepStart   = strIndex(sIn, "}", keyStart);
  }
  strCopy(val, valLen, sIn, keyStart+strlen(key), sepStart);
  strRemoveAll(val, valLen, ':');
  strRemoveAll(val, valLen, ',');
  strRemoveAll(val, valLen, '}');
  strRemoveAll(val, valLen, '"');
  strTrim(val, valLen, ' ');

} // parseJsonKey()

//===========================================================================================
String upTime()
{
  char    calcUptime[20];

  snprintf(calcUptime, sizeof(calcUptime), "%d(d)-%02d:%02d(H:m)"
                                          , int((upTimeSeconds / (60 * 60 * 24)) % 365)
                                          , int((upTimeSeconds / (60 * 60)) % 24)
                                          , int((upTimeSeconds / (60)) % 60));

  return calcUptime;

} // upTime()

//===========================================================================================
boolean isValidIP(IPAddress ip)
{
 /* Works as follows:
   *  example:
   *  127.0.0.1
   *   1 => 127||0||0||1 = 128>0 = true
   *   2 => !(false || false) = true
   *   3 => !(false || false || false || false ) = true
   *   4 => !(true && true && true && true) = false
   *   5 => !(false) = true
   *   true && true & true && false && true = false ==> correct, this is an invalid addres
   *
   *   0.0.0.0
   *   1 => 0||0||0||0 = 0>0 = false
   *   2 => !(true || true) = false
   *   3 => !(false || false || false || false) = true
   *   4 => !(true && true && true && tfalse) = true
   *   5 => !(false) = true
   *   false && false && true && true && true = false ==> correct, this is an invalid addres
   *
   *   192.168.0.1
   *   1 => 192||168||0||1 =233>0 = true
   *   2 => !(false || false) = true
   *   3 +> !(false || false || false || false) = true
   *   4 => !(false && false && true && true) = true
   *   5 => !(false) = true
   *   true & true & true && true && true = true ==> correct, this is a valid address
   *
   *   255.255.255.255
   *   1 => 255||255||255||255 =255>0 = true
   *   2 => !(false || false ) = true
   *   3 +> !(true || true || true || true) = false
   *   4 => !(false && false && false && false) = true
   *   5 => !(true) = false
   *   true && true && false && true && false = false ==> correct, this is an invalid address
   *
   *   0.123.12.1       => true && false && true && true && true = false  ==> correct, this is an invalid address
   *   10.0.0.0         => true && false && true && true && true = false  ==> correct, this is an invalid address
   *   10.255.0.1       => true && true && false && true && true = false  ==> correct, this is an invalid address
   *   150.150.255.150  => true && true && false && true && true = false  ==> correct, this is an invalid address
   *
   *   123.21.1.99      => true && true && true && true && true = true    ==> correct, this is annvalid address
   *   1.1.1.1          => true && true && true && true && true = true    ==> correct, this is annvalid address
   *
   *   Some references on valid ip addresses:
   *   - https://www.quora.com/How-do-you-identify-an-invalid-IP-address
   *
   */
  boolean _isValidIP = false;
  _isValidIP = ((ip[0] || ip[1] || ip[2] || ip[3])>0);                             // if any bits are set, then it is not 0.0.0.0
  _isValidIP &= !((ip[0]==0) || (ip[3]==0));                                       // if either the first or last is a 0, then it is invalid
  _isValidIP &= !((ip[0]==255) || (ip[1]==255) || (ip[2]==255) || (ip[3]==255)) ;  // if any of the octets is 255, then it is invalid
  _isValidIP &= !(ip[0]==127 && ip[1]==0 && ip[2]==0 && ip[3]==1);                 // if not 127.0.0.0 then it might be valid
  _isValidIP &= !(ip[0]>=224);                                                     // if ip[0] >=224 then reserved space

  // DebugTf( "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
  // if (_isValidIP)
  //   Debugln(F(" = Valid IP"));
  // else
  //   Debugln(F(" = Invalid IP!"));

  return _isValidIP;

} //  isValidIP()


uint32_t updateRebootCount()
{
  //simple function to keep track of the number of reboots
  //return: number of reboots (if it goes as planned)
  uint32_t _reboot = 0;
  #define REBOOTCNT_FILE "/reboot_count.txt"
  if (LittleFS.begin()) {
    //start with opening the file
    File fh = LittleFS.open(REBOOTCNT_FILE, "r");
    if (fh) {
      //read from file
      if (fh.available()){
        //read the first line
        _reboot  = fh.readStringUntil('\n').toInt();
      }
    }
    fh.close();
    //increment reboot counter
    _reboot++;
    //write back the reboot counter
    fh = LittleFS.open(REBOOTCNT_FILE, "w");
    if (fh) {
      //write to _reboot to file
      fh.println(_reboot);
    }
    fh.close();
  }
  return _reboot;
}


bool updateRebootLog(String text)
{
  #define REBOOTLOG_FILE "/reboot_log.txt"
  #define TEMPLOG_FILE "/reboot_log.t.txt"
  #define LOG_LINES 30
  #define LOG_LINE_LENGTH 140


  char log_line[LOG_LINE_LENGTH] = {0};
  char log_line_regs[LOG_LINE_LENGTH] = {0};
  char log_line_reason[LOG_LINE_LENGTH] = {0};
  char log_line_excpt[LOG_LINE_LENGTH] = {0};
  uint32_t errorCode = -1;


  loopNTP(); // make sure time is up to date


  struct	rst_info	*rtc_info	=	system_get_rst_info();
  
  if (rtc_info == NULL) {
    DebugTf("no reset info available:	%x\r\n",	errorCode);
  } else {


    // Rst cause No.    Cause                     GPIO state
    //--------------    -------------------       -------------
    // 0                Power reboot              Changed
    // 1                Hardware WDT reset        Changed
    // 2                Fatal exception           Unchanged
    // 3                Software watchdog reset   Unchanged
    // 4                Software reset            Unchanged
    // 5                Deep-sleep                Changed
    // 6                Hardware reset            Changed

    errorCode = rtc_info->reason;

    switch(rtc_info->reason) {
        case 0:   snprintf(log_line_reason, LOG_LINE_LENGTH, "0 - Power reboot"); break;
        case 1:   snprintf(log_line_reason, LOG_LINE_LENGTH, "1 - Hardware WDT reset"); break;
        case 2:   snprintf(log_line_reason, LOG_LINE_LENGTH, "2 - Fatal exception"); break;
        case 3:   snprintf(log_line_reason, LOG_LINE_LENGTH, "3 - Software watchdog reset"); break;
        case 4:   snprintf(log_line_reason, LOG_LINE_LENGTH, "4 - Software reset"); break;
        case 5:   snprintf(log_line_reason, LOG_LINE_LENGTH, "5 - Deep-sleep"); break;
        case 6:   snprintf(log_line_reason, LOG_LINE_LENGTH, "6 - Hardware reset"); break;
        default:  snprintf(log_line_reason, LOG_LINE_LENGTH, "- Other (not specified) (%d)", rtc_info->reason); break;
      }
    DebugTf("reset reason:	%s\r\n",	log_line_reason);

    if	(rtc_info->reason	==	REASON_WDT_RST	|| rtc_info->reason	==	REASON_EXCEPTION_RST	|| rtc_info->reason	==	REASON_SOFT_WDT_RST)	{

      //The	address	of	the	last	crash	is	printed,	which	is	used	to	debug	garbled	output
      snprintf(log_line_regs, LOG_LINE_LENGTH,"ESP register contents: epc1=0x%08x, epc2=0x%08x, epc3=0x%08x, excvaddr=0x%08x, depc=0x%08x\r\n", rtc_info->epc1, rtc_info->epc2, rtc_info->epc3, rtc_info->excvaddr, rtc_info->depc);
      DebugTf(log_line_regs);
    }


    if	(rtc_info->reason	==	REASON_EXCEPTION_RST)	{


      // Fatal exception No.    Description             Possible Causes
      // -------------------    --------------          -------------------
      //  0                     Invalid command         1. Damaged BIN binaries
      //                                                2. Wild pointers
      //
      //  6                     Division by zero        Division by zero
      //
      //  9                     Unaligned read/write    1. Unaligned read/write Cache addresses
      //                        operation addresses     2. Wild pointers
      //
      //  28/29                 Access to invalid       1. Access to Cache after it is turned off
      //                        address                 2. Wild pointers
      //
      // more reasons can be found in the "corebits.h" file of the Extensa SDK


      switch(rtc_info->exccause) {
        case 0:   snprintf(log_line_excpt, LOG_LINE_LENGTH, "- Invalid command (0)"); break;
        case 6:   snprintf(log_line_excpt, LOG_LINE_LENGTH, "- Division by zero (6)"); break;
        case 9:   snprintf(log_line_excpt, LOG_LINE_LENGTH, "- Unaligned read/write operation addresses (9)"); break;
        case 28:  snprintf(log_line_excpt, LOG_LINE_LENGTH, "- Access to invalid address (28)"); break;
        case 29:  snprintf(log_line_excpt, LOG_LINE_LENGTH, "- Access to invalid address (29)"); break;
        default:  snprintf(log_line_excpt, LOG_LINE_LENGTH, "- Other (not specified) (%d)", rtc_info->exccause); break;
      }


      DebugTf("Fatal exception (%d): %s\r\n",	rtc_info->exccause, log_line_excpt);
    }
  }


  snprintf(log_line, LOG_LINE_LENGTH, "%d-%02d-%02d %02d:%02d:%02d - reboot cause: %s (%x) %s\r\n", year(),  month(), day(), hour(), minute(), second(), text, errorCode, log_line_excpt);


  if (LittleFS.begin()) {
    //start with opening the file
    File outfh = LittleFS.open(TEMPLOG_FILE, "w");


    if (outfh) {
      //write to _reboot to file
      outfh.print(log_line);

      if (strlen(log_line_reason)>2) {
        outfh.print(log_line_reason);
      }


      if (strlen(log_line_regs)>2) {
        outfh.print(log_line_regs);
      }


      File infh = LittleFS.open(REBOOTLOG_FILE, "r");
      
      int i = 1;
      if (infh) {
        //read from file
        while (infh.available() && (i < LOG_LINES)){
          //read the first line 
          // String line = infh.readStringUntil('\r\n');
          String line = infh.readStringUntil('\n');
          if (line.length() > 3) { //TODO: check is no longer needed?
            outfh.print(line);
          }
          i++;
        }
        infh.close();
      }
      outfh.close();
      
      if (LittleFS.exists(REBOOTLOG_FILE)) {
        LittleFS.remove(REBOOTLOG_FILE);
      }
      
      LittleFS.rename(TEMPLOG_FILE, REBOOTLOG_FILE);


      return true; // succesfully logged
    }
  }
  
  return false; // logging unsuccesfull
}



void doRestart(const char* str) {
  DebugTln(str);
  updateRebootLog(String(str));
  delay(2000);  // Enough time for messages to be sent and saved
  ESP.restart();
  delay(5000);  // Enough time to ensure we don't return.
}


/***************************************************************************
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to permit
* persons to whom the Software is furnished to do so, subject to the
* following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
* THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
****************************************************************************
*/