From 9ca9633332f876c0a5f01b0e5c6cb29e3b36381c Mon Sep 17 00:00:00 2001
From: georgeman93 <george.gpo93@gmail.com>
Date: Wed, 8 Dec 2021 13:41:17 +1100
Subject: [PATCH 001/100] not working yet

---
 src/TinyGsmClient.h     |   1 +
 src/TinyGsmClientBG96.h | 183 +++++++++++++++++++++++++++++++++++-----
 2 files changed, 164 insertions(+), 20 deletions(-)

diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index a8ae763..6b85bc7 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -77,6 +77,7 @@ typedef TinyGsmM95::GsmClientM95 TinyGsmClient;
 #include "TinyGsmClientBG96.h"
 typedef TinyGsmBG96                TinyGsm;
 typedef TinyGsmBG96::GsmClientBG96 TinyGsmClient;
+typedef TinyGsmBG96::GsmClientSecureBG96 TinyGsmClientSecure;
 
 #elif defined(TINY_GSM_MODEM_A6) || defined(TINY_GSM_MODEM_A7)
 #include "TinyGsmClientA6.h"
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index e696404..656f85d 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -96,7 +96,26 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
       return true;
     }
 
-   public:
+    int8_t uploadFile(const char *fileName, const char *content) {
+      // AT+QFDEL="file_name.pem"
+      at->sendAT(GF("+QFDEL="), GF("\""), fileName,
+                 GF("\""));
+      at->waitResponse();
+
+      at->sendAT(GF("+QFUPL="), GF("\""), fileName,
+                 GF("\","), strlen(content), GF(","), 100);
+      if (at->waitResponse(GF("CONNECT")) != 1)
+        return 0;
+      at->stream.write(content, strlen(content));
+      at->stream.flush();
+      if (at->waitResponse() != 1)
+        return 0;
+      if (at->waitResponse(5000, GF(GSM_NL "+QFUPL:")) != 1)
+        return 0;
+      at->stream.readStringUntil('\n');
+      return at->waitResponse();
+    }
+
     virtual int connect(const char* host, uint16_t port, int timeout_s) {
       stop();
       TINY_GSM_YIELD();
@@ -117,6 +136,10 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
       stop(15000L);
     }
 
+    // we need to be able to access the inner secure client function definitions from inside TinyGsmTCP
+    // eg modemSend, modemRead, modemGetConnected and modemGetAvailable, how?
+
+    
     /*
      * Extended API
      */
@@ -127,17 +150,13 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   /*
    * Inner Secure Client
    */
-
-  /*
-  class GsmClientSecureBG96 : public GsmClientBG96
-  {
+public:
+  class GsmClientSecureBG96 : public GsmClientBG96 {
   public:
-    GsmClientSecure() {}
-
-    GsmClientSecure(TinyGsmBG96& modem, uint8_t mux = 0)
-     : public GsmClient(modem, mux)
-    {}
+    GsmClientSecureBG96() {}
 
+    explicit GsmClientSecureBG96(TinyGsmBG96& modem, uint8_t mux = 0)
+     : GsmClientBG96(modem, mux) {}
 
   public:
     int connect(const char* host, uint16_t port, int timeout_s) override {
@@ -148,8 +167,118 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
       return sock_connected;
     }
     TINY_GSM_CLIENT_CONNECT_OVERRIDES
+
+    void stop(uint32_t maxWaitMs) {
+      uint32_t startMillis = millis();
+      dumpModemBuffer(maxWaitMs);
+      at->sendAT(GF("+QSSLCLOSE=0"));
+      sock_connected = false;
+      at->waitResponse((maxWaitMs - (millis() - startMillis)));
+    }
+    void stop() {
+      stop(15000L);
+    }
+
+    int8_t sslSetcacert(uint8_t context, const char *fileName) {
+      at->sendAT(GF("+QSSLCFG="), GF("\""), GF("cacert"),
+                 GF("\","), context, GF(",\""), fileName, GF("\""));
+      at->waitResponse();
+
+      at->sendAT(GF("+QSSLCFG="), GF("\""), GF("negotiatetime"),
+                 GF("\","), context, GF(",300"));
+      at->waitResponse();
+      at->sendAT(GF("+QSSLCFG="), GF("\""), GF("ignorelocaltime"),
+                 GF("\","), context, GF(",0"));
+      return at->waitResponse();
+    }
+
+  protected:
+    int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
+      at->sendAT(GF("+QSSLSEND=0,"), (uint16_t)len);
+      if (at->waitResponse(GF(">")) != 1) { return 0; }
+      at->stream.write(reinterpret_cast<const uint8_t*>(buff), len);
+      at->stream.flush();
+      if (at->waitResponse(GF(GSM_NL "SEND OK")) != 1) { return 0; }
+      return len;
+    }
+
+    size_t modemRead(size_t size, uint8_t mux) {
+      if (!at->sockets[mux]) return 0;
+      at->sendAT(GF("+QSSLRECV=0,"), (uint16_t)size);
+      if (at->waitResponse(GF("+QSSLRECV:")) != 1) { return 0; }
+      int16_t len = at->streamGetIntBefore('\n');
+
+      for (int i = 0; i < len; i++) { at->moveCharFromStreamToFifo(mux); }
+      at->waitResponse();
+      // DBG("### READ:", len, "from", mux);
+      // sockets[mux]->sock_available = modemGetAvailable(mux);
+      return len;
+    }
+
+    size_t modemGetAvailable(uint8_t mux) {
+      if (!at->sockets[mux]) return 0;
+      at->sendAT(GF("+QSSLRECV=0,1500"));
+      size_t result = 0;
+      if (at->waitResponse(GF("+QSSLRECV:")) == 1) {
+        result = at->streamGetIntBefore('\n');
+        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
+        at->waitResponse();
+      }
+      if (!result) { at->sockets[mux]->sock_connected = modemGetConnected(mux); }
+      return result;
+    }
+
+    bool modemGetConnected(uint8_t mux) {
+      at->sendAT(GF("+QSSLSTATE=0"));
+      // +QSSLSTATE: 4,"SSLClient","220.180.239.201",8010,65344,2,1,4,0,"usbmodem",1
+
+      if (at->waitResponse(GF("+QSSLSTATE:")) != 1) { return false; }
+
+      at->streamSkipUntil(',');                  // Skip clientID
+      at->streamSkipUntil(',');                  // Skip "SSLClient"
+      at->streamSkipUntil(',');                  // Skip remote ip
+      at->streamSkipUntil(',');                  // Skip remote port
+      at->streamSkipUntil(',');                  // Skip local port
+      int8_t res = at->streamGetIntBefore(',');  // socket state
+
+      at->waitResponse();
+
+      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
+      return 2 == res;
+    }
+
+    bool gprsConnectImpl(const char* apn, const char* user = NULL,
+                       const char* pwd = NULL) {
+      at->gprsDisconnect();
+
+      // Configure the TCPIP Context
+      at->sendAT(GF("+QICSGP=1,1,\""), apn, GF("\",\""), user, GF("\",\""), pwd,
+           GF("\""));
+      if (at->waitResponse() != 1) { return false; }
+
+      // Activate GPRS/CSD Context
+      at->sendAT(GF("+QIACT=1"));
+      if (at->waitResponse(150000L) != 1) { return false; }
+
+      at->sendAT(GF("+QSSLCFG="), GF("\"sslversion"),
+                 GF("\","), 0, GF(",4"));
+      if (!at->waitResponse())
+        return false;
+
+      at->sendAT(GF("+QSSLCFG="), GF("\"ciphersuite"),
+                 GF("\","), 0, GF(",0xffff"));
+      if (!at->waitResponse())
+        return false;
+
+      at->sendAT(GF("+QSSLCFG="), GF("\"seclevel"),
+                 GF("\","), 0, GF(",1"));
+      if (!at->waitResponse())
+        return false;
+
+      return true;
+    }
+
   };
-  */
 
   /*
    * Constructor
@@ -531,22 +660,36 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
  protected:
   bool modemConnect(const char* host, uint16_t port, uint8_t mux,
                     bool ssl = false, int timeout_s = 150) {
-    if (ssl) { DBG("SSL not yet supported on this module!"); }
 
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
 
-    // <PDPcontextID>(1-16), <connectID>(0-11),
-    // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
-    // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
-    sendAT(GF("+QIOPEN=1,"), mux, GF(",\""), GF("TCP"), GF("\",\""), host,
-           GF("\","), port, GF(",0,0"));
-    waitResponse();
+    if (ssl) {
+      //AT+QSSLOPEN=1,0,0,"220.180.239.201",8010,0
+      sendAT(GF("+QSSLOPEN=1,"), mux, GF(",0,\""), host,
+            GF("\","), port, GF(",0"));
+      waitResponse();
 
-    if (waitResponse(timeout_ms, GF(GSM_NL "+QIOPEN:")) != 1) { return false; }
+      if (waitResponse(timeout_ms, GF(GSM_NL "+QSSLOPEN:")) != 1) { return false; }
 
-    if (streamGetIntBefore(',') != mux) { return false; }
+      if (streamGetIntBefore(',') != 0) { return false; } //make sure client_id is 0
+
+    } else {
+      // AT+QIOPEN=1,0,"TCP","220.180.239.212",8009,0,0
+      // <PDPcontextID>(1-16), <connectID>(0-11),
+      // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
+      // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
+      sendAT(GF("+QIOPEN=1,"), mux, GF(",\""), GF("TCP"), GF("\",\""), host,
+            GF("\","), port, GF(",0,0"));
+      waitResponse();
+
+      if (waitResponse(timeout_ms, GF(GSM_NL "+QIOPEN:")) != 1) { return false; }
+
+      if (streamGetIntBefore(',') != mux) { return false; }
+
+    }
     // Read status
     return (0 == streamGetIntBefore('\n'));
+
   }
 
   int16_t modemSend(const void* buff, size_t len, uint8_t mux) {

From 69b8c400e88c3f8277dc5e10e85f7b266d21f0e0 Mon Sep 17 00:00:00 2001
From: Gonzalo Brusco <gonzabrusco@gmail.com>
Date: Mon, 4 Apr 2022 15:54:48 -0300
Subject: [PATCH 002/100] Fix NTPServerSync

---
 src/TinyGsmNTP.tpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/TinyGsmNTP.tpp b/src/TinyGsmNTP.tpp
index aaeda7e..7d0ca0d 100644
--- a/src/TinyGsmNTP.tpp
+++ b/src/TinyGsmNTP.tpp
@@ -32,7 +32,7 @@ class TinyGsmNTP {
     return true;
   }
 
-  byte NTPServerSync(String server = "pool.ntp.org", byte TimeZone = 3) {
+  byte NTPServerSync(String server = "pool.ntp.org", int TimeZone = 0) {
     return thisModem().NTPServerSyncImpl(server, TimeZone);
   }
   String ShowNTPError(byte error) {
@@ -54,7 +54,7 @@ class TinyGsmNTP {
    * NTP server functions
    */
  protected:
-  byte NTPServerSyncImpl(String server = "pool.ntp.org", byte TimeZone = 3) {
+  byte NTPServerSyncImpl(String server = "pool.ntp.org", int TimeZone = 0) {
     // Set GPRS bearer profile to associate with NTP sync
     // this may fail, it's not supported by all modules
     thisModem().sendAT(GF("+CNTPCID=1"));
@@ -68,6 +68,11 @@ class TinyGsmNTP {
     thisModem().sendAT(GF("+CNTP"));
     if (thisModem().waitResponse(10000L, GF("+CNTP:"))) {
       String result = thisModem().stream.readStringUntil('\n');
+      // Check for ',' in case the modules appends the time nexto to the return value.
+      int index = result.indexOf(',');
+      if(index > 0) {
+          result.remove(index);
+      }
       result.trim();
       if (TinyGsmIsValidNumber(result)) { return result.toInt(); }
     } else {

From 7f25e735e6bb91c3dd1ff10d02b793a2f7bf55cb Mon Sep 17 00:00:00 2001
From: Gonzalo Brusco <gonzabrusco@gmail.com>
Date: Mon, 4 Apr 2022 16:03:04 -0300
Subject: [PATCH 003/100] Fix typo

---
 src/TinyGsmNTP.tpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmNTP.tpp b/src/TinyGsmNTP.tpp
index 7d0ca0d..6ae23cc 100644
--- a/src/TinyGsmNTP.tpp
+++ b/src/TinyGsmNTP.tpp
@@ -68,7 +68,7 @@ class TinyGsmNTP {
     thisModem().sendAT(GF("+CNTP"));
     if (thisModem().waitResponse(10000L, GF("+CNTP:"))) {
       String result = thisModem().stream.readStringUntil('\n');
-      // Check for ',' in case the modules appends the time nexto to the return value.
+      // Check for ',' in case the module appends the time next to the return code. Eg: +CNTP: <code>[,<time>]
       int index = result.indexOf(',');
       if(index > 0) {
           result.remove(index);

From c4ada6ec5dd506feee7b2b3701677a73157c2924 Mon Sep 17 00:00:00 2001
From: Ben Garman <benjamin.garman@bbconsult.co.uk>
Date: Thu, 5 May 2022 14:41:24 +0100
Subject: [PATCH 004/100] Sim5320 GPS Location Update

---
 src/TinyGsmClientSIM5360.h | 102 +++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)

diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index f181036..006b7f9 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -17,6 +17,7 @@
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
+#include "TinyGsmGPS.tpp"
 #include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
 #include "TinyGsmSMS.tpp"
@@ -50,6 +51,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
                        public TinyGsmTime<TinyGsmSim5360>,
                        public TinyGsmNTP<TinyGsmSim5360>,
                        public TinyGsmGSMLocation<TinyGsmSim5360>,
+                       public TinyGsmGPS<TinyGsmSim5360>,
                        public TinyGsmBattery<TinyGsmSim5360>,
                        public TinyGsmTemperature<TinyGsmSim5360> {
   friend class TinyGsmModem<TinyGsmSim5360>;
@@ -59,6 +61,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   friend class TinyGsmTime<TinyGsmSim5360>;
   friend class TinyGsmNTP<TinyGsmSim5360>;
   friend class TinyGsmGSMLocation<TinyGsmSim5360>;
+  friend class TinyGsmGPS<TinyGsmSim5360>;
   friend class TinyGsmBattery<TinyGsmSim5360>;
   friend class TinyGsmTemperature<TinyGsmSim5360>;
 
@@ -410,6 +413,105 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     return true;
   }
 
+  /*
+   * GPS location functions
+   */
+ protected:
+  // enable GPS
+  bool enableGPSImpl() {
+    sendAT(GF("+CGPS=1"));
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+
+  bool disableGPSImpl() {
+    sendAT(GF("+CGPS=0"));
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+
+  // get the RAW GPS output
+  String getGPSrawImpl() {
+    sendAT(GF("+CGPSINFO"));
+    if (waitResponse(GF(GSM_NL "+CGPSINFO:")) != 1) { return ""; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.trim();
+    return res;
+  }
+
+  // get GPS informations
+  bool getGPSImpl(float* lat, float* lon, float* speed = 0, float* alt = 0,
+                  int* vsat = 0, int* usat = 0, float* accuracy = 0,
+                  int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
+                  int* minute = 0, int* second = 0) {
+    sendAT(GF("+CGPSINFO"));
+    if (waitResponse(GF(GSM_NL "+CGPSINFO:")) != 1) { return false; }
+    delay(30);
+   
+    float ilat = 0;
+    char  north;
+    float ilon = 0;
+    char  east;
+    float ispeed       = 0;
+    float ialt         = 0;
+    int   ivsat        = 0;
+    int   iusat        = 0;
+    int   iyear        = 0;
+    int   imonth       = 0;
+    int   iday         = 0;
+    int   ihour        = 0;
+    int   imin         = 0;
+    float secondWithSS = 0;
+
+    ilat  = streamGetFloatBefore(',');  // Latitude in ddmm.mmmmmm
+    north = stream.read();              // N/S Indicator, N=north or S=south
+    streamSkipUntil(',');               // BEIDOU satellite valid numbers
+    ilon = streamGetFloatBefore(',');  // Longitude in dddmm.mmmmmm
+    east = stream.read();              // E/W Indicator, E=east or W=west
+    streamSkipUntil(',');               // BEIDOU satellite valid numbers
+
+    // Date. Output format is ddmmyy
+    iday   = streamGetIntLength(2);    // Two digit day
+    imonth = streamGetIntLength(2);    // Two digit month
+    iyear  = streamGetIntBefore(',');  // Two digit year
+
+    // UTC Time. Output format is hhmmss.s
+    ihour = streamGetIntLength(2);  // Two digit hour
+    imin  = streamGetIntLength(2);  // Two digit minute
+    secondWithSS = streamGetFloatBefore(',');  // 4 digit second with subseconds
+
+    ialt   = streamGetFloatBefore(',');  // MSL Altitude. Unit is meters
+    ispeed = streamGetFloatBefore(',');  // Speed Over Ground. Unit is knots.
+
+    if(ilat != -9999.0F){
+      if (lat != NULL)
+        *lat = (floor(ilat / 100) + fmod(ilat, 100.) / 60) *
+            (north == 'N' ? 1 : -1);
+      if (lon != NULL)
+        *lon = (floor(ilon / 100) + fmod(ilon, 100.) / 60) *
+            (east == 'E' ? 1 : -1);
+      if (speed != NULL) *speed = ispeed;
+      if (alt != NULL) *alt = ialt;
+      if (vsat != NULL) *vsat = ivsat;
+      if (usat != NULL) *usat = iusat;
+      if (iyear < 2000) iyear += 2000;
+      if (year != NULL) *year = iyear;
+      if (month != NULL) *month = imonth;
+      if (day != NULL) *day = iday;
+      if (hour != NULL) *hour = ihour;
+      if (minute != NULL) *minute = imin;
+      if (second != NULL) *second = static_cast<int>(secondWithSS);
+
+      waitResponse();
+      return true;
+    }
+    
+    waitResponse();
+    return false;
+    
+  }
+
   /*
    * SIM card functions
    */

From 8884b91cd57eb27738b59fb07851e07d0752b206 Mon Sep 17 00:00:00 2001
From: Bengarman <benj.garman@gmail.com>
Date: Thu, 5 May 2022 14:59:02 +0100
Subject: [PATCH 005/100] Update library.json

---
 library.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library.json b/library.json
index 06f4172..9c482ec 100644
--- a/library.json
+++ b/library.json
@@ -1,11 +1,11 @@
 {
   "name": "TinyGSM",
-  "version": "0.11.5",
+  "version": "0.11.5.1",
   "description": "A small Arduino library for GPRS modules, that just works. Includes examples for Blynk, MQTT, File Download, and Web Client. Supports many GSM, LTE, and WiFi modules with AT command interfaces.",
   "keywords": "GSM, AT commands, AT, SIM800, SIM900, A6, A7, M590, ESP8266, SIM7000, SIM800A, SIM800C, SIM800L, SIM800H, SIM808, SIM868, SIM900A, SIM900D, SIM908, SIM968, M95, MC60, MC60E, BG96, ublox, Quectel, SIMCOM, AI Thinker, LTE, LTE-M",
   "authors": [
     {
-      "name": "Volodymyr Shymanskyy",
+      "name": "Ben Garman",
       "url": "https://github.com/vshymanskyy",
       "maintainer": true
     }

From 7dc2caf9ef016802a37350944828049c0e5fcaab Mon Sep 17 00:00:00 2001
From: github0013 <github0013@gmail.com>
Date: Wed, 24 Aug 2022 13:11:28 +0900
Subject: [PATCH 006/100] password then user when cid is set

https://www.simcom.com/product/SIM7600X-PCIE.html
SIM7500_SIM7600 Series_AT Command Manual_V3.00

- AT+CGAUTH=<cid>[,<auth_type>[,<passwd>[,<user>]]]
- AT+CGAUTH=,,<user>,<passwd> (for CDMA1x-EvDo)

If not CDMA1, password should come first.
---
 src/TinyGsmClientSIM7600.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 9f47c5d..de74cb5 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -316,7 +316,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
 
     // Set the external authentication
     if (user && strlen(user) > 0) {
-      sendAT(GF("+CGAUTH=1,0,\""), user, GF("\",\""), pwd, '"');
+      sendAT(GF("+CGAUTH=1,0,\""), pwd, GF("\",\""), user, '"');
       waitResponse();
     }
 

From 00b2446945b86188598e59d16dd99e3223920210 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Tue, 4 Oct 2022 17:27:16 -0300
Subject: [PATCH 007/100] mqtt sending ok

---
 src/TinyGsmClient.h       |   6 +
 src/TinyGsmClientA7672x.h | 694 ++++++++++++++++++++++++++++++++++++++
 src/TinyGsmGPRS.tpp       |  14 +
 3 files changed, 714 insertions(+)
 create mode 100644 src/TinyGsmClientA7672x.h

diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index a8ae763..0eaae63 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -114,6 +114,12 @@ typedef TinyGsmSequansMonarch::GsmClientSequansMonarch TinyGsmClient;
 typedef TinyGsmSequansMonarch::GsmClientSecureSequansMonarch
     TinyGsmClientSecure;
 
+#elif defined(TINY_GSM_MODEM_A7672X)
+#include "TinyGsmClientA7672X.h"
+typedef TinyGsmA7672X                  TinyGsm;
+typedef TinyGsmA7672X::GsmClientA7672X TinyGsmClient;
+// typedef TinyGsmA7672X::GsmClientSecureA7672X TinyGsmClientSecure; //TODO
+
 #else
 #error "Please define GSM modem model"
 #endif
diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
new file mode 100644
index 0000000..cf5a0b0
--- /dev/null
+++ b/src/TinyGsmClientA7672x.h
@@ -0,0 +1,694 @@
+/**
+ * @file       TinyGsmClientA7672x.h
+ * @author     Giovanni de Rosso Unruh
+ * @license    LGPL-3.0
+ * @copyright  Copyright (c) 2022 Giovanni de Rosso Unruh
+ * @date       Oct 2022
+ */
+
+#ifndef SRC_TINYGSMCLIENTA7672X_H_
+#define SRC_TINYGSMCLIENTA7672X_H_
+
+// #define TINY_GSM_DEBUG Serial
+// #define TINY_GSM_USE_HEX
+
+#define TINY_GSM_MUX_COUNT 10
+#define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmModem.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmTCP.tpp"
+#include "TinyGsmTime.tpp"
+#include "TinyGsmNTP.tpp"
+
+#define GSM_NL "\r\n"
+static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
+static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
+#if defined       TINY_GSM_DEBUG
+static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
+static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
+#endif
+
+enum RegStatus {
+  REG_NO_RESULT    = -1,
+  REG_UNREGISTERED = 0,
+  REG_SEARCHING    = 2,
+  REG_DENIED       = 3,
+  REG_OK_HOME      = 1,
+  REG_OK_ROAMING   = 5,
+  REG_UNKNOWN      = 4,
+};
+class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
+                      public TinyGsmGPRS<TinyGsmA7672X>,
+                      public TinyGsmTCP<TinyGsmA7672X, TINY_GSM_MUX_COUNT>,
+                      public TinyGsmSSL<TinyGsmA7672X>,
+                      public TinyGsmCalling<TinyGsmA7672X>,
+                      public TinyGsmSMS<TinyGsmA7672X>,
+                      public TinyGsmGSMLocation<TinyGsmA7672X>,
+                      public TinyGsmTime<TinyGsmA7672X>,
+                      public TinyGsmNTP<TinyGsmA7672X>,
+                      public TinyGsmBattery<TinyGsmA7672X> {
+  friend class TinyGsmModem<TinyGsmA7672X>;
+  friend class TinyGsmGPRS<TinyGsmA7672X>;
+  friend class TinyGsmTCP<TinyGsmA7672X, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmSSL<TinyGsmA7672X>;
+  friend class TinyGsmCalling<TinyGsmA7672X>;
+  friend class TinyGsmSMS<TinyGsmA7672X>;
+  friend class TinyGsmGSMLocation<TinyGsmA7672X>;
+  friend class TinyGsmTime<TinyGsmA7672X>;
+  friend class TinyGsmNTP<TinyGsmA7672X>;
+  friend class TinyGsmBattery<TinyGsmA7672X>;
+
+  /*
+   * Inner Client
+   */
+ public:
+  class GsmClientA7672X : public GsmClient {
+    friend class TinyGsmA7672X;
+
+   public:
+    GsmClientA7672X() {}
+
+    explicit GsmClientA7672X(TinyGsmA7672X& modem, uint8_t mux = 0) {
+      init(&modem, mux);
+    }
+
+    bool init(TinyGsmA7672X* modem, uint8_t mux = 0) {
+      this->at       = modem;
+      sock_available = 0;
+      prev_check     = 0;
+      sock_connected = false;
+      got_data       = false;
+
+      if (mux < TINY_GSM_MUX_COUNT) {
+        this->mux = mux;
+      } else {
+        this->mux = (mux % TINY_GSM_MUX_COUNT);
+      }
+      at->sockets[this->mux] = this;
+
+      return true;
+    }
+
+   public:
+    virtual int connect(const char* host, uint16_t port, int timeout_s) {
+      stop();
+      TINY_GSM_YIELD();
+      rx.clear();
+      sock_connected = at->modemConnect(host, port, mux, false, timeout_s);
+      return sock_connected;
+    }
+    TINY_GSM_CLIENT_CONNECT_OVERRIDES
+
+    void stop(uint32_t maxWaitMs) {
+      dumpModemBuffer(maxWaitMs);
+      at->sendAT(GF("+CIPCLOSE="), mux, GF(",1"));  // Quick close
+      sock_connected = false;
+      at->waitResponse();
+    }
+    void stop() override {
+      stop(15000L);
+    }
+
+    /*
+     * Extended API
+     */
+
+    String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  };
+
+  /*
+   * Inner Secure Client
+   */
+ public:
+  class GsmClientSecureSim800 : public GsmClientA7672X {
+   public:
+    GsmClientSecureSim800() {}
+
+    explicit GsmClientSecureSim800(TinyGsmA7672X& modem, uint8_t mux = 0)
+        : GsmClientA7672X(modem, mux) {}
+
+   public:
+    int connect(const char* host, uint16_t port, int timeout_s) override {
+      stop();
+      TINY_GSM_YIELD();
+      rx.clear();
+      sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
+      return sock_connected;
+    }
+    TINY_GSM_CLIENT_CONNECT_OVERRIDES
+  };
+
+  /*
+   * Constructor
+   */
+ public:
+  explicit TinyGsmA7672X(Stream& stream) : stream(stream) {
+    memset(sockets, 0, sizeof(sockets));
+  }
+
+  /*
+   * Basic functions
+   */
+ protected:
+  bool initImpl(const char* pin = NULL) {
+    DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
+    DBG(GF("### TinyGSM Compiled Module:  A7672X"));
+
+    if (!testAT()) { return false; }
+
+    // sendAT(GF("&FZ"));  // Factory + Reset
+    // waitResponse();
+
+    sendAT(GF("E0"));  // Echo Off
+    if (waitResponse() != 1) { return false; }
+
+#ifdef TINY_GSM_DEBUG
+    sendAT(GF("V1"));  // turn on verbose error codes
+#else
+    sendAT(GF("V0"));  // turn off error codes
+#endif
+    waitResponse();
+
+    DBG(GF("### Modem:"), getModemName());
+
+    SimStatus ret = getSimStatus();
+    // if the sim isn't ready and a pin has been provided, try to unlock the sim
+    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+      simUnlock(pin);
+      return (getSimStatus() == SIM_READY);
+    } else {
+      // if the sim is ready, or it's locked but no pin has been provided,
+      // return true
+      return (ret == SIM_READY || ret == SIM_LOCKED);
+    }
+  }
+
+  String getModemNameImpl() {
+    String name = "A7672SA-LASE";
+
+    sendAT(GF("+CGMM"));
+    String res2;
+    if (waitResponse(1000L, res2) != 1) { return name; }
+    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace("_", " ");
+    res2.trim();
+
+    name = res2;
+    DBG("### Modem:", name);
+    return name;
+  }
+
+  bool factoryDefaultImpl() {
+    sendAT(GF("&FZE0&W"));  // Factory + Reset + Echo Off + Write
+    waitResponse();
+    sendAT(GF("+IPR=0"));  // Auto-baud
+    waitResponse();
+    sendAT(GF("+IFC=0,0"));  // No Flow Control
+    waitResponse();
+    sendAT(GF("+ICF=3,3"));  // 8 data 0 parity 1 stop
+    waitResponse();
+    sendAT(GF("+CSCLK=0"));  // Disable Slow Clock
+    waitResponse();
+    sendAT(GF("&W"));  // Write configuration
+    return waitResponse() == 1;
+  }
+
+  /*
+    bool thisHasSSL() {
+  #if defined(TINY_GSM_MODEM_SIM900)
+      return false;
+  #else
+      sendAT(GF("+CIPSSL=?"));
+      if (waitResponse(GF(GSM_NL "+CIPSSL:")) != 1) { return false; }
+      return waitResponse() == 1;
+  #endif
+    }
+    */
+
+  /*
+   * Power functions
+   */
+ protected:
+  bool restartImpl(const char* pin = NULL) {
+    if (!testAT()) { return false; }
+    sendAT(GF("&W"));
+    waitResponse();
+    if (!setPhoneFunctionality(0)) { return false; }
+    if (!setPhoneFunctionality(1, true)) { return false; }
+    delay(3000);
+    return init(pin);
+  }
+
+  bool powerOffImpl() {
+    sendAT(GF("+CPOWD=1"));
+    return waitResponse(10000L, GF("NORMAL POWER DOWN")) == 1;
+  }
+
+  // During sleep, the SIM800 module has its serial communication disabled. In
+  // order to reestablish communication pull the DRT-pin of the SIM800 module
+  // LOW for at least 50ms. Then use this function to disable sleep mode. The
+  // DTR-pin can then be released again.
+  bool sleepEnableImpl(bool enable = true) {
+    sendAT(GF("+CSCLK="), enable);
+    return waitResponse() == 1;
+  }
+
+  // <fun> 0 Minimum functionality
+  // <fun> 1 Full functionality (Default)
+  // <fun> 4 Disable phone both transmit and receive RF circuits.
+  // <rst> Reset the MT before setting it to <fun> power level.
+  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false) {
+    sendAT(GF("+CFUN="), fun, reset ? ",1" : "");
+    return waitResponse(10000L) == 1;
+  }
+
+  /*
+   * Generic network functions
+   */
+ public:
+  RegStatus getRegistrationStatus() {
+    return (RegStatus)getRegistrationStatusXREG("CREG");
+  }
+
+ protected:
+  bool isNetworkConnectedImpl() {
+    RegStatus s = getRegistrationStatus();
+    return (s == REG_OK_HOME || s == REG_OK_ROAMING);
+  }
+
+  /*
+   * GPRS functions
+   */
+ protected:
+  bool gprsConnectImpl(const char* apn, const char* user = NULL,
+                       const char* pwd = NULL) {
+    gprsDisconnect();
+
+    // Define the PDP context
+    sendAT(GF("+CGDCONT=1,\"IP\",\""), apn, '"');
+    waitResponse();
+
+    // Activate the PDP context
+    sendAT(GF("+CGACT=1,1"));
+    waitResponse(60000L);
+
+    // Attach to GPRS
+    sendAT(GF("+CGATT=1"));
+    if (waitResponse(60000L) != 1) { return false; }
+
+    // Set to get data manually
+    sendAT(GF("+CIPRXGET=1"));
+    if (waitResponse() != 1) { return false; }
+
+    // Get Local IP Address, only assigned after connection
+    sendAT(GF("+CGPADDR=1"));
+    if (waitResponse(10000L) != 1) { return false; }
+
+    // Configure Domain Name Server (DNS)
+    sendAT(GF("+CDNSCFG=\"8.8.8.8\",\"8.8.4.4\""));
+    if (waitResponse() != 1) { return false; }
+
+    return true;
+  }
+
+  bool gprsDisconnectImpl() {
+    // Shut the TCP/IP connection
+    // CIPSHUT will close *all* open connections
+    sendAT(GF("+NETCLOSE"));
+    if (waitResponse(60000L) != 1) { return false; }
+
+    sendAT(GF("+CGATT=0"));  // Detach from GPRS
+    if (waitResponse(60000L) != 1) { return false; }
+
+    return true;
+  }
+
+  /*
+   * SIM card functions
+   */
+ protected:
+  String getSimCCIDImpl() {
+    sendAT(GF("+CICCID"));
+    if (waitResponse(GF(GSM_NL "+ICCID:")) != 1) { return ""; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.trim();
+    return res;
+  }
+
+  /*
+   * Phone Call functions
+   */
+ public:
+  bool setGsmBusy(bool busy = true) {
+    sendAT(GF("+GSMBUSY="), busy ? 1 : 0);
+    return waitResponse() == 1;
+  }
+
+  /*
+   * Messaging functions
+   */
+ protected:
+  // Follows all messaging functions per template
+
+  /*
+   * GSM Location functions
+   */
+ protected:
+  // Depending on the exacty model and firmware revision, should return a
+  // GSM-based location from CLBS as per the template
+  // TODO(?):  Check number of digits in year (2 or 4)
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+ protected:
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+ public:
+  bool setVolume(uint8_t volume = 50) {
+    // Set speaker volume
+    sendAT(GF("+CLVL="), volume);
+    return waitResponse() == 1;
+  }
+
+  uint8_t getVolume() {
+    // Get speaker volume
+    sendAT(GF("+CLVL?"));
+    if (waitResponse(GF(GSM_NL)) != 1) { return 0; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.replace("+CLVL:", "");
+    res.trim();
+    return res.toInt();
+  }
+
+  bool setMicVolume(uint8_t channel, uint8_t level) {
+    if (channel > 4) { return 0; }
+    sendAT(GF("+CMIC="), level);
+    return waitResponse() == 1;
+  }
+
+  bool setAudioChannel(uint8_t channel) {
+    sendAT(GF("+CHFA="), channel);
+    return waitResponse() == 1;
+  }
+
+  bool playToolkitTone(uint8_t tone, uint32_t duration) {
+    sendAT(GF("STTONE="), 1, tone);
+    delay(duration);
+    sendAT(GF("STTONE="), 0);
+    return waitResponse();
+  }
+
+  /*
+   * Time functions
+   */
+ protected:
+  // Can follow the standard CCLK function in the template
+
+  /*
+   * NTP server functions
+   */
+  // Can sync with server using CNTP as per template
+
+  /*
+   * Battery functions
+   */
+ protected:
+  // Follows all battery functions per template
+
+  /*
+   * NTP server functions
+   */
+  // Can sync with server using CNTP as per template
+
+  /*
+   * Client related functions
+   */
+ protected:
+  bool modemConnect(const char* host, uint16_t port, uint8_t mux,
+                    bool ssl = false, int timeout_s = 75) {
+    int8_t   rsp;
+    uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
+
+    sendAT(GF("+CTCPKA=1,2,5,1"));
+    if (waitResponse(2000L) != 1) { return false; }
+
+    // sendAT(GF("+CIPMODE=1")); //todo
+    // if (waitResponse(2000L) != 1) { return false; }
+
+    sendAT(GF("+NETOPEN"));
+    if (waitResponse(2000L) != 1) { return false; }
+
+    sendAT(GF("+NETOPEN?"));
+    if (waitResponse(2000L, GF("+NETOPEN: 1")) != 1) { return false; }
+
+    sendAT(GF("+CIPOPEN="), 0, ',', GF("\"TCP"), GF("\",\""), host, GF("\","),
+           port);
+
+    rsp = waitResponse(
+        timeout_ms, GF("+CIPOPEN: 0,0" GSM_NL), GF("+CIPOPEN: 0,1" GSM_NL),
+        GF("+CIPOPEN: 0,4" GSM_NL), GF("ERROR" GSM_NL),
+        GF("CLOSE OK" GSM_NL));  // Happens when HTTPS handshake fails
+    return (1 == rsp);
+  }
+
+  int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
+    sendAT(GF("+CIPSEND="), mux, ',', (uint16_t)len);
+    if (waitResponse(GF(">")) != 1) { return 0; }
+    stream.write(reinterpret_cast<const uint8_t*>(buff), len);
+    stream.flush();
+    if (waitResponse(GF(GSM_NL "DATA ACCEPT:")) != 1) { return 0; }
+    streamSkipUntil(',');  // Skip mux
+    return streamGetIntBefore('\n');
+  }
+
+  size_t modemRead(size_t size, uint8_t mux) {
+    if (!sockets[mux]) return 0;
+#ifdef TINY_GSM_USE_HEX
+    sendAT(GF("+CIPRXGET=3,"), mux, ',', (uint16_t)size);
+    if (waitResponse(GF("+CIPRXGET:")) != 1) { return 0; }
+#else
+    sendAT(GF("+CIPRXGET=2,"), mux, ',', (uint16_t)size);
+    if (waitResponse(GF("+CIPRXGET:")) != 1) { return 0; }
+#endif
+    streamSkipUntil(',');  // Skip Rx mode 2/normal or 3/HEX
+    streamSkipUntil(',');  // Skip mux
+    int16_t len_requested = streamGetIntBefore(',');
+    //  ^^ Requested number of data bytes (1-1460 bytes)to be read
+    int16_t len_confirmed = streamGetIntBefore('\n');
+    // ^^ Confirmed number of data bytes to be read, which may be less than
+    // requested. 0 indicates that no data can be read.
+    // SRGD NOTE:  Contrary to above (which is copied from AT command manual)
+    // this is actually be the number of bytes that will be remaining in the
+    // buffer after the read.
+    for (int i = 0; i < len_requested; i++) {
+      uint32_t startMillis = millis();
+#ifdef TINY_GSM_USE_HEX
+      while (stream.available() < 2 &&
+             (millis() - startMillis < sockets[mux]->_timeout)) {
+        TINY_GSM_YIELD();
+      }
+      char buf[4] = {
+          0,
+      };
+      buf[0] = stream.read();
+      buf[1] = stream.read();
+      char c = strtol(buf, NULL, 16);
+#else
+      while (!stream.available() &&
+             (millis() - startMillis < sockets[mux]->_timeout)) {
+        TINY_GSM_YIELD();
+      }
+      char c = stream.read();
+#endif
+      sockets[mux]->rx.put(c);
+    }
+    // DBG("### READ:", len_requested, "from", mux);
+    // sockets[mux]->sock_available = modemGetAvailable(mux);
+    sockets[mux]->sock_available = len_confirmed;
+    waitResponse();
+    return len_requested;
+  }
+
+  size_t modemGetAvailable(uint8_t mux) {
+    if (!sockets[mux]) return 0;
+    sendAT(GF("+CIPRXGET=4,"), mux);
+    size_t result = 0;
+    if (waitResponse(GF("+CIPRXGET:")) == 1) {
+      streamSkipUntil(',');  // Skip mode 4
+      streamSkipUntil(',');  // Skip mux
+      result = streamGetIntBefore('\n');
+      waitResponse();
+    }
+    // DBG("### Available:", result, "on", mux);
+    if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
+    return result;
+  }
+
+  bool modemGetConnected(uint8_t mux) {
+    sendAT(GF("+CIPSTATUS="), mux);
+    waitResponse(GF("+CIPSTATUS"));
+    int8_t res = waitResponse(GF(",\"CONNECTED\""), GF(",\"CLOSED\""),
+                              GF(",\"CLOSING\""), GF(",\"REMOTE CLOSING\""),
+                              GF(",\"INITIAL\""));
+    waitResponse();
+    return 1 == res;
+  }
+
+  /*
+   * Utilities
+   */
+ public:
+  // TODO(vshymanskyy): Optimize this!
+  int8_t waitResponse(uint32_t timeout_ms, String& data,
+                      GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    /*String r1s(r1); r1s.trim();
+    String r2s(r2); r2s.trim();
+    String r3s(r3); r3s.trim();
+    String r4s(r4); r4s.trim();
+    String r5s(r5); r5s.trim();
+    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
+    data.reserve(64);
+    uint8_t  index       = 0;
+    uint32_t startMillis = millis();
+    do {
+      TINY_GSM_YIELD();
+      while (stream.available() > 0) {
+        TINY_GSM_YIELD();
+        int8_t a = stream.read();
+        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
+        data += static_cast<char>(a);
+        if (r1 && data.endsWith(r1)) {
+          index = 1;
+          goto finish;
+        } else if (r2 && data.endsWith(r2)) {
+          index = 2;
+          goto finish;
+        } else if (r3 && data.endsWith(r3)) {
+#if defined TINY_GSM_DEBUG
+          if (r3 == GFP(GSM_CME_ERROR)) {
+            streamSkipUntil('\n');  // Read out the error
+          }
+#endif
+          index = 3;
+          goto finish;
+        } else if (r4 && data.endsWith(r4)) {
+          index = 4;
+          goto finish;
+        } else if (r5 && data.endsWith(r5)) {
+          index = 5;
+          goto finish;
+        } else if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+          int8_t mode = streamGetIntBefore(',');
+          if (mode == 1) {
+            int8_t mux = streamGetIntBefore('\n');
+            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+              sockets[mux]->got_data = true;
+            }
+            data = "";
+            // DBG("### Got Data:", mux);
+          } else {
+            data += mode;
+          }
+        } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+          int8_t  mux = streamGetIntBefore(',');
+          int16_t len = streamGetIntBefore('\n');
+          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+            sockets[mux]->got_data = true;
+            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
+          }
+          data = "";
+          // DBG("### Got Data:", len, "on", mux);
+        } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
+          int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+          int8_t coma = data.indexOf(',', nl + 2);
+          int8_t mux  = data.substring(nl + 2, coma).toInt();
+          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+            sockets[mux]->sock_connected = false;
+          }
+          data = "";
+          DBG("### Closed: ", mux);
+        } else if (data.endsWith(GF("*PSNWID:"))) {
+          streamSkipUntil('\n');  // Refresh network name by network
+          data = "";
+          DBG("### Network name updated.");
+        } else if (data.endsWith(GF("*PSUTTZ:"))) {
+          streamSkipUntil('\n');  // Refresh time and time zone by network
+          data = "";
+          DBG("### Network time and time zone updated.");
+        } else if (data.endsWith(GF("+CTZV:"))) {
+          streamSkipUntil('\n');  // Refresh network time zone by network
+          data = "";
+          DBG("### Network time zone updated.");
+        } else if (data.endsWith(GF("DST:"))) {
+          streamSkipUntil(
+              '\n');  // Refresh Network Daylight Saving Time by network
+          data = "";
+          DBG("### Daylight savings time state updated.");
+        }
+      }
+    } while (millis() - startMillis < timeout_ms);
+  finish:
+    if (!index) {
+      data.trim();
+      if (data.length()) { DBG("### Unhandled:", data); }
+      data = "";
+    }
+    // data.replace(GSM_NL, "/");
+    // DBG('<', index, '>', data);
+    return index;
+  }
+
+  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    String data;
+    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
+  }
+
+  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    return waitResponse(1000, r1, r2, r3, r4, r5);
+  }
+
+ public:
+  Stream& stream;
+
+ protected:
+  GsmClientA7672X* sockets[TINY_GSM_MUX_COUNT];
+  const char*      gsmNL = GSM_NL;
+};
+
+#endif  // SRC_TINYGSMCLIENTA7672X_H_
diff --git a/src/TinyGsmGPRS.tpp b/src/TinyGsmGPRS.tpp
index c3ad5e0..2941c95 100644
--- a/src/TinyGsmGPRS.tpp
+++ b/src/TinyGsmGPRS.tpp
@@ -65,6 +65,11 @@ class TinyGsmGPRS {
     return thisModem().getOperatorImpl();
   }
 
+  // Gets the current network provider
+  String getProvider() {
+    return thisModem().getProviderImpl();
+  }
+
   /*
    * CRTP Helper
    */
@@ -166,6 +171,15 @@ class TinyGsmGPRS {
     thisModem().waitResponse();
     return res;
   }
+
+  String getProviderImpl() {
+    thisModem().sendAT(GF("+CSPN?"));
+    if (thisModem().waitResponse(GF("+CSPN:")) != 1) { return ""; }
+    thisModem().streamSkipUntil('"'); /* Skip mode and format */
+    String res = thisModem().stream.readStringUntil('"');
+    thisModem().waitResponse();
+    return res;
+  }
 };
 
 #endif  // SRC_TINYGSMGPRS_H_

From 7fb7926eaee42ef7bec5df2e6f48af8e29036bd1 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Thu, 6 Oct 2022 17:04:20 -0300
Subject: [PATCH 008/100] A7672X SSL ok

---
 src/TinyGsmClient.h       |   6 +-
 src/TinyGsmClientA7672x.h | 317 +++++++++++++++++++++++++++-----------
 2 files changed, 231 insertions(+), 92 deletions(-)

diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index 0eaae63..08644a6 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -116,9 +116,9 @@ typedef TinyGsmSequansMonarch::GsmClientSecureSequansMonarch
 
 #elif defined(TINY_GSM_MODEM_A7672X)
 #include "TinyGsmClientA7672X.h"
-typedef TinyGsmA7672X                  TinyGsm;
-typedef TinyGsmA7672X::GsmClientA7672X TinyGsmClient;
-// typedef TinyGsmA7672X::GsmClientSecureA7672X TinyGsmClientSecure; //TODO
+typedef TinyGsmA7672X                        TinyGsm;
+typedef TinyGsmA7672X::GsmClientA7672X       TinyGsmClient;
+typedef TinyGsmA7672X::GsmClientSecureA7672X TinyGsmClientSecure;
 
 #else
 #error "Please define GSM modem model"
diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index cf5a0b0..a2c525a 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -107,7 +107,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 
     void stop(uint32_t maxWaitMs) {
       dumpModemBuffer(maxWaitMs);
-      at->sendAT(GF("+CIPCLOSE="), mux, GF(",1"));  // Quick close
+      at->sendAT(GF("+CIPCLOSE="), mux);  //, GF(",1"));  // Quick close
       sock_connected = false;
       at->waitResponse();
     }
@@ -126,14 +126,22 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Inner Secure Client
    */
  public:
-  class GsmClientSecureSim800 : public GsmClientA7672X {
+  class GsmClientSecureA7672X : public GsmClientA7672X {
    public:
-    GsmClientSecureSim800() {}
+    GsmClientSecureA7672X() {}
 
-    explicit GsmClientSecureSim800(TinyGsmA7672X& modem, uint8_t mux = 0)
+    explicit GsmClientSecureA7672X(TinyGsmA7672X& modem, uint8_t mux = 0)
         : GsmClientA7672X(modem, mux) {}
 
    public:
+    bool setCertificate(const String& certificateName, const uint8_t len) {
+      return at->setCertificate(certificateName, len);
+    }
+
+    bool deleteCertificate(const String& certificateName) {
+      return at->deleteCertificate(certificateName);
+    }
+
     int connect(const char* host, uint16_t port, int timeout_s) override {
       stop();
       TINY_GSM_YIELD();
@@ -142,6 +150,16 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
       return sock_connected;
     }
     TINY_GSM_CLIENT_CONNECT_OVERRIDES
+
+    void stop(uint32_t maxWaitMs) {
+      dumpModemBuffer(maxWaitMs);
+      at->sendAT(GF("+CCHCLOSE="), mux);  //, GF(",1"));  // Quick close
+      sock_connected = false;
+      at->waitResponse();
+    }
+    void stop() override {
+      stop(15000L);
+    }
   };
 
   /*
@@ -175,10 +193,14 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 #endif
     waitResponse();
 
+    // sendAT(GF("X4"));
+    // waitResponse();
+
     DBG(GF("### Modem:"), getModemName());
 
     SimStatus ret = getSimStatus();
-    // if the sim isn't ready and a pin has been provided, try to unlock the sim
+    // if the sim isn't ready and a pin has been provided, try to unlock the
+    // sim
     if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
@@ -219,18 +241,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return waitResponse() == 1;
   }
 
-  /*
-    bool thisHasSSL() {
-  #if defined(TINY_GSM_MODEM_SIM900)
-      return false;
-  #else
-      sendAT(GF("+CIPSSL=?"));
-      if (waitResponse(GF(GSM_NL "+CIPSSL:")) != 1) { return false; }
-      return waitResponse() == 1;
-  #endif
-    }
-    */
-
   /*
    * Power functions
    */
@@ -250,8 +260,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return waitResponse(10000L, GF("NORMAL POWER DOWN")) == 1;
   }
 
-  // During sleep, the SIM800 module has its serial communication disabled. In
-  // order to reestablish communication pull the DRT-pin of the SIM800 module
+  // During sleep, the A7672X module has its serial communication disabled. In
+  // order to reestablish communication pull the DRT-pin of the A7672X module
   // LOW for at least 50ms. Then use this function to disable sleep mode. The
   // DTR-pin can then be released again.
   bool sleepEnableImpl(bool enable = true) {
@@ -276,12 +286,42 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return (RegStatus)getRegistrationStatusXREG("CREG");
   }
 
+  String getLocalIPImpl() {
+    if (hasSSL) {
+      sendAT(GF("+CCHADDR"));
+      if (waitResponse(GF("+CCHADDR:")) != 1) { return ""; }
+    } else {
+      sendAT(GF("+CGPADDR=1"));
+      if (waitResponse(GF("+CGPADDR:")) != 1) { return ""; }
+    }
+    streamSkipUntil(',');  // Skip context id
+    String res = stream.readStringUntil('\r');
+    if (waitResponse() != 1) { return ""; }
+    return res;
+  }
+
  protected:
   bool isNetworkConnectedImpl() {
     RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
+  /*
+   * Secure socket layer functions
+   */
+ protected:
+  // The name of the certificate/key/password file. The file name must
+  // havetype like ".pem" or ".der".
+  bool setCertificate(const String& certificateName, const uint8_t len) {
+    sendAT(GF("+CCERTDOWN="), certificateName, GF(","), len);
+    return waitResponse() == 1;
+  }
+
+  bool deleteCertificate(const String& certificateName) {
+    sendAT(GF("+CCERTDELE="), certificateName);
+    return waitResponse() == 1;
+  }
+
   /*
    * GPRS functions
    */
@@ -441,80 +481,142 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     int8_t   rsp;
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
 
-    sendAT(GF("+CTCPKA=1,2,5,1"));
+    sendAT(GF("+CTCPKA=1,2,5,1"));  // todo: here?
     if (waitResponse(2000L) != 1) { return false; }
 
-    // sendAT(GF("+CIPMODE=1")); //todo
-    // if (waitResponse(2000L) != 1) { return false; }
+    if (ssl) {
+      hasSSL = true;
+      // set the ssl version
+      // AT+CSSLCFG="sslversion",<ssl_ctx_index>,<sslversion>
+      // <ctxindex> PDP context identifier
+      // <sslversion> 0: QAPI_NET_SSL_PROTOCOL_UNKNOWN
+      //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
+      //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
+      //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
+      //              4: QAPI_NET_SSL_PROTOCOL_DTLS_1_0
+      //              5: QAPI_NET_SSL_PROTOCOL_DTLS_1_2
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+CSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
+      if (waitResponse(5000L) != 1) return false;
 
-    sendAT(GF("+NETOPEN"));
-    if (waitResponse(2000L) != 1) { return false; }
 
-    sendAT(GF("+NETOPEN?"));
-    if (waitResponse(2000L, GF("+NETOPEN: 1")) != 1) { return false; }
+      if (certificates[mux] != "") {
+        /* Configure the server root CA of the specified SSL context
+        AT + CSSLCFG = "cacert", <ssl_ ctx_index>,<ca_file> */
+        sendAT(GF("+CASSLCFG=\"cacert\",0,"), certificates[mux].c_str());
+        if (waitResponse(5000L) != 1) return false;
+      }
 
-    sendAT(GF("+CIPOPEN="), 0, ',', GF("\"TCP"), GF("\",\""), host, GF("\","),
-           port);
+      // set the SSL SNI (server name indication)
+      // AT+CSSLCFG="enableSNI",<ssl_ctx_index>,<enableSNI_flag>
+      // NOTE:  despite docs using caps, "sni" must be in lower case
+      sendAT(GF("+CSSLCFG=\"enableSNI\",0,1"));
+      if (waitResponse(2000L) != 1) { return false; }
+
+      // Configure the report mode of sending and receiving data
+      /* +CCHSET=<report_send_result>,<recv_mode>
+       * <report_send_result> Whether to report result of CCHSEND, the default
+       *  value is 0: 0 No. 1 Yes. Module will report +CCHSEND:
+       * <session_id>,<err> to MCU when complete sending data.
+       *
+       * <recv_mode> The receiving mode, the default value is 0:
+       * 0 Output the data to MCU whenever received data.
+       * 1 Module caches the received data and notifies MCU with+CCHEVENT:
+       * <session_id>,RECV EVENT. MCU can use AT+CCHRECV to receive the cached
+       * data (only in manual receiving mode).
+       */
+      sendAT(GF("+CCHSET=1,1"));
+      if (waitResponse(2000L) != 1) { return false; }
+
+      sendAT(GF("+CCHSTART"));
+      if (waitResponse(2000L) != 1) { return false; }
+
+      sendAT(GF("+CCHSSLCFG="), mux, GF(",0"));
+      if (waitResponse(2000L) != 1) { return false; }
+
+      sendAT(GF("+CCHOPEN="), 0, GF(",\""), host, GF("\","), port, GF(",2"));
+      rsp = waitResponse(timeout_ms, GF("+CCHOPEN: 0,0" GSM_NL),
+                         GF("+CCHOPEN: 0,1" GSM_NL), GF("+CCHOPEN: 0,4" GSM_NL),
+                         GF("ERROR" GSM_NL), GF("CLOSE OK" GSM_NL));
+    } else {
+
+      sendAT(GF("+NETOPEN"));
+      if (waitResponse(2000L) != 1) { return false; }
+
+      sendAT(GF("+NETOPEN?"));
+      if (waitResponse(2000L) != 1) { return false; }
+
+      sendAT(GF("+CIPOPEN="), 0, ',', GF("\"TCP"), GF("\",\""), host, GF("\","),
+             port);
+     
+      rsp = waitResponse(
+          timeout_ms, GF("+CIPOPEN: 0,0" GSM_NL), GF("+CIPOPEN: 0,1" GSM_NL),
+          GF("+CIPOPEN: 0,4" GSM_NL), GF("ERROR" GSM_NL),
+          GF("CLOSE OK" GSM_NL));  // Happens when HTTPS handshake fails
+    }
 
-    rsp = waitResponse(
-        timeout_ms, GF("+CIPOPEN: 0,0" GSM_NL), GF("+CIPOPEN: 0,1" GSM_NL),
-        GF("+CIPOPEN: 0,4" GSM_NL), GF("ERROR" GSM_NL),
-        GF("CLOSE OK" GSM_NL));  // Happens when HTTPS handshake fails
     return (1 == rsp);
   }
 
   int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
-    sendAT(GF("+CIPSEND="), mux, ',', (uint16_t)len);
+    if (hasSSL)
+      sendAT(GF("+CCHSEND="), mux, ',', (uint16_t)len);
+    else
+      sendAT(GF("+CIPSEND="), mux, ',', (uint16_t)len);
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "DATA ACCEPT:")) != 1) { return 0; }
+
+    if (hasSSL) {
+      if (waitResponse(GF(GSM_NL "+CCHSEND:")) != 1) { return 0; }
+    } else if (waitResponse() != 1) {
+      return 0;
+    }
     streamSkipUntil(',');  // Skip mux
     return streamGetIntBefore('\n');
   }
 
   size_t modemRead(size_t size, uint8_t mux) {
+    int16_t len_requested = 0;
+    int16_t len_confirmed = 0;
     if (!sockets[mux]) return 0;
-#ifdef TINY_GSM_USE_HEX
-    sendAT(GF("+CIPRXGET=3,"), mux, ',', (uint16_t)size);
-    if (waitResponse(GF("+CIPRXGET:")) != 1) { return 0; }
-#else
-    sendAT(GF("+CIPRXGET=2,"), mux, ',', (uint16_t)size);
-    if (waitResponse(GF("+CIPRXGET:")) != 1) { return 0; }
-#endif
-    streamSkipUntil(',');  // Skip Rx mode 2/normal or 3/HEX
-    streamSkipUntil(',');  // Skip mux
-    int16_t len_requested = streamGetIntBefore(',');
-    //  ^^ Requested number of data bytes (1-1460 bytes)to be read
-    int16_t len_confirmed = streamGetIntBefore('\n');
-    // ^^ Confirmed number of data bytes to be read, which may be less than
-    // requested. 0 indicates that no data can be read.
-    // SRGD NOTE:  Contrary to above (which is copied from AT command manual)
-    // this is actually be the number of bytes that will be remaining in the
-    // buffer after the read.
+    if (hasSSL) {
+      sendAT(GF("+CCHRECV?"));
+      String res = "";
+      waitResponse(2000L, res);
+      int16_t len =
+          res.substring(res.indexOf(',') + 1, res.lastIndexOf(',')).toInt();
+      sendAT(GF("+CCHRECV="), mux, ',', (uint16_t)size);
+      if (waitResponse(GF("+CCHRECV:")) != 1) { return 0; }
+      //+CCHRECV: DATA,0,<msg>
+      streamSkipUntil(',');  // Skip DATA
+      streamSkipUntil(',');  // Skip mux
+      len_requested = streamGetIntBefore('\n');
+      len_confirmed = len;  // streamGetIntBefore(',');
+    } else {
+      sendAT(GF("+CIPRXGET=2,"), mux, ',', (uint16_t)size);
+      if (waitResponse(GF("+CIPRXGET:")) != 1) { return 0; }
+      streamSkipUntil(',');  // Skip Rx mode 2/normal or 3/HEX
+      streamSkipUntil(',');  // Skip mux
+      len_requested = streamGetIntBefore(',');
+      //  ^^ Requested number of data bytes (1-1460 bytes)to be read
+      len_confirmed = streamGetIntBefore('\n');
+      // ^^ Confirmed number of data bytes to be read, which may be less than
+      // requested. 0 indicates that no data can be read.
+      // SRGD NOTE:  Contrary to above (which is copied from AT command manual)
+      // this is actually be the number of bytes that will be remaining in the
+      // buffer after the read.
+    }
     for (int i = 0; i < len_requested; i++) {
       uint32_t startMillis = millis();
-#ifdef TINY_GSM_USE_HEX
-      while (stream.available() < 2 &&
-             (millis() - startMillis < sockets[mux]->_timeout)) {
-        TINY_GSM_YIELD();
-      }
-      char buf[4] = {
-          0,
-      };
-      buf[0] = stream.read();
-      buf[1] = stream.read();
-      char c = strtol(buf, NULL, 16);
-#else
       while (!stream.available() &&
              (millis() - startMillis < sockets[mux]->_timeout)) {
         TINY_GSM_YIELD();
       }
       char c = stream.read();
-#endif
       sockets[mux]->rx.put(c);
     }
-    // DBG("### READ:", len_requested, "from", mux);
+    DBG("### READ:", len_requested, " bytes from connection ", mux);
     // sockets[mux]->sock_available = modemGetAvailable(mux);
     sockets[mux]->sock_available = len_confirmed;
     waitResponse();
@@ -523,26 +625,40 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 
   size_t modemGetAvailable(uint8_t mux) {
     if (!sockets[mux]) return 0;
-    sendAT(GF("+CIPRXGET=4,"), mux);
     size_t result = 0;
-    if (waitResponse(GF("+CIPRXGET:")) == 1) {
-      streamSkipUntil(',');  // Skip mode 4
-      streamSkipUntil(',');  // Skip mux
-      result = streamGetIntBefore('\n');
-      waitResponse();
+    if (hasSSL) {
+      sendAT(GF("+CCHRECV?"));
+      String res = "";
+      waitResponse(2000L, res);
+      result =
+          res.substring(res.indexOf(',') + 1, res.lastIndexOf(',')).toInt();
+    } else {
+      sendAT(GF("+CIPRXGET=4,"), mux);
+      result = 0;
+      if (waitResponse(GF("+CIPRXGET:")) == 1) {
+        streamSkipUntil(',');  // Skip mode 4
+        streamSkipUntil(',');  // Skip mux
+        result = streamGetIntBefore('\n');
+        waitResponse();
+      }
     }
-    // DBG("### Available:", result, "on", mux);
+    DBG("### Available:", result, "on", mux);
     if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
     return result;
   }
 
   bool modemGetConnected(uint8_t mux) {
-    sendAT(GF("+CIPSTATUS="), mux);
-    waitResponse(GF("+CIPSTATUS"));
-    int8_t res = waitResponse(GF(",\"CONNECTED\""), GF(",\"CLOSED\""),
-                              GF(",\"CLOSING\""), GF(",\"REMOTE CLOSING\""),
-                              GF(",\"INITIAL\""));
-    waitResponse();
+    int8_t res = 0;
+    if (hasSSL) {
+      return this->sockets[mux]->sock_connected;
+    } else {
+      sendAT(GF("+CIPACK="), mux);
+      waitResponse(GF("+CIPACK:"));
+      res = waitResponse(2000L);  //(GF(",\"CONNECTED\""), GF(",\"CLOSED\""),
+                                  // GF(",\"CLOSING\""), GF(",\"REMOTE
+                                  // CLOSING\""), GF(",\"INITIAL\""));
+      waitResponse();
+    }
     return 1 == res;
   }
 
@@ -605,28 +721,49 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
               sockets[mux]->got_data = true;
             }
             data = "";
-            // DBG("### Got Data:", mux);
+            DBG("### Got Data:", mux);
           } else {
             data += mode;
           }
-        } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
+        } else if (data.endsWith(GF("RECV EVENT" GSM_NL))) {
+          sendAT(GF("+CCHRECV?"));
+          String res = "";
+          waitResponse(2000L, res);
+          int8_t  mux = res.substring(res.lastIndexOf(',') + 1).toInt();
+          int16_t len =
+              res.substring(res.indexOf(',') + 1, res.lastIndexOf(',')).toInt();
           if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
             sockets[mux]->got_data = true;
             if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
           }
           data = "";
-          // DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-          int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
-          int8_t coma = data.indexOf(',', nl + 2);
-          int8_t mux  = data.substring(nl + 2, coma).toInt();
+          DBG("### Got Data:", len, "on", mux);
+        } else if (data.endsWith(GF("+CCHRECV: 0,0" GSM_NL))) {
+          int8_t mux = data.substring(data.lastIndexOf(',') + 1).toInt();
+          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+            sockets[mux]->sock_connected = true;
+          }
+          data = "";
+          DBG("### ACK:", mux);
+        } else if (data.endsWith(GF("+IPCLOSE:"))) {
+          // int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+          // int8_t coma = data.indexOf(',', nl + 2);
+          // int8_t mux  = data.substring(nl + 2, coma).toInt();
+          int8_t mux = streamGetIntBefore(',');
           if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
             sockets[mux]->sock_connected = false;
           }
           data = "";
-          DBG("### Closed: ", mux);
+          DBG("### TCP Closed: ", mux);
+        } else if (data.endsWith(GF("+CCH_PEER_CLOSED:"))) {
+          // int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+          // int8_t coma = data.indexOf(',', nl + 2);
+          int8_t mux = streamGetIntBefore('\n');
+          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+            sockets[mux]->sock_connected = false;
+          }
+          data = "";
+          DBG("### SSL Closed: ", mux);
         } else if (data.endsWith(GF("*PSNWID:"))) {
           streamSkipUntil('\n');  // Refresh network name by network
           data = "";
@@ -688,7 +825,9 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 
  protected:
   GsmClientA7672X* sockets[TINY_GSM_MUX_COUNT];
-  const char*      gsmNL = GSM_NL;
+  const char*      gsmNL  = GSM_NL;
+  bool             hasSSL = false;
+  String           certificates[TINY_GSM_MUX_COUNT];
 };
 
 #endif  // SRC_TINYGSMCLIENTA7672X_H_

From 67c8242535da9c034cd2373554746e41d6745826 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Thu, 6 Oct 2022 17:29:48 -0300
Subject: [PATCH 009/100] todo's & dbg

---
 src/TinyGsmClientA7672x.h | 61 ++++++++++++++++++++-------------------
 1 file changed, 31 insertions(+), 30 deletions(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index a2c525a..1f1b1ff 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -10,7 +10,6 @@
 #define SRC_TINYGSMCLIENTA7672X_H_
 
 // #define TINY_GSM_DEBUG Serial
-// #define TINY_GSM_USE_HEX
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
@@ -107,7 +106,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 
     void stop(uint32_t maxWaitMs) {
       dumpModemBuffer(maxWaitMs);
-      at->sendAT(GF("+CIPCLOSE="), mux);  //, GF(",1"));  // Quick close
+      at->sendAT(GF("+CIPCLOSE="), mux);
       sock_connected = false;
       at->waitResponse();
     }
@@ -193,9 +192,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 #endif
     waitResponse();
 
-    // sendAT(GF("X4"));
-    // waitResponse();
-
     DBG(GF("### Modem:"), getModemName());
 
     SimStatus ret = getSimStatus();
@@ -226,8 +222,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return name;
   }
 
-  bool factoryDefaultImpl() {
-    sendAT(GF("&FZE0&W"));  // Factory + Reset + Echo Off + Write
+  bool factoryDefaultImpl() {  // todo:
+    sendAT(GF("&FZE0&W"));     // Factory + Reset + Echo Off + Write
     waitResponse();
     sendAT(GF("+IPR=0"));  // Auto-baud
     waitResponse();
@@ -245,7 +241,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = NULL) {  // todo:
     if (!testAT()) { return false; }
     sendAT(GF("&W"));
     waitResponse();
@@ -255,7 +251,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return init(pin);
   }
 
-  bool powerOffImpl() {
+  bool powerOffImpl() {  // todo:
     sendAT(GF("+CPOWD=1"));
     return waitResponse(10000L, GF("NORMAL POWER DOWN")) == 1;
   }
@@ -264,7 +260,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   // order to reestablish communication pull the DRT-pin of the A7672X module
   // LOW for at least 50ms. Then use this function to disable sleep mode. The
   // DTR-pin can then be released again.
-  bool sleepEnableImpl(bool enable = true) {
+  bool sleepEnableImpl(bool enable = true) {  // todo:
     sendAT(GF("+CSCLK="), enable);
     return waitResponse() == 1;
   }
@@ -357,7 +353,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return true;
   }
 
-  bool gprsDisconnectImpl() {
+  bool gprsDisconnectImpl() {  // todo:
     // Shut the TCP/IP connection
     // CIPSHUT will close *all* open connections
     sendAT(GF("+NETCLOSE"));
@@ -386,27 +382,26 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Phone Call functions
    */
  public:
-  bool setGsmBusy(bool busy = true) {
+  bool setGsmBusy(bool busy = true) {  // todo:
     sendAT(GF("+GSMBUSY="), busy ? 1 : 0);
     return waitResponse() == 1;
   }
 
   /*
-   * Messaging functions
+   * Messaging functions //todo:
    */
  protected:
   // Follows all messaging functions per template
 
   /*
-   * GSM Location functions
+   * GSM Location functions //todo:
    */
  protected:
   // Depending on the exacty model and firmware revision, should return a
   // GSM-based location from CLBS as per the template
-  // TODO(?):  Check number of digits in year (2 or 4)
 
   /*
-   * GPS/GNSS/GLONASS location functions
+   * GPS/GNSS/GLONASS location functions //todo:
    */
  protected:
   // No functions of this type supported
@@ -415,13 +410,13 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Audio functions
    */
  public:
-  bool setVolume(uint8_t volume = 50) {
+  bool setVolume(uint8_t volume = 50) {  // todo:
     // Set speaker volume
     sendAT(GF("+CLVL="), volume);
     return waitResponse() == 1;
   }
 
-  uint8_t getVolume() {
+  uint8_t getVolume() {  // todo:
     // Get speaker volume
     sendAT(GF("+CLVL?"));
     if (waitResponse(GF(GSM_NL)) != 1) { return 0; }
@@ -432,18 +427,18 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return res.toInt();
   }
 
-  bool setMicVolume(uint8_t channel, uint8_t level) {
+  bool setMicVolume(uint8_t channel, uint8_t level) {  // todo:
     if (channel > 4) { return 0; }
     sendAT(GF("+CMIC="), level);
     return waitResponse() == 1;
   }
 
-  bool setAudioChannel(uint8_t channel) {
+  bool setAudioChannel(uint8_t channel) {  // todo:
     sendAT(GF("+CHFA="), channel);
     return waitResponse() == 1;
   }
 
-  bool playToolkitTone(uint8_t tone, uint32_t duration) {
+  bool playToolkitTone(uint8_t tone, uint32_t duration) {  // todo:
     sendAT(GF("STTONE="), 1, tone);
     delay(duration);
     sendAT(GF("STTONE="), 0);
@@ -451,24 +446,30 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   }
 
   /*
-   * Time functions
+   * Time functions //todo:
    */
  protected:
   // Can follow the standard CCLK function in the template
 
   /*
-   * NTP server functions
+   * NTP server functions //todo:
    */
   // Can sync with server using CNTP as per template
 
   /*
-   * Battery functions
+   * BLE functions //todo:
+   */
+ protected:
+  // Follows all BLE functions per template
+
+  /*
+   * Battery functions //todo:
    */
  protected:
   // Follows all battery functions per template
 
   /*
-   * NTP server functions
+   * NTP server functions //todo:
    */
   // Can sync with server using CNTP as per template
 
@@ -539,7 +540,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
                          GF("+CCHOPEN: 0,1" GSM_NL), GF("+CCHOPEN: 0,4" GSM_NL),
                          GF("ERROR" GSM_NL), GF("CLOSE OK" GSM_NL));
     } else {
-
       sendAT(GF("+NETOPEN"));
       if (waitResponse(2000L) != 1) { return false; }
 
@@ -548,7 +548,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 
       sendAT(GF("+CIPOPEN="), 0, ',', GF("\"TCP"), GF("\",\""), host, GF("\","),
              port);
-     
+
       rsp = waitResponse(
           timeout_ms, GF("+CIPOPEN: 0,0" GSM_NL), GF("+CIPOPEN: 0,1" GSM_NL),
           GF("+CIPOPEN: 0,4" GSM_NL), GF("ERROR" GSM_NL),
@@ -581,7 +581,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     int16_t len_confirmed = 0;
     if (!sockets[mux]) return 0;
     if (hasSSL) {
-      sendAT(GF("+CCHRECV?"));
+      sendAT(GF("+CCHRECV?"));  // TODO(Rosso): Optimize this!
       String res = "";
       waitResponse(2000L, res);
       int16_t len =
@@ -616,7 +616,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
       char c = stream.read();
       sockets[mux]->rx.put(c);
     }
-    DBG("### READ:", len_requested, " bytes from connection ", mux);
+    // DBG("### READ:", len_requested, " bytes from connection ", mux);
     // sockets[mux]->sock_available = modemGetAvailable(mux);
     sockets[mux]->sock_available = len_confirmed;
     waitResponse();
@@ -642,7 +642,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
         waitResponse();
       }
     }
-    DBG("### Available:", result, "on", mux);
+    // DBG("### Available:", result, "on", mux);
     if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
     return result;
   }
@@ -754,6 +754,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
             sockets[mux]->sock_connected = false;
           }
           data = "";
+          streamSkipUntil('\n');
           DBG("### TCP Closed: ", mux);
         } else if (data.endsWith(GF("+CCH_PEER_CLOSED:"))) {
           // int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);

From 6957cf563a8f7575522fdd0d93a0e32c328617a9 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Mon, 10 Oct 2022 10:35:11 -0300
Subject: [PATCH 010/100] Custom Certificate upload

---
 src/TinyGsmClientA7672x.h | 163 ++++++++++++++++----------------------
 1 file changed, 70 insertions(+), 93 deletions(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 1f1b1ff..c0fdaa4 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -24,6 +24,7 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmTemperature.tpp"
 
 #define GSM_NL "\r\n"
 static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
@@ -51,7 +52,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
                       public TinyGsmGSMLocation<TinyGsmA7672X>,
                       public TinyGsmTime<TinyGsmA7672X>,
                       public TinyGsmNTP<TinyGsmA7672X>,
-                      public TinyGsmBattery<TinyGsmA7672X> {
+                      public TinyGsmBattery<TinyGsmA7672X>,
+                      public TinyGsmTemperature<TinyGsmA7672X> {
   friend class TinyGsmModem<TinyGsmA7672X>;
   friend class TinyGsmGPRS<TinyGsmA7672X>;
   friend class TinyGsmTCP<TinyGsmA7672X, TINY_GSM_MUX_COUNT>;
@@ -62,6 +64,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   friend class TinyGsmTime<TinyGsmA7672X>;
   friend class TinyGsmNTP<TinyGsmA7672X>;
   friend class TinyGsmBattery<TinyGsmA7672X>;
+  friend class TinyGsmTemperature<TinyGsmA7672X>;
 
   /*
    * Inner Client
@@ -133,8 +136,13 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
         : GsmClientA7672X(modem, mux) {}
 
    public:
-    bool setCertificate(const String& certificateName, const uint8_t len) {
-      return at->setCertificate(certificateName, len);
+    bool addCertificate(const String& certificateName, const String& cert,
+                        const uint16_t len) {
+      return at->addCertificate(certificateName, cert, len);
+    }
+
+    bool setCertificate(const String& certificateName) {
+      return at->setCertificate(certificateName, mux);
     }
 
     bool deleteCertificate(const String& certificateName) {
@@ -222,16 +230,24 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return name;
   }
 
-  bool factoryDefaultImpl() {  // todo:
-    sendAT(GF("&FZE0&W"));     // Factory + Reset + Echo Off + Write
+  float getTemperatureImpl() {
+    String res = "";
+    sendAT(GF("+CPMUTEMP"));
+    if (waitResponse(1000L, res)) { return 0; }
+    res        = res.substring(res.indexOf(':'), res.indexOf('\r'));
+    float temp = res.toFloat();
     waitResponse();
-    sendAT(GF("+IPR=0"));  // Auto-baud
+    return temp;
+  }
+
+  bool factoryDefaultImpl() {
+    sendAT(GF("&F"));  // Factory + Reset
     waitResponse();
     sendAT(GF("+IFC=0,0"));  // No Flow Control
     waitResponse();
-    sendAT(GF("+ICF=3,3"));  // 8 data 0 parity 1 stop
+    sendAT(GF("+ICF=2,2"));  // 8 data 0 parity 1 stop
     waitResponse();
-    sendAT(GF("+CSCLK=0"));  // Disable Slow Clock
+    sendAT(GF("+CSCLK=0"));  // Control UART Sleep always work
     waitResponse();
     sendAT(GF("&W"));  // Write configuration
     return waitResponse() == 1;
@@ -241,9 +257,9 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {  // todo:
+  bool restartImpl(const char* pin = NULL) {
     if (!testAT()) { return false; }
-    sendAT(GF("&W"));
+    sendAT(GF("+CRESET"));
     waitResponse();
     if (!setPhoneFunctionality(0)) { return false; }
     if (!setPhoneFunctionality(1, true)) { return false; }
@@ -251,26 +267,33 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return init(pin);
   }
 
-  bool powerOffImpl() {  // todo:
-    sendAT(GF("+CPOWD=1"));
-    return waitResponse(10000L, GF("NORMAL POWER DOWN")) == 1;
+  bool powerOffImpl() {
+    sendAT(GF("+CPOF"));
+    return waitResponse(10000L) == 1;
   }
 
-  // During sleep, the A7672X module has its serial communication disabled. In
-  // order to reestablish communication pull the DRT-pin of the A7672X module
-  // LOW for at least 50ms. Then use this function to disable sleep mode. The
-  // DTR-pin can then be released again.
-  bool sleepEnableImpl(bool enable = true) {  // todo:
-    sendAT(GF("+CSCLK="), enable);
+  //  This command is used to enable UART Sleep or always work. If set to 0,
+  //  UART always work. If set to 1, ensure that DTR is pulled high and the
+  //  module can go to DTR sleep. If set to 2, the module will enter RXsleep. RX
+  //  wakeup directly sends data through the serial port (for example: AT) to
+  //  wake up
+  bool sleepEnableImpl(bool enable = true) {
+    sendAT(GF("+CSCLK="),
+           enable ? "2" : "1");  // 2: RXsleep (at wakeup) 1: DTR sleep
     return waitResponse() == 1;
   }
 
-  // <fun> 0 Minimum functionality
-  // <fun> 1 Full functionality (Default)
-  // <fun> 4 Disable phone both transmit and receive RF circuits.
-  // <rst> Reset the MT before setting it to <fun> power level.
+  // <fun> 0 minimum functionality
+  // <fun> 1 full functionality, online mode
+  // <fun> 4 disable phone both transmit and receive RF circuits
+  // <fun> 5 Factory Test Mode (The A7600's 5 and 1 have the same function)
+  // <fun> 6 Reset
+  // <fun> 7 Offline Mode
+  // <rst> 0 do not reset the ME before setting it to <fun> power level
+  // <rst> 1 reset the ME before setting it to <fun> power level. This
+  // valueonlytakes effect when <fun> equals 1
   bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false) {
-    sendAT(GF("+CFUN="), fun, reset ? ",1" : "");
+    sendAT(GF("+CFUN="), fun, reset ? ",1" : ",0");
     return waitResponse(10000L) == 1;
   }
 
@@ -308,12 +331,24 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
  protected:
   // The name of the certificate/key/password file. The file name must
   // havetype like ".pem" or ".der".
-  bool setCertificate(const String& certificateName, const uint8_t len) {
+  // The certificate like - const char ca_cert[] PROGMEM =  R"EOF(-----BEGIN...
+  // len of certificate like - sizeof(ca_cert)
+  bool addCertificate(const String& certificateName, const String& cert,
+                      const uint16_t len) {
     sendAT(GF("+CCERTDOWN="), certificateName, GF(","), len);
+    if (waitResponse(GF(">")) != 1) { return 0; }
+    stream.write(cert.c_str(), len);
+    stream.flush();
     return waitResponse() == 1;
   }
 
-  bool deleteCertificate(const String& certificateName) {
+  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
+    if (mux >= TINY_GSM_MUX_COUNT) return false;
+    certificates[mux] = certificateName;
+    return true;
+  }
+
+  bool deleteCertificate(const String& certificateName) {  // todo test
     sendAT(GF("+CCERTDELE="), certificateName);
     return waitResponse() == 1;
   }
@@ -353,9 +388,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return true;
   }
 
-  bool gprsDisconnectImpl() {  // todo:
+  bool gprsDisconnectImpl() {
     // Shut the TCP/IP connection
-    // CIPSHUT will close *all* open connections
     sendAT(GF("+NETCLOSE"));
     if (waitResponse(60000L) != 1) { return false; }
 
@@ -382,97 +416,39 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Phone Call functions
    */
  public:
-  bool setGsmBusy(bool busy = true) {  // todo:
-    sendAT(GF("+GSMBUSY="), busy ? 1 : 0);
+  bool setGsmBusy(bool busy = true) {
+    sendAT(GF("+CCFC=1,"), busy ? 1 : 0);
     return waitResponse() == 1;
   }
 
-  /*
-   * Messaging functions //todo:
-   */
- protected:
-  // Follows all messaging functions per template
-
   /*
    * GSM Location functions //todo:
    */
  protected:
-  // Depending on the exacty model and firmware revision, should return a
-  // GSM-based location from CLBS as per the template
-
   /*
    * GPS/GNSS/GLONASS location functions //todo:
    */
  protected:
-  // No functions of this type supported
-
   /*
-   * Audio functions
+   * Audio functions //todo:
    */
- public:
-  bool setVolume(uint8_t volume = 50) {  // todo:
-    // Set speaker volume
-    sendAT(GF("+CLVL="), volume);
-    return waitResponse() == 1;
-  }
-
-  uint8_t getVolume() {  // todo:
-    // Get speaker volume
-    sendAT(GF("+CLVL?"));
-    if (waitResponse(GF(GSM_NL)) != 1) { return 0; }
-    String res = stream.readStringUntil('\n');
-    waitResponse();
-    res.replace("+CLVL:", "");
-    res.trim();
-    return res.toInt();
-  }
-
-  bool setMicVolume(uint8_t channel, uint8_t level) {  // todo:
-    if (channel > 4) { return 0; }
-    sendAT(GF("+CMIC="), level);
-    return waitResponse() == 1;
-  }
-
-  bool setAudioChannel(uint8_t channel) {  // todo:
-    sendAT(GF("+CHFA="), channel);
-    return waitResponse() == 1;
-  }
-
-  bool playToolkitTone(uint8_t tone, uint32_t duration) {  // todo:
-    sendAT(GF("STTONE="), 1, tone);
-    delay(duration);
-    sendAT(GF("STTONE="), 0);
-    return waitResponse();
-  }
-
+ protected:
   /*
    * Time functions //todo:
    */
  protected:
-  // Can follow the standard CCLK function in the template
-
   /*
    * NTP server functions //todo:
    */
-  // Can sync with server using CNTP as per template
-
+ protected:
   /*
    * BLE functions //todo:
    */
  protected:
-  // Follows all BLE functions per template
-
   /*
    * Battery functions //todo:
    */
  protected:
-  // Follows all battery functions per template
-
-  /*
-   * NTP server functions //todo:
-   */
-  // Can sync with server using CNTP as per template
-
   /*
    * Client related functions
    */
@@ -482,7 +458,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     int8_t   rsp;
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
 
-    sendAT(GF("+CTCPKA=1,2,5,1"));  // todo: here?
+    // +CTCPKA:<keepalive>,<keepidle>,<keepcount>,<keepinterval>
+    sendAT(GF("+CTCPKA=1,2,5,1"));
     if (waitResponse(2000L) != 1) { return false; }
 
     if (ssl) {
@@ -504,7 +481,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
       if (certificates[mux] != "") {
         /* Configure the server root CA of the specified SSL context
         AT + CSSLCFG = "cacert", <ssl_ ctx_index>,<ca_file> */
-        sendAT(GF("+CASSLCFG=\"cacert\",0,"), certificates[mux].c_str());
+        sendAT(GF("+CSSLCFG=\"cacert\",0,"), certificates[mux].c_str());
         if (waitResponse(5000L) != 1) return false;
       }
 

From 4d3b5b4e443f31590eb385f8523f87582dff9345 Mon Sep 17 00:00:00 2001
From: Gonzalo Brusco <gonzalo@powermeter.com.ar>
Date: Thu, 13 Oct 2022 15:29:06 -0300
Subject: [PATCH 011/100] Separate NTP functions for different 70xx modules.

---
 src/TinyGsmClientSIM7000.h    |  4 +++-
 src/TinyGsmClientSIM7000SSL.h |  3 +++
 src/TinyGsmClientSIM7080.h    | 43 ++++++++++++++++++++++++++++++++++-
 src/TinyGsmClientSIM70xx.h    |  3 ---
 4 files changed, 48 insertions(+), 5 deletions(-)

diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index e708845..0b33a4e 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -17,11 +17,13 @@
 
 #include "TinyGsmClientSIM70xx.h"
 #include "TinyGsmTCP.tpp"
-
+#include "TinyGsmNTP.tpp"
 
 class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
+                       public TinyGsmNTP<TinyGsmSim7000>,
                        public TinyGsmTCP<TinyGsmSim7000, TINY_GSM_MUX_COUNT> {
   friend class TinyGsmSim70xx<TinyGsmSim7000>;
+  friend class TinyGsmNTP<TinyGsmSim7000>;
   friend class TinyGsmTCP<TinyGsmSim7000, TINY_GSM_MUX_COUNT>;
 
   /*
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index 2f88e89..db5d774 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -18,13 +18,16 @@
 #include "TinyGsmClientSIM70xx.h"
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmSSL.tpp"
+#include "TinyGsmNTP.tpp"
 
 class TinyGsmSim7000SSL
     : public TinyGsmSim70xx<TinyGsmSim7000SSL>,
       public TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>,
+      public TinyGsmNTP<TinyGsmSim7000SSL>,
       public TinyGsmSSL<TinyGsmSim7000SSL> {
   friend class TinyGsmSim70xx<TinyGsmSim7000SSL>;
   friend class TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmNTP<TinyGsmSim7000SSL>;
   friend class TinyGsmSSL<TinyGsmSim7000SSL>;
 
   /*
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index f5584a9..601ab3c 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -18,11 +18,14 @@
 #include "TinyGsmClientSIM70xx.h"
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmSSL.tpp"
+#include "TinyGsmNTP.tpp"
 
 class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
+                       public TinyGsmNTP<TinyGsmSim7080>,
                        public TinyGsmTCP<TinyGsmSim7080, TINY_GSM_MUX_COUNT>,
                        public TinyGsmSSL<TinyGsmSim7080> {
   friend class TinyGsmSim70xx<TinyGsmSim7080>;
+  friend class TinyGsmNTP<TinyGsmSim7080>;
   friend class TinyGsmTCP<TinyGsmSim7080, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmSSL<TinyGsmSim7080>;
 
@@ -317,7 +320,45 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+
+  byte NTPServerSyncImpl(String server = "pool.ntp.org", int TimeZone = 0) {
+    // Set GPRS bearer profile to associate with NTP sync
+    // this may fail, it's not supported by all modules
+    sendAT(GF("+CNTPCID=0")); // CID must be 0. With 1 (like other modules) does not work!
+    waitResponse(10000L);
+
+    // Set NTP server and timezone
+    sendAT(GF("+CNTP=\""), server, "\",", String(TimeZone));
+    if (waitResponse(10000L) != 1) { return -1; }
+
+    // Request network synchronization
+    sendAT(GF("+CNTP"));
+    if (waitResponse(10000L, GF("+CNTP:"))) {
+      String result = stream.readStringUntil('\n');
+      // Check for ',' in case the module appends the time next to the return code. Eg: +CNTP: <code>[,<time>]
+      int index = result.indexOf(',');
+      if(index > 0) {
+          result.remove(index);
+      }
+      result.trim();
+      if (TinyGsmIsValidNumber(result)) { return result.toInt(); }
+    } else {
+      return -1;
+    }
+    return -1;
+  }
+
+  String ShowNTPErrorImpl(byte error) {
+    switch (error) {
+      case 1: return "Network time synchronization is successful";
+      case 61: return "Network error";
+      case 62: return "DNS resolution error";
+      case 63: return "Connection error";
+      case 64: return "Service response error";
+      case 65: return "Service response timeout";
+      default: return "Unknown error: " + String(error);
+    }
+  }
 
   /*
    * Battery functions
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 45d1f5e..7e50833 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -18,7 +18,6 @@
 #include "TinyGsmModem.tpp"
 #include "TinyGsmSMS.tpp"
 #include "TinyGsmTime.tpp"
-#include "TinyGsmNTP.tpp"
 #include "TinyGsmGSMLocation.tpp"
 
 #define GSM_NL "\r\n"
@@ -45,7 +44,6 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
                        public TinyGsmSMS<TinyGsmSim70xx<modemType>>,
                        public TinyGsmGPS<TinyGsmSim70xx<modemType>>,
                        public TinyGsmTime<TinyGsmSim70xx<modemType>>,
-                       public TinyGsmNTP<TinyGsmSim70xx<modemType>>,
                        public TinyGsmBattery<TinyGsmSim70xx<modemType>>,
                        public TinyGsmGSMLocation<TinyGsmSim70xx<modemType>> {
   friend class TinyGsmModem<TinyGsmSim70xx<modemType>>;
@@ -53,7 +51,6 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   friend class TinyGsmSMS<TinyGsmSim70xx<modemType>>;
   friend class TinyGsmGPS<TinyGsmSim70xx<modemType>>;
   friend class TinyGsmTime<TinyGsmSim70xx<modemType>>;
-  friend class TinyGsmNTP<TinyGsmSim70xx<modemType>>;
   friend class TinyGsmBattery<TinyGsmSim70xx<modemType>>;
   friend class TinyGsmGSMLocation<TinyGsmSim70xx<modemType>>;
 

From 2d1fc04065cb0508bda7765ca0cd0cd5224749af Mon Sep 17 00:00:00 2001
From: Gonzalo Brusco <gonzalo@powermeter.com.ar>
Date: Fri, 14 Oct 2022 15:23:11 -0300
Subject: [PATCH 012/100] Added missing parameter to CNCFG (was returning an
 error previously)

---
 src/TinyGsmClientSIM7000SSL.h | 2 +-
 src/TinyGsmClientSIM7080.h    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index db5d774..e5a03b4 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -245,7 +245,7 @@ class TinyGsmSim7000SSL
     //                 2: CHAP
     //                 3: PAP or CHAP
     if (pwd && strlen(pwd) > 0 && user && strlen(user) > 0) {
-      sendAT(GF("+CNCFG=1,\""), apn, "\",\"", "\",\"", user, pwd, '"');
+      sendAT(GF("+CNCFG=1,\""), apn, "\",\"", "\",\"", user, pwd, "\",3");
       waitResponse();
     } else if (user && strlen(user) > 0) {
       // Set the user name only
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index 601ab3c..217cda7 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -250,7 +250,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     //                  2: CHAP
     //                  3: PAP or CHAP
     if (pwd && strlen(pwd) > 0 && user && strlen(user) > 0) {
-      sendAT(GF("+CNCFG=0,1,\""), apn, "\",\"", user, "\",\"", pwd, '"');
+      sendAT(GF("+CNCFG=0,1,\""), apn, "\",\"", user, "\",\"", pwd, "\",3");
       waitResponse();
     } else if (user && strlen(user) > 0) {
       // Set the user name only

From 5f7c27555ad1b4c4f60f10ba8a09982ef0bfe815 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Tue, 25 Oct 2022 08:58:24 -0300
Subject: [PATCH 013/100] fixes

---
 src/TinyGsmClientA7672x.h | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index c0fdaa4..f5a0453 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -544,13 +544,13 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
 
-    if (hasSSL) {
-      if (waitResponse(GF(GSM_NL "+CCHSEND:")) != 1) { return 0; }
-    } else if (waitResponse() != 1) {
+    if (waitResponse() != 1) { return 0; }
+    if (waitResponse(10000L, GF("+CCHSEND: 0,0" GSM_NL),
+                     GF("+CCHSEND: 0,4" GSM_NL), GF("+CCHSEND: 0,9" GSM_NL),
+                     GF("ERROR" GSM_NL), GF("CLOSE OK" GSM_NL)) != 1) {
       return 0;
     }
-    streamSkipUntil(',');  // Skip mux
-    return streamGetIntBefore('\n');
+    return len;
   }
 
   size_t modemRead(size_t size, uint8_t mux) {
@@ -604,7 +604,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     if (!sockets[mux]) return 0;
     size_t result = 0;
     if (hasSSL) {
-      sendAT(GF("+CCHRECV?"));
+      sendAT(GF("+CCHRECV?"));  // TODO(Rosso): Optimize this!
       String res = "";
       waitResponse(2000L, res);
       result =
@@ -620,14 +620,16 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
       }
     }
     // DBG("### Available:", result, "on", mux);
-    if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
+    if (result == 0) { sockets[mux]->sock_connected = modemGetConnected(mux); }
     return result;
   }
 
   bool modemGetConnected(uint8_t mux) {
     int8_t res = 0;
     if (hasSSL) {
-      return this->sockets[mux]->sock_connected;
+      bool connected = this->sockets[mux]->sock_connected;
+      DBG("### Connected:", connected);
+      return connected;
     } else {
       sendAT(GF("+CIPACK="), mux);
       waitResponse(GF("+CIPACK:"));
@@ -723,9 +725,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
           data = "";
           DBG("### ACK:", mux);
         } else if (data.endsWith(GF("+IPCLOSE:"))) {
-          // int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
-          // int8_t coma = data.indexOf(',', nl + 2);
-          // int8_t mux  = data.substring(nl + 2, coma).toInt();
           int8_t mux = streamGetIntBefore(',');
           if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
             sockets[mux]->sock_connected = false;
@@ -734,8 +733,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
           streamSkipUntil('\n');
           DBG("### TCP Closed: ", mux);
         } else if (data.endsWith(GF("+CCH_PEER_CLOSED:"))) {
-          // int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
-          // int8_t coma = data.indexOf(',', nl + 2);
           int8_t mux = streamGetIntBefore('\n');
           if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
             sockets[mux]->sock_connected = false;

From 6d1938756351f94472b52da4c41d4b8fec836358 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Tue, 1 Nov 2022 17:45:48 -0300
Subject: [PATCH 014/100] SSL Close

---
 src/TinyGsmClientA7672x.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index f5a0453..8d6c566 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -732,6 +732,14 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
           data = "";
           streamSkipUntil('\n');
           DBG("### TCP Closed: ", mux);
+        } else if (data.endsWith(GF("+CCHCLOSE:"))) {
+          int8_t mux = streamGetIntBefore(',');
+          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+            sockets[mux]->sock_connected = false;
+          }
+          data = "";
+          streamSkipUntil('\n');
+          DBG("### SSL Closed: ", mux);
         } else if (data.endsWith(GF("+CCH_PEER_CLOSED:"))) {
           int8_t mux = streamGetIntBefore('\n');
           if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {

From 1e650c59ff98eb4c40ab0f95815547f0cbd51dcb Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Thu, 10 Nov 2022 10:20:46 -0300
Subject: [PATCH 015/100] dbg

---
 src/TinyGsmClientA7672x.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 8d6c566..084a921 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -628,7 +628,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     int8_t res = 0;
     if (hasSSL) {
       bool connected = this->sockets[mux]->sock_connected;
-      DBG("### Connected:", connected);
+      // DBG("### Connected:", connected);
       return connected;
     } else {
       sendAT(GF("+CIPACK="), mux);

From 13826b08d1f7fc61fad7c18f586767a55e0e9ddb Mon Sep 17 00:00:00 2001
From: Felipe Geremia-Nievinski <fgnievinski@gmail.com>
Date: Wed, 22 Mar 2023 00:49:20 -0300
Subject: [PATCH 016/100] Update README.md

avoid 404 error in chat link
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 890a6d9..d8de9a2 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ If you like **TinyGSM** - give it a star, or fork it and contribute!
 [![GitHub forks](https://img.shields.io/github/forks/vshymanskyy/TinyGSM.svg?style=social&label=Fork)](https://github.com/vshymanskyy/TinyGSM/network)
 
 You can also join our chat:
-[![Gitter](https://img.shields.io/gitter/room/vshymanskyy/TinyGSM.svg)](https://gitter.im/tinygsm)
+[![Gitter](https://img.shields.io/gitter/room/vshymanskyy/TinyGSM.svg)](https://app.gitter.im/#/room/#tinygsm_Lobby:gitter.im)
 
 - [Supported modems](#supported-modems)
   - [Supported boards/modules](#supported-boardsmodules)

From cf4296c6a12e915ca1179021884ba41a06c3c8f4 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Thu, 11 May 2023 16:57:33 -0300
Subject: [PATCH 017/100] SIM card functions

---
 src/TinyGsmClientA7672x.h | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 084a921..4b247fa 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -241,7 +241,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   }
 
   bool factoryDefaultImpl() {
-    sendAT(GF("&F"));  // Factory + Reset
+    sendAT(GF("&F"));        // Factory + Reset
     waitResponse();
     sendAT(GF("+IFC=0,0"));  // No Flow Control
     waitResponse();
@@ -249,10 +249,34 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     waitResponse();
     sendAT(GF("+CSCLK=0"));  // Control UART Sleep always work
     waitResponse();
-    sendAT(GF("&W"));  // Write configuration
+    sendAT(GF("&W"));        // Write configuration
     return waitResponse() == 1;
   }
 
+  /*
+   * SIM card functions
+   */
+ protected:
+  SimStatus getSimStatusImpl(uint32_t timeout_ms = 10000L) {
+    for (uint32_t start = millis(); millis() - start < timeout_ms;) {
+      sendAT(GF("+CPIN?"));
+      if (waitResponse(GF("+CPIN:")) != 1) {
+        delay(1000);
+        continue;
+      }
+      int8_t status = waitResponse(GF("READY"), GF("SIM PIN"), GF("SIM PUK"),
+                                   GF("SIM not inserted"), GF("SIM REMOVED"));
+      waitResponse();
+      switch (status) {
+        case 2:
+        case 3: return SIM_LOCKED;
+        case 1: return SIM_READY;
+        default: return SIM_ERROR;
+      }
+    }
+    return SIM_ERROR;
+  }
+
   /*
    * Power functions
    */
@@ -569,7 +593,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
       streamSkipUntil(',');  // Skip DATA
       streamSkipUntil(',');  // Skip mux
       len_requested = streamGetIntBefore('\n');
-      len_confirmed = len;  // streamGetIntBefore(',');
+      len_confirmed = len;   // streamGetIntBefore(',');
     } else {
       sendAT(GF("+CIPRXGET=2,"), mux, ',', (uint16_t)size);
       if (waitResponse(GF("+CIPRXGET:")) != 1) { return 0; }

From d431b44203d9e53ba9f141111ddee23e7e997933 Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Fri, 2 Jun 2023 16:24:00 -0300
Subject: [PATCH 018/100] 2000 timeout

---
 src/TinyGsmClientA7672x.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 4b247fa..1370cdb 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -185,7 +185,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  A7672X"));
 
-    if (!testAT()) { return false; }
+    if (!testAT(2000)) { return false; }
 
     // sendAT(GF("&FZ"));  // Factory + Reset
     // waitResponse();

From 87523fa6747aac88992768df40fb9a842c0e70d0 Mon Sep 17 00:00:00 2001
From: imodre <btima@mail.ru>
Date: Tue, 4 Jul 2023 06:32:55 +0700
Subject: [PATCH 019/100] * SIM7600 GPS parser bug fixed

---
 src/TinyGsmClientSIM7600.h | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 9f47c5d..fb1ce5b 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -121,7 +121,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     }
 
     /*
-     * Extended API
+     * Exended API
      */
 
     String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
@@ -506,11 +506,9 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
       ialt   = streamGetFloatBefore(',');  // MSL Altitude. Unit is meters
       ispeed = streamGetFloatBefore(',');  // Speed Over Ground. Unit is knots.
       streamSkipUntil(',');                // Course Over Ground. Degrees.
-      streamSkipUntil(',');  // After set, will report GPS every x seconds
       iaccuracy = streamGetFloatBefore(',');  // Position Dilution Of Precision
       streamSkipUntil(',');   // Horizontal Dilution Of Precision
-      streamSkipUntil(',');   // Vertical Dilution Of Precision
-      streamSkipUntil('\n');  // TODO(?) is one more field reported??
+      streamSkipUntil('\n');  // Vertical Dilution Of Precision
 
       // Set pointers
       if (lat != NULL)

From f7e010e6842e78f8e5707097dccaee5fd96bf9f0 Mon Sep 17 00:00:00 2001
From: imodre <btima@mail.ru>
Date: Tue, 4 Jul 2023 06:33:12 +0700
Subject: [PATCH 020/100] * SIM7600 Restart delay fixed

---
 src/TinyGsmClientSIM7600.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index fb1ce5b..7c5e6d4 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -230,7 +230,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     if (!testAT()) { return false; }
     sendAT(GF("+CRESET"));
     if (waitResponse(10000L) != 1) { return false; }
-    delay(5000L);  // TODO(?):  Test this delay!
+    delay(24000L);
     return init(pin);
   }
 

From f775c75d9ce77d2b39ae9122fbfa4fcdd83ffdee Mon Sep 17 00:00:00 2001
From: imodre <btima@mail.ru>
Date: Tue, 4 Jul 2023 06:38:26 +0700
Subject: [PATCH 021/100] * Typo fix

---
 src/TinyGsmClientSIM7600.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 7c5e6d4..c33fc67 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -121,7 +121,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     }
 
     /*
-     * Exended API
+     * Extended API
      */
 
     String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
@@ -230,7 +230,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     if (!testAT()) { return false; }
     sendAT(GF("+CRESET"));
     if (waitResponse(10000L) != 1) { return false; }
-    delay(24000L);
+    delay(24000L)
     return init(pin);
   }
 

From 96313af13d5ffbb92e31301ab80ababb31a7ab75 Mon Sep 17 00:00:00 2001
From: imodre <btima@mail.ru>
Date: Tue, 4 Jul 2023 06:39:24 +0700
Subject: [PATCH 022/100] * Typo fix

---
 src/TinyGsmClientSIM7600.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index c33fc67..7c03f92 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -230,7 +230,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     if (!testAT()) { return false; }
     sendAT(GF("+CRESET"));
     if (waitResponse(10000L) != 1) { return false; }
-    delay(24000L)
+    delay(24000L);
     return init(pin);
   }
 

From 72e519058c9854266f722214db4c2aee678fa27e Mon Sep 17 00:00:00 2001
From: Giovanni <giovanni_unruh@hotmail.com>
Date: Fri, 7 Jul 2023 15:07:42 -0300
Subject: [PATCH 023/100] cert

---
 src/TinyGsmClientA7672x.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 1370cdb..45b231d 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -352,7 +352,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   /*
    * Secure socket layer functions
    */
- protected:
+ public:
   // The name of the certificate/key/password file. The file name must
   // havetype like ".pem" or ".der".
   // The certificate like - const char ca_cert[] PROGMEM =  R"EOF(-----BEGIN...

From 6a919538ef22d616d50e112a6f8044163215a5e5 Mon Sep 17 00:00:00 2001
From: Juxn3 <Juxn3@hotmail.com>
Date: Tue, 25 Jul 2023 12:20:33 -0500
Subject: [PATCH 024/100] Fix cardinal points in location by gps for sim7600

---
 src/TinyGsmClientSIM7600.h | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 9f47c5d..2d5ef63 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -482,15 +482,13 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
       int   imin         = 0;
       float secondWithSS = 0;
 
-      streamSkipUntil(',');               // GPS satellite valid numbers
-      streamSkipUntil(',');               // GLONASS satellite valid numbers
-      streamSkipUntil(',');               // BEIDOU satellite valid numbers
-      ilat  = streamGetFloatBefore(',');  // Latitude in ddmm.mmmmmm
-      north = stream.read();              // N/S Indicator, N=north or S=south
-      streamSkipUntil(',');
-      ilon = streamGetFloatBefore(',');  // Longitude in ddmm.mmmmmm
-      east = stream.read();              // E/W Indicator, E=east or W=west
-      streamSkipUntil(',');
+      streamSkipUntil(',');                           // GPS satellite valid numbers
+      streamSkipUntil(',');                           // GLONASS satellite valid numbers
+      streamSkipUntil(',');                           // BEIDOU satellite valid numbers
+      ilat  = streamGetFloatBefore(',');              // Latitude in ddmm.mmmmmm
+      north = stream.readStringUntil(',').charAt(0);  // N/S Indicator, N=north or S=south
+      ilon  = streamGetFloatBefore(',');              // Longitude in ddmm.mmmmmm
+      east  = stream.readStringUntil(',').charAt(0);  // E/W Indicator, E=east or W=west
 
       // Date. Output format is ddmmyy
       iday   = streamGetIntLength(2);    // Two digit day

From d3c4d1f657e49227850a6274de051bc5cd6b38af Mon Sep 17 00:00:00 2001
From: Sebastian Bergner <54766531+sebastianbergner@users.noreply.github.com>
Date: Wed, 23 Aug 2023 09:52:04 +0200
Subject: [PATCH 025/100] update for use with UBLOX SARA-R5 modules

Extend RegStatus, change getRegistrationStatus to check CREG
---
 src/TinyGsmClientUBLOX.h | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index cf60040..bd97cf4 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -35,13 +35,18 @@ static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
 #endif
 
 enum RegStatus {
-  REG_NO_RESULT    = -1,
-  REG_UNREGISTERED = 0,
-  REG_SEARCHING    = 2,
-  REG_DENIED       = 3,
-  REG_OK_HOME      = 1,
-  REG_OK_ROAMING   = 5,
-  REG_UNKNOWN      = 4,
+  REG_NO_RESULT               = -1,
+  REG_UNREGISTERED            = 0,
+  REG_SEARCHING               = 2,
+  REG_DENIED                  = 3,
+  REG_OK_HOME                 = 1,
+  REG_OK_ROAMING              = 5,
+  REG_UNKNOWN                 = 4,
+  REG_SMS_ONLY_HOME           = 6,
+  REG_SMS_ONLY_ROAMING        = 7,
+  REG_EMERGENCY_ONLY          = 8, // blox AT command manual (for SARA-R5 but should be applicable to all modules) (https://content.u-blox.com/sites/default/files/SARA-R5_ATCommands_UBX-19047455.pdf) states: attached for emergency bearer services only (see 3GPP TS 24.008 [85] and 3GPP TS 24.301 [120] that specify the condition when the MS is considered as attached for emergency bearer services)
+  REG_NO_FALLBACK_LTE_HOME    = 9, // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", home network (applicable only when <AcTStatus> indicates E-UTRAN)
+  REG_NO_FALLBACK_LTE_ROAMING = 10 // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", roaming (applicable only when <AcTStatus> indicates E-UTRAN)
 };
 
 class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
@@ -268,7 +273,8 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    */
  public:
   RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CGREG");
+    //use CREG instead of the CGREG AT command as it supports 2G/3G/4G instead of just 2G/3G connections
+    return (RegStatus)getRegistrationStatusXREG("CREG");
   }
 
   bool setRadioAccessTecnology(int selected, int preferred) {
@@ -297,7 +303,9 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
  protected:
   bool isNetworkConnectedImpl() {
     RegStatus s = getRegistrationStatus();
-    if (s == REG_OK_HOME || s == REG_OK_ROAMING)
+    // check for more registration staus, as some sim cards or tarifs only support SMS
+    // not all status are being checked, maybe have to be added
+    if (s == REG_OK_HOME || s == REG_OK_ROAMING ||  s == REG_SMS_ONLY_ROAMING ||  s == REG_SMS_ONLY_HOME)
       return true;
     else if (s == REG_UNKNOWN)  // for some reason, it can hang at unknown..
       return isGprsConnected();

From 617a70eaebd35c133d13983031a863a50764d36c Mon Sep 17 00:00:00 2001
From: Sebastian Bergner <sebastianbergner5892@gmail.com>
Date: Thu, 24 Aug 2023 16:38:00 +0200
Subject: [PATCH 026/100] revert changes to generic UBLOX class, create ublox
 SARA R5 classes, add required changes to TinyGsmClient

---
 src/TinyGsmClient.h       |   6 +
 src/TinyGsmClientSaraR5.h | 893 ++++++++++++++++++++++++++++++++++++++
 src/TinyGsmClientUBLOX.h  |  26 +-
 3 files changed, 908 insertions(+), 17 deletions(-)
 create mode 100644 src/TinyGsmClientSaraR5.h

diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index a8ae763..64cb61d 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -68,6 +68,12 @@ typedef TinyGsmSaraR4                    TinyGsm;
 typedef TinyGsmSaraR4::GsmClientSaraR4   TinyGsmClient;
 typedef TinyGsmSaraR4::GsmClientSecureR4 TinyGsmClientSecure;
 
+#elif defined(TINY_GSM_MODEM_SARAR5)
+#include "TinyGsmClientSaraR5.h"
+typedef TinyGsmSaraR5                    TinyGsm;
+typedef TinyGsmSaraR5::GsmClientSaraR5   TinyGsmClient;
+typedef TinyGsmSaraR5::GsmClientSecureR5 TinyGsmClientSecure;
+
 #elif defined(TINY_GSM_MODEM_M95)
 #include "TinyGsmClientM95.h"
 typedef TinyGsmM95               TinyGsm;
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
new file mode 100644
index 0000000..e9104ad
--- /dev/null
+++ b/src/TinyGsmClientSaraR5.h
@@ -0,0 +1,893 @@
+/**
+ * @file       TinyGsmClientSaraR5.h
+ * @author     Sebastian Bergner, Volodymyr Shymanskyy
+ * @license    LGPL-3.0
+ * @copyright  Copyright (c) 2016 Volodymyr Shymanskyy
+ * @date       Aug 2023
+ */
+
+#ifndef SRC_TINYGSMCLIENTSARAR5_H_
+#define SRC_TINYGSMCLIENTSARAR5_H_
+// #pragma message("TinyGSM:  TinyGsmClientSaraR5")
+
+// #define TINY_GSM_DEBUG Serial
+
+#define TINY_GSM_MUX_COUNT 7
+#define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmGPS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmModem.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmTCP.tpp"
+#include "TinyGsmTime.tpp"
+
+#include <string.h>
+
+#define GSM_NL "\r\n"
+static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
+static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
+#if defined       TINY_GSM_DEBUG
+static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
+static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
+#endif
+
+enum RegStatus {
+  REG_NO_RESULT               = -1,
+  REG_UNREGISTERED            = 0,
+  REG_SEARCHING               = 2,
+  REG_DENIED                  = 3,
+  REG_OK_HOME                 = 1,
+  REG_OK_ROAMING              = 5,
+  REG_UNKNOWN                 = 4,
+  REG_SMS_ONLY_HOME           = 6,
+  REG_SMS_ONLY_ROAMING        = 7,
+  REG_EMERGENCY_ONLY          = 8, // blox AT command manual states: attached for emergency bearer services only (see 3GPP TS 24.008 [85] and 3GPP TS 24.301 [120] that specify the condition when the MS is considered as attached for emergency bearer services)
+  REG_NO_FALLBACK_LTE_HOME    = 9, // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", home network (applicable only when <AcTStatus> indicates E-UTRAN)
+  REG_NO_FALLBACK_LTE_ROAMING = 10 // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", roaming (applicable only when <AcTStatus> indicates E-UTRAN)
+};
+
+class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
+                     public TinyGsmGPRS<TinyGsmSaraR5>,
+                     public TinyGsmTCP<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>,
+                     public TinyGsmSSL<TinyGsmSaraR5>,
+                     public TinyGsmCalling<TinyGsmSaraR5>,
+                     public TinyGsmSMS<TinyGsmSaraR5>,
+                     public TinyGsmGSMLocation<TinyGsmSaraR5>,
+                     public TinyGsmGPS<TinyGsmSaraR5>,
+                     public TinyGsmTime<TinyGsmSaraR5>,
+                     public TinyGsmBattery<TinyGsmSaraR5> {
+  friend class TinyGsmModem<TinyGsmSaraR5>;
+  friend class TinyGsmGPRS<TinyGsmSaraR5>;
+  friend class TinyGsmTCP<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmSSL<TinyGsmSaraR5>;
+  friend class TinyGsmCalling<TinyGsmSaraR5>;
+  friend class TinyGsmSMS<TinyGsmSaraR5>;
+  friend class TinyGsmGSMLocation<TinyGsmSaraR5>;
+  friend class TinyGsmGPS<TinyGsmSaraR5>;
+  friend class TinyGsmTime<TinyGsmSaraR5>;
+  friend class TinyGsmBattery<TinyGsmSaraR5>;
+
+  /*
+   * Inner Client
+   */
+ public:
+  class GsmClientSaraR5 : public GsmClient {
+    friend class TinyGsmSaraR5;
+
+   public:
+    GsmClientSaraR5() {}
+
+    explicit GsmClientSaraR5(TinyGsmSaraR5& modem, uint8_t mux = 0) {
+      init(&modem, mux);
+    }
+
+    bool init(TinyGsmSaraR5* modem, uint8_t mux = 0) {
+      this->at       = modem;
+      sock_available = 0;
+      prev_check     = 0;
+      sock_connected = false;
+      got_data       = false;
+
+      if (mux < TINY_GSM_MUX_COUNT) {
+        this->mux = mux;
+      } else {
+        this->mux = (mux % TINY_GSM_MUX_COUNT);
+      }
+      at->sockets[this->mux] = this;
+
+      return true;
+    }
+
+   public:
+    virtual int connect(const char* host, uint16_t port, int timeout_s) {
+      // stop();  // DON'T stop!
+      TINY_GSM_YIELD();
+      rx.clear();
+
+      uint8_t oldMux = mux;
+      sock_connected = at->modemConnect(host, port, &mux, false, timeout_s);
+      if (mux != oldMux) {
+        DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
+        at->sockets[oldMux] = NULL;
+      }
+      at->sockets[mux] = this;
+      at->maintain();
+
+      return sock_connected;
+    }
+    TINY_GSM_CLIENT_CONNECT_OVERRIDES
+
+    void stop(uint32_t maxWaitMs) {
+      dumpModemBuffer(maxWaitMs);
+      at->sendAT(GF("+USOCL="), mux);
+      at->waitResponse();  // should return within 1s
+      sock_connected = false;
+    }
+    void stop() override {
+      stop(15000L);
+    }
+
+    /*
+     * Extended API
+     */
+
+    String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  };
+
+  /*
+   * Inner Secure Client
+   */
+ public:
+  class GsmClientSecureR5 : public GsmClientSaraR5 {
+   public:
+    GsmClientSecureR5() {}
+
+    explicit GsmClientSecureR5(TinyGsmSaraR5& modem, uint8_t mux = 0)
+        : GsmClientSaraR5(modem, mux) {}
+
+   public:
+    int connect(const char* host, uint16_t port, int timeout_s) override {
+      // stop();  // DON'T stop!
+      TINY_GSM_YIELD();
+      rx.clear();
+      uint8_t oldMux = mux;
+      sock_connected = at->modemConnect(host, port, &mux, true, timeout_s);
+      if (mux != oldMux) {
+        DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
+        at->sockets[oldMux] = NULL;
+      }
+      at->sockets[mux] = this;
+      at->maintain();
+      return sock_connected;
+    }
+    TINY_GSM_CLIENT_CONNECT_OVERRIDES
+  };
+
+  /*
+   * Constructor
+   */
+ public:
+  explicit TinyGsmSaraR5(Stream& stream) : stream(stream) {
+    memset(sockets, 0, sizeof(sockets));
+  }
+
+  /*
+   * Basic functions
+   */
+ protected:
+  bool initImpl(const char* pin = NULL) {
+    DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
+    DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSaraR5"));
+
+    if (!testAT()) { return false; }
+
+    sendAT(GF("E0"));  // Echo Off
+    if (waitResponse() != 1) { return false; }
+
+#ifdef TINY_GSM_DEBUG
+    sendAT(GF("+CMEE=2"));  // turn on verbose error codes
+#else
+    sendAT(GF("+CMEE=0"));  // turn off error codes
+#endif
+    waitResponse();
+
+    DBG(GF("### Modem:"), getModemName());
+
+    // Enable automatic time zome update
+    sendAT(GF("+CTZU=1"));
+    waitResponse(10000L);
+    // Ignore the response, in case the network doesn't support it.
+    // if (waitResponse(10000L) != 1) { return false; }
+
+    SimStatus ret = getSimStatus();
+    // if the sim isn't ready and a pin has been provided, try to unlock the sim
+    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+      simUnlock(pin);
+      return (getSimStatus() == SIM_READY);
+    } else {
+      // if the sim is ready, or it's locked but no pin has been provided,
+      // return true
+      return (ret == SIM_READY || ret == SIM_LOCKED);
+    }
+  }
+
+  // only difference in implementation is the warning on the wrong type
+  String getModemNameImpl() {
+    sendAT(GF("+CGMI"));
+    String res1;
+    if (waitResponse(1000L, res1) != 1) { return "u-blox Cellular Modem"; }
+    res1.replace(GSM_NL "OK" GSM_NL, "");
+    res1.trim();
+
+    sendAT(GF("+GMM"));
+    String res2;
+    if (waitResponse(1000L, res2) != 1) { return "u-blox Cellular Modem"; }
+    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.trim();
+
+    String name = res1 + String(' ') + res2;
+    if (name.startsWith("u-blox SARA-R4") ||
+        name.startsWith("u-blox SARA-N4")) {
+      DBG("### WARNING:  You are using the wrong TinyGSM modem!");
+    } else if (name.startsWith("u-blox SARA-N2")) {
+      DBG("### SARA N2 NB-IoT modems not supported!");
+    }
+
+    return name;
+  }
+
+  bool factoryDefaultImpl() {
+    sendAT(GF("+UFACTORY=0,1"));  // No factory restore, erase NVM
+    waitResponse();
+    return setPhoneFunctionality(16);  // Reset
+  }
+
+  /*
+   * Power functions
+   */
+ protected:
+  bool restartImpl(const char* pin = NULL) {
+    if (!testAT()) { return false; }
+    if (!setPhoneFunctionality(16)) { return false; }
+    delay(3000);  // TODO(?):  Verify delay timing here
+    return init(pin);
+  }
+
+  bool powerOffImpl() {
+    sendAT(GF("+CPWROFF"));
+    return waitResponse(40000L) == 1;
+  }
+
+  bool sleepEnableImpl(bool enable = true) TINY_GSM_ATTR_NOT_AVAILABLE;
+
+  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false) {
+    sendAT(GF("+CFUN="), fun, reset ? ",1" : "");
+    return waitResponse(10000L) == 1;
+  }
+
+  /*
+   * Generic network functions
+   */
+ public:
+  RegStatus getRegistrationStatus() {
+    //use CREG instead of the CGREG AT command as it supports 2G/3G/4G instead of just 2G/3G connections  
+    return (RegStatus)getRegistrationStatusXREG("CREG");
+  }
+
+  bool setRadioAccessTechnology(int selected, int preferred) {
+    // selected:
+    // 0: GSM / GPRS / eGPRS (single mode)
+    // 1: GSM / UMTS (dual mode)
+    // 2: UMTS (single mode)
+    // 3: LTE (single mode)
+    // 4: GSM / UMTS / LTE (tri mode)
+    // 5: GSM / LTE (dual mode)
+    // 6: UMTS / LTE (dual mode)
+    // preferred:
+    // 0: GSM / GPRS / eGPRS
+    // 2: UTRAN
+    // 3: LTE
+    sendAT(GF("+URAT="), selected, GF(","), preferred);
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+
+  bool getCurrentRadioAccessTechnology(int&) {
+    // @TODO
+    return false;
+  }
+
+ protected:
+  bool isNetworkConnectedImpl() {
+    RegStatus s = getRegistrationStatus();
+    Serial.printf("REGISTRATION STATUS: %i\n", (int)s);
+    if (s == REG_OK_HOME || s == REG_OK_ROAMING ||  s == REG_SMS_ONLY_ROAMING ||  s == REG_SMS_ONLY_HOME)
+      return true;
+    else if (s == REG_UNKNOWN)  // for some reason, it can hang at unknown..
+      return isGprsConnected();
+    else
+      return false;
+  }
+
+  String getLocalIPImpl() {
+    sendAT(GF("+UPSND=0,0"));
+    if (waitResponse(GF(GSM_NL "+UPSND:")) != 1) { return ""; }
+    streamSkipUntil(',');   // Skip PSD profile
+    streamSkipUntil('\"');  // Skip request type
+    String res = stream.readStringUntil('\"');
+    if (waitResponse() != 1) { return ""; }
+    return res;
+  }
+
+  /*
+   * GPRS functions
+   */
+ protected:
+  bool gprsConnectImpl(const char* apn, const char* user = NULL,
+                       const char* pwd = NULL) {
+
+    sendAT(GF("+CGATT=1"));  // attach to GPRS
+    if (waitResponse(360000L) != 1) { return false; }
+
+    // Setting up the PSD profile/PDP context with the UPSD commands sets up an
+    // "internal" PDP context, i.e. a data connection using the internal IP
+    // stack and related AT commands for sockets.
+
+    // Packet switched data configuration
+    // AT+UPSD=<profile_id>,<param_tag>,<param_val>
+    // profile_id = 0 - PSD profile identifier, in range 0-6 (NOT PDP context)
+    // param_tag = 1: APN
+    // param_tag = 2: username  -> not working for SARA-R5  
+    // param_tag = 3: password  -> not working for SARA-R5
+    // param_tag = 7: IP address Note: IP address set as "0.0.0.0" means
+    //    dynamic IP address assigned during PDP context activation
+    
+
+    // check all available PDP context identifiers
+    String response;
+    response.reserve(1024);
+    sendAT(GF("+CGDCONT?"));
+    //Serial.println(waitResponse(300, response, NULL));// overwrite GSM_OK as the stream most probably still has data which would cause ### Unhandled: ....
+    waitResponseUntilEndStream(1000, response);
+    Serial.println(response);
+
+    if (response.length() == 0){
+      return false;       // no apn at all found
+    }
+    // Serial.println("we got here 3");
+    // parse string & look for apn -> modified from SparkFun u-blox SARA-R5 lib
+    // Example:
+    // +CGDCONT: 0,"IP","payandgo.o2.co.uk","0.0.0.0",0,0,0,0,0,0,0,0,0,0
+    // +CGDCONT: 1,"IP","payandgo.o2.co.uk.mnc010.mcc234.gprs","10.160.182.234",0,0,0,2,0,0,0,0,0,0
+    
+    //create search buffer where we can search
+    char *searchBuf = (char*)malloc(response.length()+1);
+    response.toCharArray(searchBuf, response.length()+1);
+
+    int rcid = -1;
+    char *searchPtr = searchBuf;
+
+    for(size_t index = 0; index<=response.length(); index++){
+      int scanned = 0;
+      // Find the first/next occurrence of +CGDCONT:
+      searchPtr = strstr(searchPtr, "+CGDCONT:");
+      if (searchPtr != nullptr){
+        char strPdpType[10];
+        char strApn[128];
+        int ipOct[4];
+
+        searchPtr += strlen("+CGDCONT:");
+        while (*searchPtr == ' ') searchPtr++; // skip spaces
+        scanned = sscanf(searchPtr, "%d,\"%[^\"]\",\"%[^\"]\",\"%d.%d.%d.%d", &rcid, strPdpType, strApn, &ipOct[0], &ipOct[1], &ipOct[2], &ipOct[3]);
+        
+        if (!strcmp(strApn, apn)){
+          // found the configuration that we want to connect to
+          break;
+        }
+      }
+    }
+
+    sendAT(GF("+UPSDA=0,4")); // Deactivate the PDP context associated with profile 0
+    waitResponse(360000L);    // Can return an error if previously not activated
+
+    sendAT(GF("+UPSD=0,100,")+String(rcid)); // Deactivate the PDP context associated with profile 0
+    waitResponse();
+
+    sendAT(GF("+UPSDA=0,3")); // Activate the PDP context associated with profile 0
+    if (waitResponse(360000L) != 1) { return false; }
+
+    sendAT(GF("+UPSD=0,0,2"));  // Set protocol type to IPv4v6 with IPv4 preferred for internal sockets
+    waitResponse();
+
+    return true;
+  }
+
+  bool gprsDisconnectImpl() {
+    sendAT(GF(
+        "+UPSDA=0,4"));  // Deactivate the PDP context associated with profile 0
+    if (waitResponse(360000L) != 1) { return false; }
+
+    sendAT(GF("+CGATT=0"));  // detach from GPRS
+    if (waitResponse(360000L) != 1) { return false; }
+
+    return true;
+  }
+
+  /*
+   * SIM card functions
+   */
+ protected:
+  // This uses "CGSN" instead of "GSN"
+  String getIMEIImpl() {
+    sendAT(GF("+CGSN"));
+    if (waitResponse(GF(GSM_NL)) != 1) { return ""; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.trim();
+    return res;
+  }
+
+  /*
+   * Phone Call functions
+   */
+ protected:
+  // Can follow all of the phone call functions from the template
+
+  /*
+   * Messaging functions
+   */
+ protected:
+  // Can follow all template functions
+
+  /*
+   * GSM/GPS/GNSS/GLONASS Location functions
+   * NOTE:  u-blox modules use the same function to get location data from both
+   * GSM tower triangulation and from dedicated GPS/GNSS/GLONASS receivers.  The
+   * only difference in which sensor the data is requested from.  If a GNSS
+   * location is requested from a modem without a GNSS receiver installed on the
+   * I2C port, the GSM-based "Cell Locate" location will be returned instead.
+   */
+ protected:
+  bool enableGPSImpl() {
+    // AT+UGPS=<mode>[,<aid_mode>[,<GNSS_systems>]]
+    // <mode> - 0: GNSS receiver powered off, 1: on
+    // <aid_mode> - 0: no aiding (default)
+    // <GNSS_systems> - 3: GPS + SBAS (default)
+    sendAT(GF("+UGPS=1,0,3"));
+    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
+    return waitResponse(10000L) == 1;
+  }
+  bool disableGPSImpl() {
+    sendAT(GF("+UGPS=0"));
+    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
+    return waitResponse(10000L) == 1;
+  }
+  String inline getUbloxLocationRaw(int8_t sensor) {
+    // AT+ULOC=<mode>,<sensor>,<response_type>,<timeout>,<accuracy>
+    // <mode> - 2: single shot position
+    // <sensor> - 0: use the last fix in the internal database and stop the GNSS
+    //          receiver
+    //          - 1: use the GNSS receiver for localization
+    //          - 2: use cellular CellLocate location information
+    //          - 3: ?? use the combined GNSS receiver and CellLocate service
+    //          information ?? - Docs show using sensor 3 and it's
+    //          documented for the +UTIME command but not for +ULOC
+    // <response_type> - 0: standard (single-hypothesis) response
+    // <timeout> - Timeout period in seconds
+    // <accuracy> - Target accuracy in meters (1 - 999999)
+    sendAT(GF("+ULOC=2,"), sensor, GF(",0,120,1"));
+    // wait for first "OK"
+    if (waitResponse(10000L) != 1) { return ""; }
+    // wait for the final result - wait full timeout time
+    if (waitResponse(120000L, GF(GSM_NL "+UULOC:")) != 1) { return ""; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.trim();
+    return res;
+  }
+  String getGsmLocationRawImpl() {
+    return getUbloxLocationRaw(2);
+  }
+  String getGPSrawImpl() {
+    return getUbloxLocationRaw(1);
+  }
+
+  inline bool getUbloxLocation(int8_t sensor, float* lat, float* lon,
+                               float* speed = 0, float* alt = 0, int* vsat = 0,
+                               int* usat = 0, float* accuracy = 0,
+                               int* year = 0, int* month = 0, int* day = 0,
+                               int* hour = 0, int* minute = 0,
+                               int* second = 0) {
+    // AT+ULOC=<mode>,<sensor>,<response_type>,<timeout>,<accuracy>
+    // <mode> - 2: single shot position
+    // <sensor> - 2: use cellular CellLocate location information
+    //          - 0: use the last fix in the internal database and stop the GNSS
+    //          receiver
+    //          - 1: use the GNSS receiver for localization
+    //          - 3: ?? use the combined GNSS receiver and CellLocate service
+    //          information ?? - Docs show using sensor 3 and it's documented
+    //          for the +UTIME command but not for +ULOC
+    // <response_type> - 0: standard (single-hypothesis) response
+    // <timeout> - Timeout period in seconds
+    // <accuracy> - Target accuracy in meters (1 - 999999)
+    sendAT(GF("+ULOC=2,"), sensor, GF(",0,120,1"));
+    // wait for first "OK"
+    if (waitResponse(10000L) != 1) { return false; }
+    // wait for the final result - wait full timeout time
+    if (waitResponse(120000L, GF(GSM_NL "+UULOC: ")) != 1) { return false; }
+
+    // +UULOC: <date>, <time>, <lat>, <long>, <alt>, <uncertainty>, <speed>,
+    // <direction>, <vertical_acc>, <sensor_used>, <SV_used>, <antenna_status>,
+    // <jamming_status>
+
+    // init variables
+    float ilat         = 0;
+    float ilon         = 0;
+    float ispeed       = 0;
+    float ialt         = 0;
+    int   iusat        = 0;
+    float iaccuracy    = 0;
+    int   iyear        = 0;
+    int   imonth       = 0;
+    int   iday         = 0;
+    int   ihour        = 0;
+    int   imin         = 0;
+    float secondWithSS = 0;
+
+    // Date & Time
+    iday         = streamGetIntBefore('/');    // Two digit day
+    imonth       = streamGetIntBefore('/');    // Two digit month
+    iyear        = streamGetIntBefore(',');    // Four digit year
+    ihour        = streamGetIntBefore(':');    // Two digit hour
+    imin         = streamGetIntBefore(':');    // Two digit minute
+    secondWithSS = streamGetFloatBefore(',');  // 6 digit second with subseconds
+
+    ilat = streamGetFloatBefore(',');  // Estimated latitude, in degrees
+    ilon = streamGetFloatBefore(',');  // Estimated longitude, in degrees
+    ialt = streamGetFloatBefore(
+        ',');         // Estimated altitude, in meters - only forGNSS
+                      // positioning, 0 in case of CellLocate
+    if (ialt != 0) {  // values not returned for CellLocate
+      iaccuracy =
+          streamGetFloatBefore(',');       // Maximum possible error, in meters
+      ispeed = streamGetFloatBefore(',');  // Speed over ground m/s3
+      streamSkipUntil(',');  // Course over ground in degree (0 deg - 360 deg)
+      streamSkipUntil(',');  // Vertical accuracy, in meters
+      streamSkipUntil(',');  // Sensor used for the position calculation
+      iusat = streamGetIntBefore(',');  // Number of satellite used
+      streamSkipUntil(',');             // Antenna status
+      streamSkipUntil('\n');            // Jamming status
+    } else {
+      iaccuracy =
+          streamGetFloatBefore('\n');  // Maximum possible error, in meters
+    }
+
+    // Set pointers
+    if (lat != NULL) *lat = ilat;
+    if (lon != NULL) *lon = ilon;
+    if (speed != NULL) *speed = ispeed;
+    if (alt != NULL) *alt = ialt;
+    if (vsat != NULL) *vsat = 0;  // Number of satellites viewed not reported;
+    if (usat != NULL) *usat = iusat;
+    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (iyear < 2000) iyear += 2000;
+    if (year != NULL) *year = iyear;
+    if (month != NULL) *month = imonth;
+    if (day != NULL) *day = iday;
+    if (hour != NULL) *hour = ihour;
+    if (minute != NULL) *minute = imin;
+    if (second != NULL) *second = static_cast<int>(secondWithSS);
+
+    // final ok
+    waitResponse();
+    return true;
+  }
+  bool getGsmLocationImpl(float* lat, float* lon, float* accuracy = 0,
+                          int* year = 0, int* month = 0, int* day = 0,
+                          int* hour = 0, int* minute = 0, int* second = 0) {
+    return getUbloxLocation(2, lat, lon, 0, 0, 0, 0, accuracy, year, month, day,
+                            hour, minute, second);
+  }
+  bool getGPSImpl(float* lat, float* lon, float* speed = 0, float* alt = 0,
+                  int* vsat = 0, int* usat = 0, float* accuracy = 0,
+                  int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
+                  int* minute = 0, int* second = 0) {
+    return getUbloxLocation(1, lat, lon, speed, alt, vsat, usat, accuracy, year,
+                            month, day, hour, minute, second);
+  }
+
+  /*
+   * Time functions
+   */
+ protected:
+  // Can follow the standard CCLK function in the template
+
+  /*
+   * Battery functions
+   */
+ protected:
+  uint16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+
+  int8_t getBattPercentImpl() {
+    sendAT(GF("+CIND?"));
+    if (waitResponse(GF(GSM_NL "+CIND:")) != 1) { return 0; }
+
+    int8_t res     = streamGetIntBefore(',');
+    int8_t percent = res * 20;  // return is 0-5
+    // Wait for final OK
+    waitResponse();
+    return percent;
+  }
+
+  uint8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+
+  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
+                        uint16_t& milliVolts) {
+    chargeState = 0;
+    percent     = getBattPercent();
+    milliVolts  = 0;
+    return true;
+  }
+
+  /*
+   * Temperature functions
+   */
+
+  // This would only available for a small number of modules in this group
+  // (TOBY-L)
+  float getTemperatureImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+
+  /*
+   * Client related functions
+   */
+ protected:
+  bool modemConnect(const char* host, uint16_t port, uint8_t* mux,
+                    bool ssl = false, int timeout_s = 120) {
+    uint32_t timeout_ms  = ((uint32_t)timeout_s) * 1000;
+    uint32_t startMillis = millis();
+
+    // create a socket
+    sendAT(GF("+USOCR=6"));
+    // reply is +USOCR: ## of socket created
+    if (waitResponse(GF(GSM_NL "+USOCR:")) != 1) { return false; }
+    *mux = streamGetIntBefore('\n');
+    waitResponse();
+
+    if (ssl) {
+      sendAT(GF("+USOSEC="), *mux, ",1");
+      waitResponse();
+    }
+
+    // Enable NODELAY
+    // AT+USOSO=<socket>,<level>,<opt_name>,<opt_val>[,<opt_val2>]
+    // <level> - 0 for IP, 6 for TCP, 65535 for socket level options
+    // <opt_name> TCP/1 = no delay (do not delay send to coalesce packets)
+    // NOTE:  Enabling this may increase data plan usage
+    // sendAT(GF("+USOSO="), *mux, GF(",6,1,1"));
+    // waitResponse();
+
+    // Enable KEEPALIVE, 30 sec
+    // sendAT(GF("+USOSO="), *mux, GF(",6,2,30000"));
+    // waitResponse();
+
+    // connect on the allocated socket
+    sendAT(GF("+USOCO="), *mux, ",\"", host, "\",", port);
+    int8_t rsp = waitResponse(timeout_ms - (millis() - startMillis));
+    return (1 == rsp);
+  }
+
+  int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
+    sendAT(GF("+USOWR="), mux, ',', (uint16_t)len);
+    if (waitResponse(GF("@")) != 1) { return 0; }
+    // 50ms delay, see AT manual section 25.10.4
+    delay(50);
+    stream.write(reinterpret_cast<const uint8_t*>(buff), len);
+    stream.flush();
+    if (waitResponse(GF(GSM_NL "+USOWR:")) != 1) { return 0; }
+    streamSkipUntil(',');  // Skip mux
+    int16_t sent = streamGetIntBefore('\n');
+    waitResponse();  // sends back OK after the confirmation of number sent
+    return sent;
+  }
+
+  size_t modemRead(size_t size, uint8_t mux) {
+    if (!sockets[mux]) return 0;
+    sendAT(GF("+USORD="), mux, ',', (uint16_t)size);
+    if (waitResponse(GF(GSM_NL "+USORD:")) != 1) { return 0; }
+    streamSkipUntil(',');  // Skip mux
+    int16_t len = streamGetIntBefore(',');
+    streamSkipUntil('\"');
+
+    for (int i = 0; i < len; i++) { moveCharFromStreamToFifo(mux); }
+    streamSkipUntil('\"');
+    waitResponse();
+    // DBG("### READ:", len, "from", mux);
+    sockets[mux]->sock_available = modemGetAvailable(mux);
+    return len;
+  }
+
+  size_t modemGetAvailable(uint8_t mux) {
+    if (!sockets[mux]) return 0;
+    // NOTE:  Querying a closed socket gives an error "operation not allowed"
+    sendAT(GF("+USORD="), mux, ",0");
+    size_t  result = 0;
+    uint8_t res    = waitResponse(GF(GSM_NL "+USORD:"));
+    // Will give error "operation not allowed" when attempting to read a socket
+    // that you have already told to close
+    if (res == 1) {
+      streamSkipUntil(',');  // Skip mux
+      result = streamGetIntBefore('\n');
+      // if (result) DBG("### DATA AVAILABLE:", result, "on", mux);
+      waitResponse();
+    }
+    if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
+    // DBG("### AvailablE:", result, "on", mux);
+    return result;
+  }
+
+  bool modemGetConnected(uint8_t mux) {
+    // NOTE:  Querying a closed socket gives an error "operation not allowed"
+    sendAT(GF("+USOCTL="), mux, ",10");
+    uint8_t res = waitResponse(GF(GSM_NL "+USOCTL:"));
+    if (res != 1) { return false; }
+
+    streamSkipUntil(',');  // Skip mux
+    streamSkipUntil(',');  // Skip type
+    int8_t result = streamGetIntBefore('\n');
+    // 0: the socket is in INACTIVE status (it corresponds to CLOSED status
+    // defined in RFC793 "TCP Protocol Specification" [112])
+    // 1: the socket is in LISTEN status
+    // 2: the socket is in SYN_SENT status
+    // 3: the socket is in SYN_RCVD status
+    // 4: the socket is in ESTABILISHED status
+    // 5: the socket is in FIN_WAIT_1 status
+    // 6: the socket is in FIN_WAIT_2 status
+    // 7: the sokcet is in CLOSE_WAIT status
+    // 8: the socket is in CLOSING status
+    // 9: the socket is in LAST_ACK status
+    // 10: the socket is in TIME_WAIT status
+    waitResponse();
+    return (result != 0);
+  }
+
+  /*
+   * Utilities
+   */
+ public:
+  // TODO(vshymanskyy): Optimize this!
+  int8_t waitResponse(uint32_t timeout_ms, String& data,
+                      GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    /*String r1s(r1); r1s.trim();
+    String r2s(r2); r2s.trim();
+    String r3s(r3); r3s.trim();
+    String r4s(r4); r4s.trim();
+    String r5s(r5); r5s.trim();
+    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
+    data.reserve(64);
+    uint8_t  index       = 0;
+    uint32_t startMillis = millis();
+    do {
+      TINY_GSM_YIELD();
+      while (stream.available() > 0) {
+        TINY_GSM_YIELD();
+        int8_t a = stream.read();
+        
+        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
+        data += static_cast<char>(a);
+        if (r1 && data.endsWith(r1)) {
+          index = 1;
+          goto finish;
+        } else if (r2 && data.endsWith(r2)) {
+          index = 2;
+          goto finish;
+        } else if (r3 && data.endsWith(r3)) {
+#if defined TINY_GSM_DEBUG
+          if (r3 == GFP(GSM_CME_ERROR)) {
+            streamSkipUntil('\n');  // Read out the error
+          }
+#endif
+          index = 3;
+          goto finish;
+        } else if (r4 && data.endsWith(r4)) {
+          index = 4;
+          goto finish;
+        } else if (r5 && data.endsWith(r5)) {
+          index = 5;
+          goto finish;
+        } else if (data.endsWith(GF("+UUSORD:"))) {
+          int8_t  mux = streamGetIntBefore(',');
+          int16_t len = streamGetIntBefore('\n');
+          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+            sockets[mux]->got_data = true;
+            // max size is 1024
+            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
+          }
+          data = "";
+          // DBG("### URC Data Received:", len, "on", mux);
+        } else if (data.endsWith(GF("+UUSOCL:"))) {
+          int8_t mux = streamGetIntBefore('\n');
+          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+            sockets[mux]->sock_connected = false;
+          }
+          data = "";
+          DBG("### URC Sock Closed: ", mux);
+        }
+      }
+    } while (millis() - startMillis < timeout_ms);
+  finish:
+    if (!index) {
+      data.trim();
+      if (data.length()) { DBG("### Unhandled:", data); }
+      data = "";
+    }
+    // data.replace(GSM_NL, "/");
+    // DBG('<', index, '>', data);
+    return index;
+  }
+
+  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    String data;
+    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
+  }
+
+  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    return waitResponse(1000, r1, r2, r3, r4, r5);
+  }
+
+private:  // basically the same as waitResponse but without preemptive exiting (except when time runs out)
+          // this is required for +CGDCONT? as it can return multiple cid/apn configurations each terminated with OK\r\n
+  int8_t waitResponseUntilEndStream(uint32_t timeout_ms, String& data) {
+    data.reserve(1024); // buffer of the same size as in the SparkFun lib
+    uint8_t  index       = 0;
+    uint32_t startMillis = millis();
+    do {
+      TINY_GSM_YIELD();
+      while (stream.available() > 0) {
+        TINY_GSM_YIELD();
+        int8_t a = stream.read();
+        
+        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
+        data += static_cast<char>(a);
+      }
+    } while (millis() - startMillis < timeout_ms);
+    return index;
+  }
+
+ public:
+  Stream& stream;
+
+ protected:
+  GsmClientSaraR5* sockets[TINY_GSM_MUX_COUNT];
+  const char*     gsmNL = GSM_NL;
+};
+
+#endif  // SRC_TINYGSMCLIENTSARAR5_H_
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index bd97cf4..cf60040 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -35,18 +35,13 @@ static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
 #endif
 
 enum RegStatus {
-  REG_NO_RESULT               = -1,
-  REG_UNREGISTERED            = 0,
-  REG_SEARCHING               = 2,
-  REG_DENIED                  = 3,
-  REG_OK_HOME                 = 1,
-  REG_OK_ROAMING              = 5,
-  REG_UNKNOWN                 = 4,
-  REG_SMS_ONLY_HOME           = 6,
-  REG_SMS_ONLY_ROAMING        = 7,
-  REG_EMERGENCY_ONLY          = 8, // blox AT command manual (for SARA-R5 but should be applicable to all modules) (https://content.u-blox.com/sites/default/files/SARA-R5_ATCommands_UBX-19047455.pdf) states: attached for emergency bearer services only (see 3GPP TS 24.008 [85] and 3GPP TS 24.301 [120] that specify the condition when the MS is considered as attached for emergency bearer services)
-  REG_NO_FALLBACK_LTE_HOME    = 9, // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", home network (applicable only when <AcTStatus> indicates E-UTRAN)
-  REG_NO_FALLBACK_LTE_ROAMING = 10 // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", roaming (applicable only when <AcTStatus> indicates E-UTRAN)
+  REG_NO_RESULT    = -1,
+  REG_UNREGISTERED = 0,
+  REG_SEARCHING    = 2,
+  REG_DENIED       = 3,
+  REG_OK_HOME      = 1,
+  REG_OK_ROAMING   = 5,
+  REG_UNKNOWN      = 4,
 };
 
 class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
@@ -273,8 +268,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    */
  public:
   RegStatus getRegistrationStatus() {
-    //use CREG instead of the CGREG AT command as it supports 2G/3G/4G instead of just 2G/3G connections
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+    return (RegStatus)getRegistrationStatusXREG("CGREG");
   }
 
   bool setRadioAccessTecnology(int selected, int preferred) {
@@ -303,9 +297,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
  protected:
   bool isNetworkConnectedImpl() {
     RegStatus s = getRegistrationStatus();
-    // check for more registration staus, as some sim cards or tarifs only support SMS
-    // not all status are being checked, maybe have to be added
-    if (s == REG_OK_HOME || s == REG_OK_ROAMING ||  s == REG_SMS_ONLY_ROAMING ||  s == REG_SMS_ONLY_HOME)
+    if (s == REG_OK_HOME || s == REG_OK_ROAMING)
       return true;
     else if (s == REG_UNKNOWN)  // for some reason, it can hang at unknown..
       return isGprsConnected();

From 7ae1f4dff9aec81c0ae999fa784583d84100d355 Mon Sep 17 00:00:00 2001
From: Sebastian Bergner <sebastianbergner5892@gmail.com>
Date: Thu, 31 Aug 2023 11:08:00 +0200
Subject: [PATCH 027/100] changes to get gnss working

---
 src/TinyGsmBluetooth.tpp          |  12 +-
 src/TinyGsmClientSIM808.h         |  24 ++-
 src/TinyGsmClientSaraR5.h         | 180 ++++++++++++----------
 src/TinyGsmClientSequansMonarch.h |   7 +-
 src/TinyGsmFifo.h                 | 239 ++++++++++++++----------------
 src/TinyGsmSMS.tpp                |   8 +-
 src/TinyGsmTCP.tpp                |   6 +-
 7 files changed, 241 insertions(+), 235 deletions(-)

diff --git a/src/TinyGsmBluetooth.tpp b/src/TinyGsmBluetooth.tpp
index ca1cb4e..58b538d 100644
--- a/src/TinyGsmBluetooth.tpp
+++ b/src/TinyGsmBluetooth.tpp
@@ -29,9 +29,9 @@ class TinyGsmBluetooth {
     return thisModem().setBluetoothVisibilityImpl(visible);
   }
   bool setBluetoothHostName(const char* name) {
-	return thisModem().setBluetoothHostNameImpl(name);
+    return thisModem().setBluetoothHostNameImpl(name);
   }
-  
+
   /*
    * CRTP Helper
    */
@@ -47,10 +47,10 @@ class TinyGsmBluetooth {
    * Bluetooth functions
    */
 
-  bool    enableBluetoothImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
-  bool    disableBluetoothImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
-  bool    setBluetoothVisibilityImpl(bool visible) TINY_GSM_ATTR_NOT_IMPLEMENTED;
-  bool    setBluetoothHostNameImpl(const char* name) TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  bool enableBluetoothImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  bool disableBluetoothImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  bool setBluetoothVisibilityImpl(bool visible) TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  bool setBluetoothHostNameImpl(const char* name) TINY_GSM_ATTR_NOT_IMPLEMENTED;
 };
 
 
diff --git a/src/TinyGsmClientSIM808.h b/src/TinyGsmClientSIM808.h
index 7398bfa..ed09be8 100644
--- a/src/TinyGsmClientSIM808.h
+++ b/src/TinyGsmClientSIM808.h
@@ -14,7 +14,9 @@
 #include "TinyGsmGPS.tpp"
 #include "TinyGsmBluetooth.tpp"
 
-class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, public TinyGsmBluetooth<TinyGsmSim808> {
+class TinyGsmSim808 : public TinyGsmSim800,
+                      public TinyGsmGPS<TinyGsmSim808>,
+                      public TinyGsmBluetooth<TinyGsmSim808> {
   friend class TinyGsmGPS<TinyGsmSim808>;
   friend class TinyGsmBluetooth<TinyGsmSim808>;
 
@@ -129,11 +131,11 @@ class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, pu
     waitResponse();
     return false;
   }
-  
-    /*
+
+  /*
    * Bluetooth functions
    */
-   
+
   bool enableBluetoothImpl() {
     sendAT(GF("+BTPOWER=1"));
     if (waitResponse() != 1) { return false; }
@@ -145,22 +147,18 @@ class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, pu
     if (waitResponse() != 1) { return false; }
     return true;
   }
-  
+
   bool setBluetoothVisibilityImpl(bool visible) {
     sendAT(GF("+BTVIS="), visible);
-    if (waitResponse() != 1) {
-      return false;
-    }
-    
+    if (waitResponse() != 1) { return false; }
+
     return true;
   }
 
   bool setBluetoothHostNameImpl(const char* name) {
     sendAT(GF("+BTHOST="), name);
-    if (waitResponse() != 1) {
-      return false;
-    }
-    
+    if (waitResponse() != 1) { return false; }
+
     return true;
   }
 };
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index e9104ad..7c59c85 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -37,30 +37,40 @@ static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
 #endif
 
 enum RegStatus {
-  REG_NO_RESULT               = -1,
-  REG_UNREGISTERED            = 0,
-  REG_SEARCHING               = 2,
-  REG_DENIED                  = 3,
-  REG_OK_HOME                 = 1,
-  REG_OK_ROAMING              = 5,
-  REG_UNKNOWN                 = 4,
-  REG_SMS_ONLY_HOME           = 6,
-  REG_SMS_ONLY_ROAMING        = 7,
-  REG_EMERGENCY_ONLY          = 8, // blox AT command manual states: attached for emergency bearer services only (see 3GPP TS 24.008 [85] and 3GPP TS 24.301 [120] that specify the condition when the MS is considered as attached for emergency bearer services)
-  REG_NO_FALLBACK_LTE_HOME    = 9, // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", home network (applicable only when <AcTStatus> indicates E-UTRAN)
-  REG_NO_FALLBACK_LTE_ROAMING = 10 // not 100% certain, ublox AT command manual states: registered for "CSFB not preferred", roaming (applicable only when <AcTStatus> indicates E-UTRAN)
+  REG_NO_RESULT        = -1,
+  REG_UNREGISTERED     = 0,
+  REG_SEARCHING        = 2,
+  REG_DENIED           = 3,
+  REG_OK_HOME          = 1,
+  REG_OK_ROAMING       = 5,
+  REG_UNKNOWN          = 4,
+  REG_SMS_ONLY_HOME    = 6,
+  REG_SMS_ONLY_ROAMING = 7,
+  REG_EMERGENCY_ONLY =
+      8,  // blox AT command manual states: attached for emergency bearer
+          // services only (see 3GPP TS 24.008 [85] and 3GPP TS 24.301 [120]
+          // that specify the condition when the MS is considered as attached
+          // for emergency bearer services)
+  REG_NO_FALLBACK_LTE_HOME =
+      9,  // not 100% certain, ublox AT command manual states: registered for
+          // "CSFB not preferred", home network (applicable only when
+          // <AcTStatus> indicates E-UTRAN)
+  REG_NO_FALLBACK_LTE_ROAMING =
+      10  // not 100% certain, ublox AT command manual states: registered for
+          // "CSFB not preferred", roaming (applicable only when <AcTStatus>
+          // indicates E-UTRAN)
 };
 
 class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
-                     public TinyGsmGPRS<TinyGsmSaraR5>,
-                     public TinyGsmTCP<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>,
-                     public TinyGsmSSL<TinyGsmSaraR5>,
-                     public TinyGsmCalling<TinyGsmSaraR5>,
-                     public TinyGsmSMS<TinyGsmSaraR5>,
-                     public TinyGsmGSMLocation<TinyGsmSaraR5>,
-                     public TinyGsmGPS<TinyGsmSaraR5>,
-                     public TinyGsmTime<TinyGsmSaraR5>,
-                     public TinyGsmBattery<TinyGsmSaraR5> {
+                      public TinyGsmGPRS<TinyGsmSaraR5>,
+                      public TinyGsmTCP<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>,
+                      public TinyGsmSSL<TinyGsmSaraR5>,
+                      public TinyGsmCalling<TinyGsmSaraR5>,
+                      public TinyGsmSMS<TinyGsmSaraR5>,
+                      public TinyGsmGSMLocation<TinyGsmSaraR5>,
+                      public TinyGsmGPS<TinyGsmSaraR5>,
+                      public TinyGsmTime<TinyGsmSaraR5>,
+                      public TinyGsmBattery<TinyGsmSaraR5> {
   friend class TinyGsmModem<TinyGsmSaraR5>;
   friend class TinyGsmGPRS<TinyGsmSaraR5>;
   friend class TinyGsmTCP<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>;
@@ -275,8 +285,16 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    */
  public:
   RegStatus getRegistrationStatus() {
-    //use CREG instead of the CGREG AT command as it supports 2G/3G/4G instead of just 2G/3G connections  
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+    // Check first for EPS registration
+    RegStatus epsStatus = (RegStatus)getRegistrationStatusXREG("CEREG");
+
+    // If we're connected on EPS, great!
+    if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
+      return epsStatus;
+    } else {
+      // Otherwise, check generic network status
+      return (RegStatus)getRegistrationStatusXREG("CREG");
+    }
   }
 
   bool setRadioAccessTechnology(int selected, int preferred) {
@@ -297,16 +315,19 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     return true;
   }
 
-  bool getCurrentRadioAccessTechnology(int&) {
-    // @TODO
-    return false;
+  bool getCurrentRadioAccessTechnology(int& set) {
+    sendAT(GF("+URAT?"));
+    String response;
+    if (waitResponse(10000L, response) != 1) { return false; }
+
+    return true;
   }
 
  protected:
   bool isNetworkConnectedImpl() {
     RegStatus s = getRegistrationStatus();
-    Serial.printf("REGISTRATION STATUS: %i\n", (int)s);
-    if (s == REG_OK_HOME || s == REG_OK_ROAMING ||  s == REG_SMS_ONLY_ROAMING ||  s == REG_SMS_ONLY_HOME)
+    if (s == REG_OK_HOME || s == REG_OK_ROAMING || s == REG_SMS_ONLY_ROAMING ||
+        s == REG_SMS_ONLY_HOME)
       return true;
     else if (s == REG_UNKNOWN)  // for some reason, it can hang at unknown..
       return isGprsConnected();
@@ -330,7 +351,6 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
  protected:
   bool gprsConnectImpl(const char* apn, const char* user = NULL,
                        const char* pwd = NULL) {
-
     sendAT(GF("+CGATT=1"));  // attach to GPRS
     if (waitResponse(360000L) != 1) { return false; }
 
@@ -342,66 +362,74 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     // AT+UPSD=<profile_id>,<param_tag>,<param_val>
     // profile_id = 0 - PSD profile identifier, in range 0-6 (NOT PDP context)
     // param_tag = 1: APN
-    // param_tag = 2: username  -> not working for SARA-R5  
+    // param_tag = 2: username  -> not working for SARA-R5
     // param_tag = 3: password  -> not working for SARA-R5
     // param_tag = 7: IP address Note: IP address set as "0.0.0.0" means
     //    dynamic IP address assigned during PDP context activation
-    
+
 
     // check all available PDP context identifiers
     String response;
     response.reserve(1024);
     sendAT(GF("+CGDCONT?"));
-    //Serial.println(waitResponse(300, response, NULL));// overwrite GSM_OK as the stream most probably still has data which would cause ### Unhandled: ....
-    waitResponseUntilEndStream(1000, response);
-    Serial.println(response);
 
-    if (response.length() == 0){
-      return false;       // no apn at all found
+    waitResponseUntilEndStream(1000, response);
+
+    if (response.length() == 0) {
+      return false;  // no apn at all found
     }
-    // Serial.println("we got here 3");
     // parse string & look for apn -> modified from SparkFun u-blox SARA-R5 lib
     // Example:
     // +CGDCONT: 0,"IP","payandgo.o2.co.uk","0.0.0.0",0,0,0,0,0,0,0,0,0,0
-    // +CGDCONT: 1,"IP","payandgo.o2.co.uk.mnc010.mcc234.gprs","10.160.182.234",0,0,0,2,0,0,0,0,0,0
-    
-    //create search buffer where we can search
-    char *searchBuf = (char*)malloc(response.length()+1);
-    response.toCharArray(searchBuf, response.length()+1);
+    // +CGDCONT:
+    // 1,"IP","payandgo.o2.co.uk.mnc010.mcc234.gprs","10.160.182.234",0,0,0,2,0,0,0,0,0,0
 
-    int rcid = -1;
-    char *searchPtr = searchBuf;
+    // create search buffer where we can search
+    char* searchBuf = (char*)malloc(response.length() + 1);
+    response.toCharArray(searchBuf, response.length() + 1);
 
-    for(size_t index = 0; index<=response.length(); index++){
+    int   rcid      = -1;
+    char* searchPtr = searchBuf;
+
+    for (size_t index = 0; index <= response.length(); index++) {
       int scanned = 0;
       // Find the first/next occurrence of +CGDCONT:
       searchPtr = strstr(searchPtr, "+CGDCONT:");
-      if (searchPtr != nullptr){
+      if (searchPtr != nullptr) {
         char strPdpType[10];
         char strApn[128];
-        int ipOct[4];
+        int  ipOct[4];
 
         searchPtr += strlen("+CGDCONT:");
-        while (*searchPtr == ' ') searchPtr++; // skip spaces
-        scanned = sscanf(searchPtr, "%d,\"%[^\"]\",\"%[^\"]\",\"%d.%d.%d.%d", &rcid, strPdpType, strApn, &ipOct[0], &ipOct[1], &ipOct[2], &ipOct[3]);
-        
-        if (!strcmp(strApn, apn)){
+        while (*searchPtr == ' ') searchPtr++;  // skip spaces
+        scanned = sscanf(searchPtr, "%d,\"%[^\"]\",\"%[^\"]\",\"%d.%d.%d.%d",
+                         &rcid, strPdpType, strApn, &ipOct[0], &ipOct[1],
+                         &ipOct[2], &ipOct[3]);
+
+        if (!strcmp(strApn, apn)) {
           // found the configuration that we want to connect to
           break;
         }
       }
     }
 
-    sendAT(GF("+UPSDA=0,4")); // Deactivate the PDP context associated with profile 0
-    waitResponse(360000L);    // Can return an error if previously not activated
+    free(searchBuf);
 
-    sendAT(GF("+UPSD=0,100,")+String(rcid)); // Deactivate the PDP context associated with profile 0
+    sendAT(GF(
+        "+UPSDA=0,4"));  // Deactivate the PDP context associated with profile 0
+    waitResponse(360000L);  // Can return an error if previously not activated
+
+    sendAT(
+        GF("+UPSD=0,100,") +
+        String(rcid));  // Deactivate the PDP context associated with profile 0
     waitResponse();
 
-    sendAT(GF("+UPSDA=0,3")); // Activate the PDP context associated with profile 0
+    sendAT(GF(
+        "+UPSDA=0,3"));  // Activate the PDP context associated with profile 0
     if (waitResponse(360000L) != 1) { return false; }
 
-    sendAT(GF("+UPSD=0,0,2"));  // Set protocol type to IPv4v6 with IPv4 preferred for internal sockets
+    sendAT(GF("+UPSD=0,0,2"));  // Set protocol type to IPv4v6 with IPv4
+                                // preferred for internal sockets
     waitResponse();
 
     return true;
@@ -453,20 +481,6 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * I2C port, the GSM-based "Cell Locate" location will be returned instead.
    */
  protected:
-  bool enableGPSImpl() {
-    // AT+UGPS=<mode>[,<aid_mode>[,<GNSS_systems>]]
-    // <mode> - 0: GNSS receiver powered off, 1: on
-    // <aid_mode> - 0: no aiding (default)
-    // <GNSS_systems> - 3: GPS + SBAS (default)
-    sendAT(GF("+UGPS=1,0,3"));
-    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
-    return waitResponse(10000L) == 1;
-  }
-  bool disableGPSImpl() {
-    sendAT(GF("+UGPS=0"));
-    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
-    return waitResponse(10000L) == 1;
-  }
   String inline getUbloxLocationRaw(int8_t sensor) {
     // AT+ULOC=<mode>,<sensor>,<response_type>,<timeout>,<accuracy>
     // <mode> - 2: single shot position
@@ -482,6 +496,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     // <accuracy> - Target accuracy in meters (1 - 999999)
     sendAT(GF("+ULOC=2,"), sensor, GF(",0,120,1"));
     // wait for first "OK"
+    // waitResponse(10000L) ;
     if (waitResponse(10000L) != 1) { return ""; }
     // wait for the final result - wait full timeout time
     if (waitResponse(120000L, GF(GSM_NL "+UULOC:")) != 1) { return ""; }
@@ -490,6 +505,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     res.trim();
     return res;
   }
+
   String getGsmLocationRawImpl() {
     return getUbloxLocationRaw(2);
   }
@@ -497,6 +513,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     return getUbloxLocationRaw(1);
   }
 
+
   inline bool getUbloxLocation(int8_t sensor, float* lat, float* lon,
                                float* speed = 0, float* alt = 0, int* vsat = 0,
                                int* usat = 0, float* accuracy = 0,
@@ -512,10 +529,13 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     //          - 3: ?? use the combined GNSS receiver and CellLocate service
     //          information ?? - Docs show using sensor 3 and it's documented
     //          for the +UTIME command but not for +ULOC
-    // <response_type> - 0: standard (single-hypothesis) response
+    // <response_type> - 0: standard (single-hypothesis) response  -> +UULOC:
+    // <date>,<time>,<lat>,<long>,<alt>,<uncertainty>
+    //                   1: detailed (single-hypothesis) response  -> +UULOC:
+    //                   <date>,<time>,<lat>,<long>,<alt>,<uncertainty>,<speed>,<direction>,<vertical_acc>,<sensor_used>,<SV_used>,<antenna_status>,<jamming_status>
     // <timeout> - Timeout period in seconds
     // <accuracy> - Target accuracy in meters (1 - 999999)
-    sendAT(GF("+ULOC=2,"), sensor, GF(",0,120,1"));
+    sendAT(GF("+ULOC=2,"), sensor, GF(",1,120,1"));
     // wait for first "OK"
     if (waitResponse(10000L) != 1) { return false; }
     // wait for the final result - wait full timeout time
@@ -587,6 +607,8 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     waitResponse();
     return true;
   }
+
+
   bool getGsmLocationImpl(float* lat, float* lon, float* accuracy = 0,
                           int* year = 0, int* month = 0, int* day = 0,
                           int* hour = 0, int* minute = 0, int* second = 0) {
@@ -784,7 +806,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
       while (stream.available() > 0) {
         TINY_GSM_YIELD();
         int8_t a = stream.read();
-        
+
         if (a <= 0) continue;  // Skip 0x00 bytes, just in case
         data += static_cast<char>(a);
         if (r1 && data.endsWith(r1)) {
@@ -863,10 +885,11 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     return waitResponse(1000, r1, r2, r3, r4, r5);
   }
 
-private:  // basically the same as waitResponse but without preemptive exiting (except when time runs out)
-          // this is required for +CGDCONT? as it can return multiple cid/apn configurations each terminated with OK\r\n
+ private:  // basically the same as waitResponse but without preemptive exiting
+           // (except when time runs out) this is used for +CGDCONT? as it can
+           // return multiple cid/apn configurations each terminated with OK\r\n
   int8_t waitResponseUntilEndStream(uint32_t timeout_ms, String& data) {
-    data.reserve(1024); // buffer of the same size as in the SparkFun lib
+    data.reserve(1024);  // buffer of the same size as in the SparkFun lib
     uint8_t  index       = 0;
     uint32_t startMillis = millis();
     do {
@@ -874,7 +897,7 @@ private:  // basically the same as waitResponse but without preemptive exiting (
       while (stream.available() > 0) {
         TINY_GSM_YIELD();
         int8_t a = stream.read();
-        
+
         if (a <= 0) continue;  // Skip 0x00 bytes, just in case
         data += static_cast<char>(a);
       }
@@ -887,7 +910,8 @@ private:  // basically the same as waitResponse but without preemptive exiting (
 
  protected:
   GsmClientSaraR5* sockets[TINY_GSM_MUX_COUNT];
-  const char*     gsmNL = GSM_NL;
+  const char*      gsmNL = GSM_NL;
 };
 
+
 #endif  // SRC_TINYGSMCLIENTSARAR5_H_
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 8d3a8cb..b9060ac 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -510,9 +510,10 @@ class TinyGsmSequansMonarch
     waitResponse(10000L, GF(GSM_NL "> "));
     // Translate bytes into char to be able to send them as an hex string
     char char_command[2];
-    for (size_t i=0; i<len; i++) {
+    for (size_t i = 0; i < len; i++) {
       memset(&char_command, 0, sizeof(char_command));
-      sprintf(&char_command[0], "%02X", reinterpret_cast<const uint8_t*>(buff)[i]);
+      sprintf(&char_command[0], "%02X",
+              reinterpret_cast<const uint8_t*>(buff)[i]);
       stream.write(char_command, sizeof(char_command));
     }
     stream.flush();
@@ -727,7 +728,7 @@ class TinyGsmSequansMonarch
  protected:
   GsmClientSequansMonarch* sockets[TINY_GSM_MUX_COUNT];
   // GSM_NL (\r\n) is not accepted with SQNSSENDEXT in data mode so use \n
-  const char*              gsmNL = "\n";
+  const char* gsmNL = "\n";
 };
 
 #endif  // SRC_TINYGSMCLIENTSEQUANSMONARCH_H_
diff --git a/src/TinyGsmFifo.h b/src/TinyGsmFifo.h
index 0a4028d..31877bc 100644
--- a/src/TinyGsmFifo.h
+++ b/src/TinyGsmFifo.h
@@ -2,140 +2,123 @@
 #define TinyGsmFifo_h
 
 template <class T, unsigned N>
-class TinyGsmFifo
-{
-public:
-    TinyGsmFifo()
-    {
-        clear();
+class TinyGsmFifo {
+ public:
+  TinyGsmFifo() {
+    clear();
+  }
+
+  void clear() {
+    _r = 0;
+    _w = 0;
+  }
+
+  // writing thread/context API
+  //-------------------------------------------------------------
+
+  bool writeable(void) {
+    return free() > 0;
+  }
+
+  int free(void) {
+    int s = _r - _w;
+    if (s <= 0) s += N;
+    return s - 1;
+  }
+
+  bool put(const T& c) {
+    int i = _w;
+    int j = i;
+    i     = _inc(i);
+    if (i == _r)  // !writeable()
+      return false;
+    _b[j] = c;
+    _w    = i;
+    return true;
+  }
+
+  int put(const T* p, int n, bool t = false) {
+    int c = n;
+    while (c) {
+      int f;
+      while ((f = free()) == 0)  // wait for space
+      {
+        if (!t) return n - c;  // no more space and not blocking
+        /* nothing / just wait */;
+      }
+      // check free space
+      if (c < f) f = c;
+      int w = _w;
+      int m = N - w;
+      // check wrap
+      if (f > m) f = m;
+      memcpy(&_b[w], p, f);
+      _w = _inc(w, f);
+      c -= f;
+      p += f;
     }
+    return n - c;
+  }
 
-    void clear()
-    {
-        _r = 0;
-        _w = 0;
+  // reading thread/context API
+  // --------------------------------------------------------
+
+  bool readable(void) {
+    return (_r != _w);
+  }
+
+  size_t size(void) {
+    int s = _w - _r;
+    if (s < 0) s += N;
+    return s;
+  }
+
+  bool get(T* p) {
+    int r = _r;
+    if (r == _w)  // !readable()
+      return false;
+    *p = _b[r];
+    _r = _inc(r);
+    return true;
+  }
+
+  int get(T* p, int n, bool t = false) {
+    int c = n;
+    while (c) {
+      int f;
+      for (;;)  // wait for data
+      {
+        f = size();
+        if (f) break;          // free space
+        if (!t) return n - c;  // no space and not blocking
+        /* nothing / just wait */;
+      }
+      // check available data
+      if (c < f) f = c;
+      int r = _r;
+      int m = N - r;
+      // check wrap
+      if (f > m) f = m;
+      memcpy(p, &_b[r], f);
+      _r = _inc(r, f);
+      c -= f;
+      p += f;
     }
+    return n - c;
+  }
 
-    // writing thread/context API
-    //-------------------------------------------------------------
+  uint8_t peek() {
+    return _b[_r];
+  }
 
-    bool writeable(void)
-    {
-        return free() > 0;
-    }
+ private:
+  int _inc(int i, int n = 1) {
+    return (i + n) % N;
+  }
 
-    int free(void)
-    {
-        int s = _r - _w;
-        if (s <= 0)
-            s += N;
-        return s - 1;
-    }
-
-    bool put(const T& c)
-    {
-        int i = _w;
-        int j = i;
-        i = _inc(i);
-        if (i == _r) // !writeable()
-            return false;
-        _b[j] = c;
-        _w = i;
-        return true;
-    }
-
-    int put(const T* p, int n, bool t = false)
-    {
-        int c = n;
-        while (c)
-        {
-            int f;
-            while ((f = free()) == 0) // wait for space
-            {
-                if (!t) return n - c; // no more space and not blocking
-                /* nothing / just wait */;
-            }
-            // check free space
-            if (c < f) f = c;
-            int w = _w;
-            int m = N - w;
-            // check wrap
-            if (f > m) f = m;
-            memcpy(&_b[w], p, f);
-            _w = _inc(w, f);
-            c -= f;
-            p += f;
-        }
-        return n - c;
-    }
-
-    // reading thread/context API
-    // --------------------------------------------------------
-
-    bool readable(void)
-    {
-        return (_r != _w);
-    }
-
-    size_t size(void)
-    {
-        int s = _w - _r;
-        if (s < 0)
-            s += N;
-        return s;
-    }
-
-    bool get(T* p)
-    {
-        int r = _r;
-        if (r == _w) // !readable()
-            return false;
-        *p = _b[r];
-        _r = _inc(r);
-        return true;
-    }
-
-    int get(T* p, int n, bool t = false)
-    {
-        int c = n;
-        while (c)
-        {
-            int f;
-            for (;;) // wait for data
-            {
-                f = size();
-                if (f)  break;        // free space
-                if (!t) return n - c; // no space and not blocking
-                /* nothing / just wait */;
-            }
-            // check available data
-            if (c < f) f = c;
-            int r = _r;
-            int m = N - r;
-            // check wrap
-            if (f > m) f = m;
-            memcpy(p, &_b[r], f);
-            _r = _inc(r, f);
-            c -= f;
-            p += f;
-        }
-        return n - c;
-    }
-
-	uint8_t peek()
-	{
-		return _b[_r];
-	}
-
-private:
-    int _inc(int i, int n = 1)
-    {
-        return (i + n) % N;
-    }
-
-    T    _b[N];
-    int  _w;
-    int  _r;
+  T   _b[N];
+  int _w;
+  int _r;
 };
 
 #endif
diff --git a/src/TinyGsmSMS.tpp b/src/TinyGsmSMS.tpp
index fb74949..3b0b6de 100644
--- a/src/TinyGsmSMS.tpp
+++ b/src/TinyGsmSMS.tpp
@@ -173,11 +173,11 @@ class TinyGsmSMS {
     Print&  p;
     uint8_t prv = 0;
     void    printHex(const uint16_t v) {
-      uint8_t c = v >> 8;
-      if (c < 0x10) p.print('0');
+         uint8_t c = v >> 8;
+         if (c < 0x10) p.print('0');
       p.print(c, HEX);
-      c = v & 0xFF;
-      if (c < 0x10) p.print('0');
+         c = v & 0xFF;
+         if (c < 0x10) p.print('0');
       p.print(c, HEX);
     }
   };
diff --git a/src/TinyGsmTCP.tpp b/src/TinyGsmTCP.tpp
index 391d1fe..0459c27 100644
--- a/src/TinyGsmTCP.tpp
+++ b/src/TinyGsmTCP.tpp
@@ -241,9 +241,9 @@ class TinyGsmTCP {
       return -1;
     }
 
-	int peek() override {
-		return (uint8_t)rx.peek();
-	}
+    int peek() override {
+      return (uint8_t)rx.peek();
+    }
 
     void flush() override {
       at->stream.flush();

From 7979e7d410d1dd79f661d7fd42f066dcc116f24b Mon Sep 17 00:00:00 2001
From: Sebastian Bergner <sebastianbergner5892@gmail.com>
Date: Thu, 31 Aug 2023 11:09:13 +0200
Subject: [PATCH 028/100] add SARA R5 to the examples

---
 examples/AllFunctions/AllFunctions.ino | 9 ++++++---
 examples/BlynkClient/BlynkClient.ino   | 6 +-----
 examples/FileDownload/FileDownload.ino | 1 +
 examples/HttpClient/HttpClient.ino     | 1 +
 examples/MqttClient/MqttClient.ino     | 1 +
 examples/WebClient/WebClient.ino       | 1 +
 6 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index b3e6ff6..2941710 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -10,7 +10,7 @@
  **************************************************************/
 
 // Select your modem:
-#define TINY_GSM_MODEM_SIM800
+// #define TINY_GSM_MODEM_SIM800
 // #define TINY_GSM_MODEM_SIM808
 // #define TINY_GSM_MODEM_SIM868
 // #define TINY_GSM_MODEM_SIM900
@@ -20,7 +20,8 @@
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
 // #define TINY_GSM_MODEM_UBLOX
-// #define TINY_GSM_MODEM_SARAR4
+#define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
@@ -77,7 +78,7 @@ SoftwareSerial SerialAT(2, 3);  // RX, TX
 #define TINY_GSM_TEST_GSM_LOCATION false
 #define TINY_GSM_TEST_NTP false
 #define TINY_GSM_TEST_TIME false
-#define TINY_GSM_TEST_GPS false
+#define TINY_GSM_TEST_GPS true
 // disconnect and power down modem after tests
 #define TINY_GSM_POWERDOWN false
 
@@ -374,7 +375,9 @@ void loop() {
 
 #if TINY_GSM_TEST_GPS && defined TINY_GSM_MODEM_HAS_GPS
   DBG("Enabling GPS/GNSS/GLONASS and waiting 15s for warm-up");
+  #if !defined(TINY_GSM_MODEM_SARAR5)
   modem.enableGPS();
+  #endif
   delay(15000L);
   float lat2      = 0;
   float lon2      = 0;
diff --git a/examples/BlynkClient/BlynkClient.ino b/examples/BlynkClient/BlynkClient.ino
index 2ab7f3d..d79d14a 100644
--- a/examples/BlynkClient/BlynkClient.ino
+++ b/examples/BlynkClient/BlynkClient.ino
@@ -22,11 +22,6 @@
  * Change GPRS apm, user, pass, and Blynk auth token to run :)
  **************************************************************/
 
-/* Fill in information from Blynk Device Info here */
-#define BLYNK_TEMPLATE_ID           "TMPxxxxxx"
-#define BLYNK_TEMPLATE_NAME         "Device"
-#define BLYNK_AUTH_TOKEN            "YourAuthToken"
-
 #define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
 
 // Default heartbeat interval for GSM is 60
@@ -45,6 +40,7 @@
 // #define TINY_GSM_MODEM_SIM7600
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
diff --git a/examples/FileDownload/FileDownload.ino b/examples/FileDownload/FileDownload.ino
index d66e4b7..d41a528 100644
--- a/examples/FileDownload/FileDownload.ino
+++ b/examples/FileDownload/FileDownload.ino
@@ -25,6 +25,7 @@
 // #define TINY_GSM_MODEM_SIM7600
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
diff --git a/examples/HttpClient/HttpClient.ino b/examples/HttpClient/HttpClient.ino
index 3e4659b..d6243fe 100644
--- a/examples/HttpClient/HttpClient.ino
+++ b/examples/HttpClient/HttpClient.ino
@@ -30,6 +30,7 @@
 // #define TINY_GSM_MODEM_SIM7600
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
diff --git a/examples/MqttClient/MqttClient.ino b/examples/MqttClient/MqttClient.ino
index 77a8500..05b6993 100644
--- a/examples/MqttClient/MqttClient.ino
+++ b/examples/MqttClient/MqttClient.ino
@@ -34,6 +34,7 @@
 // #define TINY_GSM_MODEM_SIM7600
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
diff --git a/examples/WebClient/WebClient.ino b/examples/WebClient/WebClient.ino
index 74ffa0a..67bd3a1 100644
--- a/examples/WebClient/WebClient.ino
+++ b/examples/WebClient/WebClient.ino
@@ -20,6 +20,7 @@
 // #define TINY_GSM_MODEM_SIM7600
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6

From 662c45353250c7acddddd864a1d4922fe8fd10e8 Mon Sep 17 00:00:00 2001
From: Sebastian Bergner <54766531+sebastianbergner@users.noreply.github.com>
Date: Thu, 31 Aug 2023 11:30:56 +0200
Subject: [PATCH 029/100] Update README.md SARA R5

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 890a6d9..96beeb6 100644
--- a/README.md
+++ b/README.md
@@ -75,7 +75,7 @@ TinyGSM also pulls data gently from the modem (whenever possible), so it can ope
 - Digi XBee WiFi and Cellular (using XBee command mode)
 - Neoway M590
 - u-blox 2G, 3G, 4G, and LTE Cat1 Cellular Modems (many modules including LEON-G100, LISA-U2xx, SARA-G3xx, SARA-U2xx, TOBY-L2xx, LARA-R2xx, MPCI-L2xx)
-- u-blox LTE-M/NB-IoT Modems (SARA-R4xx, SARA-N4xx, _but NOT SARA-N2xx_)
+- u-blox LTE-M/NB-IoT Modems (SARA-R4xx, SARA-N4xx, SARA-R5xx, _but NOT SARA-N2xx_)
 - Sequans Monarch LTE Cat M1/NB1 (VZM20Q)
 - Quectel BG96
 - Quectel M95
@@ -151,7 +151,7 @@ Watch this repo for new updates! And of course, contributions are welcome ;)
 - Not yet supported on:
     - SIM7000, SIM5360/5320/7100, SIM7500/7800, VZM20Q (Monarch)
 - Not possible on:
-    -  XBee (any type), u-blox SARA R4/N4, Neoway M590, ESP8266 (obviously)
+    -  XBee (any type), u-blox SARA R4/R5/N4, Neoway M590, ESP8266 (obviously)
 - Functions:
     - Dial, hangup
     - DTMF sending

From bcc8fd4731f748ec04e1777201b404732e11053b Mon Sep 17 00:00:00 2001
From: Sebastian Bergner <sebastianbergner5892@gmail.com>
Date: Thu, 31 Aug 2023 11:43:43 +0200
Subject: [PATCH 030/100] revert accidental change to Blynk example due to
 clang-format and revert changes on AllFunctions example

---
 examples/AllFunctions/AllFunctions.ino | 6 +++---
 examples/BlynkClient/BlynkClient.ino   | 4 ++++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index 2941710..4ff0a9b 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -10,7 +10,7 @@
  **************************************************************/
 
 // Select your modem:
-// #define TINY_GSM_MODEM_SIM800
+#define TINY_GSM_MODEM_SIM800
 // #define TINY_GSM_MODEM_SIM808
 // #define TINY_GSM_MODEM_SIM868
 // #define TINY_GSM_MODEM_SIM900
@@ -20,7 +20,7 @@
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
 // #define TINY_GSM_MODEM_UBLOX
-#define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
 // #define TINY_GSM_MODEM_BG96
@@ -78,7 +78,7 @@ SoftwareSerial SerialAT(2, 3);  // RX, TX
 #define TINY_GSM_TEST_GSM_LOCATION false
 #define TINY_GSM_TEST_NTP false
 #define TINY_GSM_TEST_TIME false
-#define TINY_GSM_TEST_GPS true
+#define TINY_GSM_TEST_GPS false
 // disconnect and power down modem after tests
 #define TINY_GSM_POWERDOWN false
 
diff --git a/examples/BlynkClient/BlynkClient.ino b/examples/BlynkClient/BlynkClient.ino
index d79d14a..9dcb319 100644
--- a/examples/BlynkClient/BlynkClient.ino
+++ b/examples/BlynkClient/BlynkClient.ino
@@ -22,6 +22,10 @@
  * Change GPRS apm, user, pass, and Blynk auth token to run :)
  **************************************************************/
 
+#define BLYNK_TEMPLATE_ID           "TMPxxxxxx"
+#define BLYNK_TEMPLATE_NAME         "Device"
+#define BLYNK_AUTH_TOKEN            "YourAuthToken"
+
 #define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
 
 // Default heartbeat interval for GSM is 60

From d4dea90f1f3e09bc2e1a1d1ad193828243ac5a83 Mon Sep 17 00:00:00 2001
From: Mikael Fredriksson <Gelemikke@users.noreply.github.com>
Date: Fri, 1 Sep 2023 11:07:56 +0200
Subject: [PATCH 031/100] Update TinyGsmClientSIM7000.h

Add support for "SEND FAIL" response from SIM7000 modem
---
 src/TinyGsmClientSIM7000.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index e708845..61e19a5 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -306,7 +306,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
 
-    if (waitResponse(GF(GSM_NL "DATA ACCEPT:")) != 1) { return 0; }
+    if (waitResponse(GF(GSM_NL "DATA ACCEPT:"),GF("SEND FAIL")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     return streamGetIntBefore('\n');
   }

From c6a0e6531129a86414855faca6f02045a4fe3e8c Mon Sep 17 00:00:00 2001
From: Aurelien BOUIN <aurelien.bouin@captina.dev>
Date: Sat, 23 Sep 2023 09:09:29 +0200
Subject: [PATCH 032/100] Add support for Quectel BG96 (SSL/TLS/HTTPS/GPS/GNSS)

---
 .github/ISSUE_TEMPLATE.md     |    2 +-
 README.md                     |    8 +-
 library.json                  |    4 +-
 library.properties            |    2 +-
 src/TinyGsmClient.h           |    6 +
 src/TinyGsmClientSecureBG95.h | 1177 +++++++++++++++++++++++++++++++++
 src/TinyGsmCommon.h           |    2 +-
 src/TinyGsmTime.tpp           |    5 +
 8 files changed, 1198 insertions(+), 8 deletions(-)
 create mode 100644 src/TinyGsmClientSecureBG95.h

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index 6f620d6..f98ab0f 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -25,7 +25,7 @@ with your board before submitting any issues.
 
 Modem: <!-- Brand, model, variant, firmware version, ie Quectel BG96 Revision: BG96MAR02A07M1G -->
 Main processor board: <!-- Uno, Zero, ESP32, Particle, etc -->
-TinyGSM version: <!-- always try to use the latest (0.11.7) -->
+TinyGSM version: <!-- always try to use the latest (0.11.8) -->
 Code: <!-- Example name or paste in your code -->
 
 ### Scenario, steps to reproduce
diff --git a/README.md b/README.md
index 890a6d9..59f07e3 100644
--- a/README.md
+++ b/README.md
@@ -78,6 +78,7 @@ TinyGSM also pulls data gently from the modem (whenever possible), so it can ope
 - u-blox LTE-M/NB-IoT Modems (SARA-R4xx, SARA-N4xx, _but NOT SARA-N2xx_)
 - Sequans Monarch LTE Cat M1/NB1 (VZM20Q)
 - Quectel BG96
+- Quectel BG95
 - Quectel M95
 - Quectel MC60 ***(alpha)***
 
@@ -110,6 +111,7 @@ Watch this repo for new updates! And of course, contributions are welcome ;)
         - ESP8266 - 5
         - Neoway M590 - 2
         - Quectel BG96 - 12
+        - Quectel BG95 - 12
         - Quectel M95 - 6
         - Quectel MC60/MC60E - 6
         - Sequans Monarch - 6
@@ -125,10 +127,10 @@ Watch this repo for new updates! And of course, contributions are welcome ;)
     - Not yet supported on any module, though it may be some day
 - SSL/TLS (HTTPS)
     - Supported on:
-        - SIM800, SIM7000, u-Blox, XBee _cellular_, ESP8266, and Sequans Monarch
+        - SIM800, SIM7000, u-Blox, XBee _cellular_, ESP8266, Sequans Monarch and Quectel BG95
         - Note:  **only some device models or firmware revisions have this feature** (SIM8xx R14.18, A7, etc.)
     - Not yet supported on:
-        - Quectel modems, SIM 5360/5320/7100, SIM 7500/7600/7800
+        - Quectel BG96, SIM 5360/5320/7100, SIM 7500/7600/7800
     - Not possible on:
         - SIM900, A6/A7, Neoway M590, XBee _WiFi_
     - Like TCP, most modules support simultaneous connections
@@ -158,7 +160,7 @@ Watch this repo for new updates! And of course, contributions are welcome ;)
 
 **Location**
 - GPS/GNSS
-    - SIM808, SIM7000, SIM7500/7600/7800, BG96, u-blox
+    - SIM808, SIM7000, SIM7500/7600/7800, BG96, BG95, u-blox
     - NOTE:  u-blox chips do _NOT_ have embedded GPS - this functionality only works if a secondary GPS is connected to primary cellular chip over I2C
 - GSM location service
     - SIM800, SIM7000, Quectel, u-blox
diff --git a/library.json b/library.json
index a4d1827..7df379d 100644
--- a/library.json
+++ b/library.json
@@ -1,8 +1,8 @@
 {
   "name": "TinyGSM",
-  "version": "0.11.7",
+  "version": "0.11.8",
   "description": "A small Arduino library for GPRS modules, that just works. Includes examples for Blynk, MQTT, File Download, and Web Client. Supports many GSM, LTE, and WiFi modules with AT command interfaces.",
-  "keywords": "GSM, AT commands, AT, SIM800, SIM900, A6, A7, M590, ESP8266, SIM7000, SIM800A, SIM800C, SIM800L, SIM800H, SIM808, SIM868, SIM900A, SIM900D, SIM908, SIM968, M95, MC60, MC60E, BG96, ublox, Quectel, SIMCOM, AI Thinker, LTE, LTE-M",
+  "keywords": "GSM, AT commands, AT, SIM800, SIM900, A6, A7, M590, ESP8266, SIM7000, SIM800A, SIM800C, SIM800L, SIM800H, SIM808, SIM868, SIM900A, SIM900D, SIM908, SIM968, M95, MC60, MC60E, BG96, BG95, ublox, Quectel, SIMCOM, AI Thinker, LTE, LTE-M",
   "authors": [
     {
       "name": "Volodymyr Shymanskyy",
diff --git a/library.properties b/library.properties
index 5df8580..6b1ae5e 100644
--- a/library.properties
+++ b/library.properties
@@ -1,5 +1,5 @@
 name=TinyGSM
-version=0.11.7
+version=0.11.8
 author=Volodymyr Shymanskyy
 maintainer=Volodymyr Shymanskyy
 sentence=A small Arduino library for GPRS modules, that just works.
diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index a8ae763..0c3c754 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -77,6 +77,12 @@ typedef TinyGsmM95::GsmClientM95 TinyGsmClient;
 #include "TinyGsmClientBG96.h"
 typedef TinyGsmBG96                TinyGsm;
 typedef TinyGsmBG96::GsmClientBG96 TinyGsmClient;
+typedef TinyGsmBG96::GsmClientSecureBG96 TinyGsmClientSecure;
+
+#elif defined(TINY_GSM_MODEM_SECURE_BG95)
+#include "TinyGsmClientSecureBG95.h"
+typedef TinyGsmBG95                TinyGsm;
+typedef TinyGsmBG95::GsmClientSecureBG95 TinyGsmClientSecure;
 
 #elif defined(TINY_GSM_MODEM_A6) || defined(TINY_GSM_MODEM_A7)
 #include "TinyGsmClientA6.h"
diff --git a/src/TinyGsmClientSecureBG95.h b/src/TinyGsmClientSecureBG95.h
new file mode 100644
index 0000000..fd36139
--- /dev/null
+++ b/src/TinyGsmClientSecureBG95.h
@@ -0,0 +1,1177 @@
+/**
+ * @file       TinyGsmClientBG95.h
+ * @author     Aurelien BOUIN
+ * @license    LGPL-3.0
+ * @copyright  Copyright (c) 2023 Aurelien BOUIN
+ * @date       Aug 2023
+ */
+
+#ifndef SRC_TINYGSMCLIENTBG95_H_
+#define SRC_TINYGSMCLIENTBG95_H_
+// #pragma message("TinyGSM:  TinyGsmClientBG95")
+
+// #define TINY_GSM_DEBUG Serial
+
+#define TINY_GSM_MUX_COUNT 12
+#define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmGPS.tpp"
+#include "TinyGsmModem.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmTCP.tpp"
+#include "TinyGsmTemperature.tpp"
+#include "TinyGsmTime.tpp"
+#include "TinyGsmNTP.tpp"
+
+#define GSM_NL "\r\n"
+static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
+static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
+#if defined       TINY_GSM_DEBUG
+static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
+static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
+#endif
+
+enum RegStatus {
+  REG_NO_RESULT    = -1,
+  REG_UNREGISTERED = 0,
+  REG_SEARCHING    = 2,
+  REG_DENIED       = 3,
+  REG_OK_HOME      = 1,
+  REG_OK_ROAMING   = 5,
+  REG_UNKNOWN      = 4,
+};
+
+class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
+                    public TinyGsmGPRS<TinyGsmBG95>,
+                    public TinyGsmTCP<TinyGsmBG95, TINY_GSM_MUX_COUNT>,
+                    public TinyGsmCalling<TinyGsmBG95>,
+                    public TinyGsmSMS<TinyGsmBG95>,
+                    public TinyGsmTime<TinyGsmBG95>,
+                    public TinyGsmNTP<TinyGsmBG95>,
+                    public TinyGsmGPS<TinyGsmBG95>,
+                    public TinyGsmBattery<TinyGsmBG95>,
+                    public TinyGsmTemperature<TinyGsmBG95> {
+  friend class TinyGsmModem<TinyGsmBG95>;
+  friend class TinyGsmGPRS<TinyGsmBG95>;
+  friend class TinyGsmTCP<TinyGsmBG95, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmCalling<TinyGsmBG95>;
+  friend class TinyGsmSMS<TinyGsmBG95>;
+  friend class TinyGsmTime<TinyGsmBG95>;
+  friend class TinyGsmNTP<TinyGsmBG95>;
+  friend class TinyGsmGPS<TinyGsmBG95>;
+  friend class TinyGsmBattery<TinyGsmBG95>;
+  friend class TinyGsmTemperature<TinyGsmBG95>;
+
+  /*
+   * Inner Client
+   */
+ public:
+  class GsmClientBG95 : public GsmClient {
+    friend class TinyGsmBG95;
+
+   public:
+    GsmClientBG95() {}
+
+    explicit GsmClientBG95(TinyGsmBG95& modem, uint8_t mux = 0) {
+      init(&modem, mux);
+    }
+
+    bool init(TinyGsmBG95* modem, uint8_t mux = 0) {
+      this->at       = modem;
+      sock_available = 0;
+      prev_check     = 0;
+      sock_connected = false;
+      got_data       = false;
+
+      if (mux < TINY_GSM_MUX_COUNT) {
+        this->mux = mux;
+      } else {
+        this->mux = (mux % TINY_GSM_MUX_COUNT);
+      }
+      at->sockets[this->mux] = this;
+
+      return true;
+    }
+
+   public:
+    virtual int connect(const char* host, uint16_t port, int timeout_s) {
+      stop();
+      TINY_GSM_YIELD();
+      rx.clear();
+      sock_connected = at->modemConnect(host, port, mux, false, timeout_s);
+      return sock_connected;
+    }
+    TINY_GSM_CLIENT_CONNECT_OVERRIDES
+
+    void stop(uint32_t maxWaitMs) {
+      uint32_t startMillis = millis();
+      dumpModemBuffer(maxWaitMs);
+      at->sendAT(GF("+QSSLCLOSE="), mux);
+      sock_connected = false;
+      at->waitResponse((maxWaitMs - (millis() - startMillis)));
+    }
+    void stop() override {
+      stop(15000L);
+    }
+
+    /*
+     * Extended API
+     */
+
+    String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  };
+
+  /*
+   * Inner Secure Client
+   */
+
+  class GsmClientSecureBG95 : public GsmClientBG95
+  {
+  public:
+    GsmClientSecureBG95() {}
+
+    GsmClientSecureBG95(TinyGsmBG95& modem, uint8_t mux = 0)
+     : GsmClientBG95(modem, mux)
+    {}
+
+
+  public:
+    int connect(const char* host, uint16_t port, int timeout_s) override {
+      stop();
+      TINY_GSM_YIELD();
+      rx.clear();
+      sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
+      return sock_connected;
+    }
+    TINY_GSM_CLIENT_CONNECT_OVERRIDES
+  };
+
+  /*
+   * Constructor
+   */
+ public:
+  explicit TinyGsmBG95(Stream& stream) : stream(stream) {
+    memset(sockets, 0, sizeof(sockets));
+  }
+
+  /*
+   * Basic functions
+   */
+ protected:
+  bool initImpl(const char* pin = NULL) {
+    DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
+    DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientBG95"));
+
+    if (!testAT()) { return false; }
+
+    sendAT(GF("E0"));  // Echo Off
+    if (waitResponse() != 1) { return false; }
+
+#ifdef TINY_GSM_DEBUG
+    sendAT(GF("+CMEE=2"));  // turn on verbose error codes
+#else
+    sendAT(GF("+CMEE=0"));  // turn off error codes
+#endif
+    waitResponse();
+
+    DBG(GF("### Modem:"), getModemName());
+
+    // Disable time and time zone URC's
+    sendAT(GF("+CTZR=0"));
+    if (waitResponse(10000L) != 1) { return false; }
+
+    // Enable automatic time zone update
+    sendAT(GF("+CTZU=1"));
+    if (waitResponse(10000L) != 1) { return false; }
+#if 1
+    SimStatus ret = getSimStatus();
+    // if the sim isn't ready and a pin has been provided, try to unlock the sim
+    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+      simUnlock(pin);
+      return (getSimStatus() == SIM_READY);
+    } else {
+      // if the sim is ready, or it's locked but no pin has been provided,
+      // return true
+      return (ret == SIM_READY || ret == SIM_LOCKED);
+    }
+#endif
+  }
+  /*
+   * Power functions
+   */
+ protected:
+  bool restartImpl(const char* pin = NULL) {
+    if (!testAT()) { return false; }
+    if (!setPhoneFunctionality(1, true)) { return false; }
+    waitResponse(10000L, GF("APP RDY"));
+    return init(pin);
+  }
+
+  bool powerOffImpl() {
+    sendAT(GF("+QPOWD=1"));
+    waitResponse(300);  // returns OK first
+    return waitResponse(300, GF("POWERED DOWN")) == 1;
+  }
+
+  // When entering into sleep mode is enabled, DTR is pulled up, and WAKEUP_IN
+  // is pulled up, the module can directly enter into sleep mode.If entering
+  // into sleep mode is enabled, DTR is pulled down, and WAKEUP_IN is pulled
+  // down, there is a need to pull the DTR pin and the WAKEUP_IN pin up first,
+  // and then the module can enter into sleep mode.
+  bool sleepEnableImpl(bool enable = true) {
+    sendAT(GF("+QSCLK="), enable);
+    return waitResponse() == 1;
+  }
+
+  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false, uint32_t timeout_ms = 15500L) {
+    sendAT(GF("+CFUN="), fun, reset ? ",1" : "");
+    return waitResponse(timeout_ms, GF("OK")) == 1;
+  }
+
+  /*
+   * Generic network functions
+   */
+ public:
+  RegStatus getRegistrationStatus() {
+    // Check first for EPS registration
+    RegStatus epsStatus = (RegStatus)getRegistrationStatusXREG("CEREG");
+
+    //if REG_UNKNOWN
+
+    // If we're connected on EPS, great!
+    if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
+      return epsStatus;
+    } else {
+      // Otherwise, check generic network status
+      return (RegStatus)getRegistrationStatusXREG("CREG");
+    }
+  }
+
+ protected:
+  bool isNetworkConnectedImpl() {
+    RegStatus s = getRegistrationStatus();
+    return (s == REG_OK_HOME || s == REG_OK_ROAMING);
+  }
+
+  /*
+   * GPRS functions
+   */
+ protected:
+  bool gprsConnectImpl(const char* apn, const char* user = NULL,
+                       const char* pwd = NULL) {
+    gprsDisconnect();
+
+    // Configure the TCPIP Context
+    sendAT(GF("+QICSGP=1,1,\""), apn, GF("\",\""), user, GF("\",\""), pwd,
+           GF("\""));
+    if (waitResponse() != 1) { return false; }
+
+    // Activate GPRS/CSD Context
+    sendAT(GF("+QIACT=1"));
+    if (waitResponse(150000L) != 1) { return false; }
+
+    // Attach to Packet Domain service - is this necessary?
+    sendAT(GF("+CGATT=1"));
+    if (waitResponse(60000L) != 1) { return false; }
+
+    return true;
+  }
+
+  bool gprsDisconnectImpl() {
+    sendAT(GF("+QIDEACT=1"));  // Deactivate the bearer context
+    if (waitResponse(40000L) != 1) { return false; }
+
+    return true;
+  }
+
+  /*
+   * SIM card functions
+   */
+ protected:
+  String getSimCCIDImpl() {
+    sendAT(GF("+QCCID"));
+    if (waitResponse(GF(GSM_NL "+QCCID:")) != 1) { return ""; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.trim();
+    return res;
+  }
+
+  /*
+   * Phone Call functions
+   */
+ protected:
+  // Can follow all of the phone call functions from the template
+
+  /*
+   * Messaging functions
+   */
+ protected:
+  // Follows all messaging functions per template
+
+  /*
+   * GSM Location functions
+   */
+ protected:
+  // NOTE:  As of application firmware version 01.016.01.016 triangulated
+  // locations can be obtained via the QuecLocator service and accompanying AT
+  // commands.  As this is a separate paid service which I do not have access
+  // to, I am not implementing it here.
+
+
+
+  /*
+   * Testing functions
+   */
+
+ public:
+  String getModemManufacturerIdentification(){
+    sendAT(GF("+GMI"));
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    res.replace(GSM_NL "OK" GSM_NL, "");
+    res.replace(GSM_NL, " ");
+    res.trim();
+    return res;
+  }
+  String getModemModelIdentification(){
+    sendAT(GF("+GMM"));
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    res.replace(GSM_NL "OK" GSM_NL, "");
+    res.replace(GSM_NL, " ");
+    res.trim();
+    return res;
+  }
+  String getModemFirmwareVersionIdentification(){
+    sendAT(GF("+GMR"));
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    res.replace(GSM_NL "OK" GSM_NL, "");
+    res.replace(GSM_NL, " ");
+    res.trim();
+    return res;
+  }
+  String getModemFirmwareFullVersionIdentification(){
+    sendAT(GF("+QGMR"));
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    res.replace(GSM_NL "OK" GSM_NL, "");
+    res.replace(GSM_NL, " ");
+    res.trim();
+    return res;
+  }
+  String getModemFirmwareApplicationVersionIdentification(){
+    sendAT(GF("+QAPPVER"));
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    res.replace(GSM_NL "OK" GSM_NL, "");
+    res.replace(GSM_NL, " ");
+    res.replace("+QAPPVER: ","");
+    res.trim();
+    return res;
+  }
+  bool configureGPS(void) {
+    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));//Based on Mobile Country Code (europe : galileo)
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+  bool configureGPSPriority(void) {
+    sendAT(GF("+QGPSCFG=\"priority\""));//Priority GNSS instead of WWAN
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+  bool test(void) {
+    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));//Based on Mobile Country Code (europe : galileo)
+    waitResponse();
+    sendAT(GF("+QGPSCFG=\"priority\",0,0"));//Priority GNSS, not saved
+    waitResponse();
+    sendAT(GF("+QGPS=1,1,0,1"));//Low Accuracy, Continuous positionning, Rate : 1 sec
+    waitResponse();
+    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));//Based on Mobile Country Code (europe : galileo)
+    waitResponse();
+    sendAT(GF("+QGPSCFG=\"priority\",0,0"));//Priority GNSS, not saved
+    waitResponse();
+    return true;
+  }
+  bool test_ask(void) {
+    sendAT(GF("+QGPSCFG=\"gnssconfig\""));//Based on Mobile Country Code (europe : galileo)
+    waitResponse();
+    //if (waitResponse() != 1) { return false; }
+    sendAT(GF("+QGPSCFG=?"));
+    waitResponse();
+    sendAT(GF("+QGPSEND=?"));
+    waitResponse();
+    sendAT(GF("+QGPSEND"));
+    waitResponse();
+    return true;
+  }
+#define MODEM_RAT_SEARCHED_AUTOMATIC    (0)
+#define MODEM_RAT_SEARCHED_GSM_ONLY     (1)
+#define MODEM_RAT_SEARCHED_LTE_ONLY     (3)
+#define MODEM_RAT_SEARCHED_ERROR        (255)
+  uint8_t query_modem_rat_searched(void){
+    uint8_t returned;
+    sendAT(GF("+QCFG=\"nwscanmode\""));
+    if (waitResponse(GF("+QCFG:")) != 1) { return MODEM_RAT_SEARCHED_ERROR; }
+    streamSkipUntil('"');
+    streamSkipUntil('"');
+    streamSkipUntil(',');
+    returned = stream.parseInt();
+    waitResponse();
+    return returned;
+    /* Max Response Time : 300ms
+     0 : Automatic (GSM + LTE)
+     1 : GSM only
+     3 : LTE only
+     */
+  }
+#define MODEM_NETWORK_CATEGORY_SEARCHED_EMTC     (0)
+#define MODEM_NETWORK_CATEGORY_SEARCHED_NBIOT    (1)
+#define MODEM_NETWORK_CATEGORY_SEARCHED_ALL      (2)
+#define MODEM_NETWORK_CATEGORY_SEARCHED_ERROR    (255)
+  uint8_t query_modem_network_category_searched(void){
+    uint8_t returned;
+    sendAT(GF("+QCFG=\"iotopmode\""));
+    if (waitResponse(GF("+QCFG:")) != 1) { return MODEM_NETWORK_CATEGORY_SEARCHED_ERROR; }
+    streamSkipUntil('"');
+    streamSkipUntil('"');
+    streamSkipUntil(',');
+    returned = stream.parseInt();
+    waitResponse();
+    return returned;
+    /* Max Response Time : 300ms
+     0 : eMTC
+     1 : NB-IoT
+     2 : eMTC and NB-IoT
+     */
+  }
+  void query_modem_register_settings(void){
+    sendAT(GF("+QCFG=\"band\""));
+    waitResponse(500);
+    sendAT(GF("+QCFG=\"nwscanmode\""));
+    waitResponse(500);
+    sendAT(GF("+QCFG=\"nwscanseq\""));
+    waitResponse(500);
+    sendAT(GF("+QCFG=\"iotopmode\""));
+    waitResponse(500);
+    /* Without any modification it gives :
+    +QCFG: "band",0x3,0x80084,0x80084
+    +QCFG: "nwscanmode",3
+    +QCFG: "nwscanseq",020301
+    +QCFG: "iotopmode",0
+    When previously set automatic_register
+    +QCFG: "band",0x3,0x80084,0x80084
+    +QCFG: "nwscanmode",0
+    +QCFG: "nwscanseq",020301
+    +QCFG: "iotopmode",2
+
+    */
+  }
+  void configure_europe_band(void){
+    /*
+     * =>Speed-up auto detection
+     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
+     * existing GSM band : GSM850, EGSM900, DCS1800, PCS1900
+     * Europe GSM : EGSM900/DCS1800
+     * EGSM900 : 0x1
+     * DCS1800 : 0x2
+     * =>3
+     * F for all bands
+     * Europe eMTC & NB-IOT bands : B3/B8/B20
+     * B3 : 0x4
+     * B8 : 0x80
+     * B20 : 0x80000
+     * =>80084
+     */
+    //sendAT(GF("+QCFG=\"band\",F,80084,80084,1"));
+    sendAT(GF("+QCFG=\"band\",3,80084,80084,1"));
+    waitResponse(500);
+  }
+  bool automatic_register(bool restart_modem = false) {
+    //// NB-IOT Band Configuration
+    //// 1NCE: 80 for Band 8
+    //sendAT(GF("+QCFG=\"band\",0,0,80,1"));
+    //waitResponse(500);
+
+    // Configure RAT(s) to be Searched
+    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
+    // 1 GSM only
+    // 3 LTE only
+    sendAT(GF("+QCFG=\"nwscanmode\",0,1"));
+    waitResponse(500);
+
+    // Configure RAT Searching Sequence
+    //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
+    //sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
+    // 00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
+    sendAT(GF("+QCFG=\"nwscanseq\",00,1"));
+    waitResponse(500);
+
+    // Configure Network Category to be Searched under 
+    // 0 : LTE Cat M1
+    // 1 : LTE Cat NB1
+    // 2 : LTE Cat M1 and Cat NB1(default)
+    //sendAT(GF("+QCFG=\"iotopmode\",1,1"));
+    sendAT(GF("+QCFG=\"iotopmode\",2,1"));
+    waitResponse(500);
+
+    //// Configure Service Domain
+    //// 1 : use PS domain service for data-service
+    //// 2 : CS & PS (default)
+    //sendAT(GF("+QCFG=\"servicedomain\",2,1"));
+    //waitResponse(500);
+
+    //// Configure Get the EMM cause value
+    //// 0 : Numeric value (default)
+    //// 1 : Verbose value
+    //sendAT(GF("+QCFG=\"emmcause\",0"));
+    //waitResponse(500);
+    if(restart_modem){
+      setPhoneFunctionalityImpl(0);
+      setPhoneFunctionalityImpl(1);
+    }
+
+    return true;
+  }
+  bool force_ltem_register(bool restart_modem = false) {
+    /* Purpose speed up searching time since much longer searching time for NB-IoT than eMTC
+     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
+     * 6.2. Solutions to Speed up Network Searching : 
+     * 6.2.1 Disable NB-IoT and Enable Required RAT(s)
+     */
+    // Configure Network Category to be Searched under 
+    // 0 : LTE Cat M1
+    // 1 : LTE Cat NB1
+    // 2 : LTE Cat M1 and Cat NB1(default)
+    sendAT(GF("+QCFG=\"iotopmode\",0,1"));
+    waitResponse(500);
+    // Configure RAT(s) to be Searched
+    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
+    // 1 GSM only
+    // 3 LTE only
+    sendAT(GF("+QCFG=\"nwscanmode\",3,1"));
+    waitResponse(500);
+    if(restart_modem){
+      setPhoneFunctionalityImpl(0);
+      setPhoneFunctionalityImpl(1);
+    }
+    return true;
+  }
+  bool force_nbiot_register(bool restart_modem = false) {
+    /* Purpose speed up searching time since much longer searching time for NB-IoT than eMTC
+     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
+     * 6.2. Solutions to Speed up Network Searching : 
+     * 6.2.2. Enable NB-IoT Bands Supported by Current Operator Only
+     */
+    // Configure Network Category to be Searched under 
+    // 0 : LTE Cat M1
+    // 1 : LTE Cat NB1
+    // 2 : LTE Cat M1 and Cat NB1(default)
+    sendAT(GF("+QCFG=\"iotopmode\",2,1"));
+    waitResponse(500);
+    // Configure RAT Searching Sequence
+    //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
+    //sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
+    // 00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
+    sendAT(GF("+QCFG=\"nwscanseq\",020301,1"));
+    waitResponse(500);
+    // Configure RAT(s) to be Searched
+    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
+    // 1 GSM only
+    // 3 LTE only
+    sendAT(GF("+QCFG=\"nwscanmode\",3,1"));
+    waitResponse(500);
+    if(restart_modem){
+      setPhoneFunctionalityImpl(0);
+      setPhoneFunctionalityImpl(1);
+    }
+    return true;
+  }
+  bool force_gsm_register(bool restart_modem = false) {
+    /* Purpose speed up searching time since much longer searching time for NB-IoT than eMTC
+     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
+     * 6.2. Solutions to Speed up Network Searching : 
+     * 6.2.1 Disable NB-IoT and Enable Required RAT(s)
+     */
+    // Configure RAT(s) to be Searched
+    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
+    // 1 GSM only
+    // 3 LTE only
+    sendAT(GF("+QCFG=\"nwscanmode\",1,1"));
+    waitResponse(500);
+    if(restart_modem){
+      setPhoneFunctionalityImpl(0);
+      setPhoneFunctionalityImpl(1);
+    }
+    return true;
+  }
+  bool lte_and_falling_gsm_register(bool restore_band = false, bool restart_modem = false) {
+    if(restore_band){
+      // Restore default Banc Configuration
+      sendAT(GF("+QCFG=\"bandrestore\""));
+      waitResponse(500);
+    }
+    // Configure Network Category to be Searched under 
+    // 0 : LTE Cat M1
+    // 1 : LTE Cat NB1
+    // 2 : LTE Cat M1 and Cat NB1(default)
+    sendAT(GF("+QCFG=\"iotopmode\",2,1"));
+    waitResponse(500);
+    // Configure RAT(s) to be Searched
+    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
+    // 1 GSM only
+    // 3 LTE only
+    sendAT(GF("+QCFG=\"nwscanmode\",0,1"));
+    waitResponse(500);
+    // Configure RAT Searching Sequence
+    //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
+    //sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
+    // 00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
+    // 01 : GSM
+    // 02 : LTE-M(eMTC)
+    // 03 : NB-IOT
+    sendAT(GF("+QCFG=\"nwscanseq\",020301,1"));
+    waitResponse(500);
+    if(restart_modem){
+      setPhoneFunctionalityImpl(0);
+      setPhoneFunctionalityImpl(1);
+    }
+    return true;
+  }
+  /*
+   * parse AT+COPS :
+   * +COPS: <mode>[,<format>[,<oper>][,<Act>]]
+   * where <Act>:
+   * 0 : GSM
+   * 8 : eMTC/LTE-M
+   * 9 : NB-IoT
+   */
+#define MODEM_COP_GSM     (0)
+#define MODEM_COP_EMTC    (8)
+#define MODEM_COP_NBIOT   (9)
+  uint8_t get_access_technology(void) {
+    uint8_t act_value;
+    sendAT(GF("+COPS?"));
+    if (waitResponse(GF("+COPS:")) != 1) { return 10; }
+    streamSkipUntil('"'); /* Skip mode and format */
+    streamSkipUntil('"'); /* Skip mode and format */
+    streamSkipUntil(','); /* Skip mode and format */
+    act_value = stream.parseInt();
+    waitResponse();
+    return act_value;
+  }
+  void get_emmcause(void) {
+    uint8_t act_value;
+    sendAT(GF("+QCFG=\"emmcause\",1"));
+    waitResponse();
+  }
+  bool ask_to_automatically_register(void) {
+    sendAT(GF("+COPS=0"));  // Auto-register to the network
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+ protected:
+  // enable GPS
+  bool enableGPSImpl() {
+    sendAT(GF("+QGPS=1"));
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+
+  bool disableGPSImpl() {
+    sendAT(GF("+QGPSEND"));
+    if (waitResponse() != 1) { return false; }
+    return true;
+  }
+
+  // get the RAW GPS output
+  String getGPSrawImpl() {
+    sendAT(GF("+QGPSLOC=2"));
+    if (waitResponse(10000L, GF(GSM_NL "+QGPSLOC:")) != 1) { return ""; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.trim();
+    return res;
+  }
+
+  // get GPS informations
+  bool getGPSImpl(float* lat, float* lon, float* speed = 0, float* alt = 0,
+                  int* vsat = 0, int* usat = 0, float* accuracy = 0,
+                  int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
+                  int* minute = 0, int* second = 0) {
+    sendAT(GF("+QGPSLOC=2"));
+    if (waitResponse(10000L, GF(GSM_NL "+QGPSLOC: ")) != 1) {
+      // NOTE:  Will return an error if the position isn't fixed
+      return false;
+    }
+
+    // init variables
+    float ilat         = 0;
+    float ilon         = 0;
+    float ispeed       = 0;
+    float ialt         = 0;
+    int   iusat        = 0;
+    float iaccuracy    = 0;
+    int   iyear        = 0;
+    int   imonth       = 0;
+    int   iday         = 0;
+    int   ihour        = 0;
+    int   imin         = 0;
+    float secondWithSS = 0;
+
+    // UTC date & Time
+    ihour        = streamGetIntLength(2);      // Two digit hour
+    imin         = streamGetIntLength(2);      // Two digit minute
+    secondWithSS = streamGetFloatBefore(',');  // 6 digit second with subseconds
+
+    ilat      = streamGetFloatBefore(',');  // Latitude
+    ilon      = streamGetFloatBefore(',');  // Longitude
+    iaccuracy = streamGetFloatBefore(',');  // Horizontal precision
+    ialt      = streamGetFloatBefore(',');  // Altitude from sea level
+    streamSkipUntil(',');                   // GNSS positioning mode
+    streamSkipUntil(',');  // Course Over Ground based on true north
+    streamSkipUntil(',');  // Speed Over Ground in Km/h
+    ispeed = streamGetFloatBefore(',');  // Speed Over Ground in knots
+
+    iday   = streamGetIntLength(2);    // Two digit day
+    imonth = streamGetIntLength(2);    // Two digit month
+    iyear  = streamGetIntBefore(',');  // Two digit year
+
+    iusat = streamGetIntBefore(',');  // Number of satellites,
+    streamSkipUntil('\n');  // The error code of the operation. If it is not
+                            // 0, it is the type of error.
+
+    // Set pointers
+    if (lat != NULL) *lat = ilat;
+    if (lon != NULL) *lon = ilon;
+    if (speed != NULL) *speed = ispeed;
+    if (alt != NULL) *alt = ialt;
+    if (vsat != NULL) *vsat = 0;
+    if (usat != NULL) *usat = iusat;
+    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (iyear < 2000) iyear += 2000;
+    if (year != NULL) *year = iyear;
+    if (month != NULL) *month = imonth;
+    if (day != NULL) *day = iday;
+    if (hour != NULL) *hour = ihour;
+    if (minute != NULL) *minute = imin;
+    if (second != NULL) *second = static_cast<int>(secondWithSS);
+
+    waitResponse();  // Final OK
+    return true;
+  }
+
+  /*
+   * Time functions
+   */
+ protected:
+  String getGSMDateTimeImpl(TinyGSMDateTimeFormat format) {
+    sendAT(GF("+QLTS=2"));
+    if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return ""; }
+
+    String res;
+
+    switch (format) {
+      case DATE_FULL: res = stream.readStringUntil('"'); break;
+      case DATE_TIME:
+        streamSkipUntil(',');
+        res = stream.readStringUntil('"');
+        break;
+      case DATE_DATE: res = stream.readStringUntil(','); break;
+    }
+    waitResponse();  // Ends with OK
+    return res;
+  }
+
+  // The BG95 returns UTC time instead of local time as other modules do in
+  // response to CCLK, so we're using QLTS where we can specifically request
+  // local time.
+  bool getNetworkUTCTimeImpl(int* year, int* month, int* day, int* hour,
+                          int* minute, int* second, float* timezone) {
+    sendAT(GF("+QLTS=1"));
+    if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return false; }
+
+    int iyear     = 0;
+    int imonth    = 0;
+    int iday      = 0;
+    int ihour     = 0;
+    int imin      = 0;
+    int isec      = 0;
+    int itimezone = 0;
+
+    // Date & Time
+    iyear       = streamGetIntBefore('/');
+    imonth      = streamGetIntBefore('/');
+    iday        = streamGetIntBefore(',');
+    ihour       = streamGetIntBefore(':');
+    imin        = streamGetIntBefore(':');
+    isec        = streamGetIntLength(2);
+    char tzSign = stream.read();
+    itimezone   = streamGetIntBefore(',');
+    if (tzSign == '-') { itimezone = itimezone * -1; }
+    streamSkipUntil('\n');  // DST flag
+
+    // Set pointers
+    if (iyear < 2000) iyear += 2000;
+    if (year != NULL) *year = iyear;
+    if (month != NULL) *month = imonth;
+    if (day != NULL) *day = iday;
+    if (hour != NULL) *hour = ihour;
+    if (minute != NULL) *minute = imin;
+    if (second != NULL) *second = isec;
+    if (timezone != NULL) *timezone = static_cast<float>(itimezone) / 4.0;
+
+    // Final OK
+    waitResponse();  // Ends with OK
+    return true;
+  }
+
+  // The BG95 returns UTC time instead of local time as other modules do in
+  // response to CCLK, so we're using QLTS where we can specifically request
+  // local time.
+  bool getNetworkTimeImpl(int* year, int* month, int* day, int* hour,
+                          int* minute, int* second, float* timezone) {
+    sendAT(GF("+QLTS=2"));
+    if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return false; }
+
+    int iyear     = 0;
+    int imonth    = 0;
+    int iday      = 0;
+    int ihour     = 0;
+    int imin      = 0;
+    int isec      = 0;
+    int itimezone = 0;
+
+    // Date & Time
+    iyear       = streamGetIntBefore('/');
+    imonth      = streamGetIntBefore('/');
+    iday        = streamGetIntBefore(',');
+    ihour       = streamGetIntBefore(':');
+    imin        = streamGetIntBefore(':');
+    isec        = streamGetIntLength(2);
+    char tzSign = stream.read();
+    itimezone   = streamGetIntBefore(',');
+    if (tzSign == '-') { itimezone = itimezone * -1; }
+    streamSkipUntil('\n');  // DST flag
+
+    // Set pointers
+    if (iyear < 2000) iyear += 2000;
+    if (year != NULL) *year = iyear;
+    if (month != NULL) *month = imonth;
+    if (day != NULL) *day = iday;
+    if (hour != NULL) *hour = ihour;
+    if (minute != NULL) *minute = imin;
+    if (second != NULL) *second = isec;
+    if (timezone != NULL) *timezone = static_cast<float>(itimezone) / 4.0;
+
+    // Final OK
+    waitResponse();  // Ends with OK
+    return true;
+  }
+
+  /*
+   * NTP server functions
+   */
+
+  byte NTPServerSyncImpl(String server = "pool.ntp.org", byte = -5) {
+    // Request network synchronization
+    // AT+QNTP=<contextID>,<server>[,<port>][,<autosettime>]
+    sendAT(GF("+QNTP=1,\""), server, '"');
+    if (waitResponse(10000L, GF("+QNTP:"))) {
+      String result = stream.readStringUntil(',');
+      streamSkipUntil('\n');
+      result.trim();
+      if (TinyGsmIsValidNumber(result)) { return result.toInt(); }
+    } else {
+      return -1;
+    }
+    return -1;
+  }
+
+  String ShowNTPErrorImpl(byte error) TINY_GSM_ATTR_NOT_IMPLEMENTED;
+
+  /*
+   * Battery functions
+   */
+ protected:
+  // Can follow CBC as in the template
+
+  /*
+   * Temperature functions
+   */
+ protected:
+  // get temperature in degree celsius
+  uint16_t getTemperatureImpl() {
+    sendAT(GF("+QTEMP"));
+    if (waitResponse(GF(GSM_NL "+QTEMP:")) != 1) { return 0; }
+    // return temperature in C
+    uint16_t res =
+        streamGetIntBefore(',');  // read PMIC (primary ic) temperature
+    streamSkipUntil(',');         // skip XO temperature ??
+    streamSkipUntil('\n');        // skip PA temperature ??
+    // Wait for final OK
+    waitResponse();
+    return res;
+  }
+
+  /*
+   * Client related functions
+   */
+ protected:
+  bool modemConnect(const char* host, uint16_t port, uint8_t mux,
+                    bool ssl = false, int timeout_s = 150) {
+
+    uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
+
+      // set the ssl version
+      // AT+QSSLCFG="sslversion",<ctxindex>,<sslversion>
+      // <ctxindex> PDP context identifier
+      // <sslversion> 0: QAPI_NET_SSL_3.0
+      //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
+      //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
+      //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
+      //              4: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+QSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
+      if (waitResponse(5000L) != 1) return false;
+      // set the ssl cipher_suite
+      // AT+QSSLCFG="ciphersuite",<ctxindex>,<cipher_suite>
+      // <ctxindex> PDP context identifier
+      // <cipher_suite> 0: TODO
+      //              1: TODO
+      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+      //              0XFFFF: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+QSSLCFG=\"ciphersuite\",0,0X0035"));  // TLS_RSA_WITH_AES_256_CBC_SHA
+      if (waitResponse(5000L) != 1) return false;
+      // set the ssl sec level
+      // AT+QSSLCFG="seclevel",<ctxindex>,<sec_level>
+      // <ctxindex> PDP context identifier
+      // <sec_level> 0: TODO
+      //              1: TODO
+      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+      //              0XFFFF: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+QSSLCFG=\"seclevel\",0,1"));
+      if (waitResponse(5000L) != 1) return false;
+
+
+      if (certificates[mux] != "") {
+        // apply the correct certificate to the connection
+        // AT+QSSLCFG="cacert",<ctxindex>,<caname>
+        // <ctxindex> PDP context identifier
+        // <certname> certificate name
+
+        //sendAT(GF("+CASSLCFG="), mux, ",CACERT,\"", certificates[mux].c_str(),
+        //       "\"");
+        sendAT(GF("+QSSLCFG=\"cacert\",0,\""), certificates[mux].c_str(), GF("\""));
+        if (waitResponse(5000L) != 1) return false;
+
+      }
+
+    // <PDPcontextID>(1-16), <connectID>(0-11),
+    // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
+    // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
+    //may need previous AT+QSSLCFG
+    sendAT(GF("+QSSLOPEN=1,1,"), mux, GF(",\""), host,
+          GF("\","), port, GF(",0"));
+    waitResponse();
+
+    if (waitResponse(timeout_ms, GF(GSM_NL "+QSSLOPEN:")) != 1) { return false; }
+    //20230629 -> +QSSLOPEN: <clientID>,<err>
+    //clientID is mux
+    //err must be 0
+    if (streamGetIntBefore(',') != mux) { return false; }
+    // Read status
+    return (0 == streamGetIntBefore('\n'));
+  }
+
+  int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
+    sendAT(GF("+QSSLSEND="), mux, ',', (uint16_t)len);
+    if (waitResponse(GF(">")) != 1) { return 0; }
+    stream.write(reinterpret_cast<const uint8_t*>(buff), len);
+    stream.flush();
+    if (waitResponse(GF(GSM_NL "SEND OK")) != 1) { return 0; }
+    // TODO(?): Wait for ACK? AT+QSSLSEND=id,0
+    return len;
+  }
+
+  size_t modemRead(size_t size, uint8_t mux) {
+    if (!sockets[mux]) return 0;
+    sendAT(GF("+QSSLRECV="), mux, ',', (uint16_t)size);
+    if (waitResponse(GF("+QSSLRECV:")) != 1) {
+      DBG("### READ: For unknown reason close");
+      return 0;
+    }
+    int16_t len = streamGetIntBefore('\n');
+
+    for (int i = 0; i < len; i++) {
+      moveCharFromStreamToFifo(mux);
+      }
+    waitResponse();
+    sockets[mux]->sock_available = modemGetAvailable(mux);
+    return len;
+  }
+
+  size_t modemGetAvailable(uint8_t mux) {
+    if (!sockets[mux]) return 0;
+    sendAT(GF("+QSSLRECV="), mux, GF(",0"));
+    size_t result = 0;
+    if (waitResponse(GF("+QSSLRECV:")) == 1) {
+      streamSkipUntil(',');  // Skip total received
+      streamSkipUntil(',');  // Skip have read
+      result = streamGetIntBefore('\n');
+      if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
+      waitResponse();
+    }
+    //if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
+    return result;
+  }
+
+  bool modemGetConnected(uint8_t mux) {
+    sendAT(GF("+QSSLSTATE=1,"), mux);
+    // +QSSLSTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
+
+    if (waitResponse(GF("+QSSLSTATE:")) != 1) { return false; }
+
+    streamSkipUntil(',');                  // Skip mux
+    streamSkipUntil(',');                  // Skip socket type
+    streamSkipUntil(',');                  // Skip remote ip
+    streamSkipUntil(',');                  // Skip remote port
+    streamSkipUntil(',');                  // Skip local port
+    int8_t res = streamGetIntBefore(',');  // socket state
+
+    waitResponse();
+
+    // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
+    return 2 == res;
+  }
+
+  /*
+   * Utilities
+   */
+ public:
+  // TODO(vshymanskyy): Optimize this!
+  int8_t waitResponse(uint32_t timeout_ms, String& data,
+                      GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    /*String r1s(r1); r1s.trim();
+    String r2s(r2); r2s.trim();
+    String r3s(r3); r3s.trim();
+    String r4s(r4); r4s.trim();
+    String r5s(r5); r5s.trim();
+    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
+    data.reserve(64);
+    uint8_t  index       = 0;
+    uint32_t startMillis = millis();
+    do {
+      TINY_GSM_YIELD();
+      while (stream.available() > 0) {
+        TINY_GSM_YIELD();
+        int8_t a = stream.read();
+        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
+        data += static_cast<char>(a);
+        if (r1 && data.endsWith(r1)) {
+          index = 1;
+          goto finish;
+        } else if (r2 && data.endsWith(r2)) {
+          index = 2;
+          goto finish;
+        } else if (r3 && data.endsWith(r3)) {
+#if defined TINY_GSM_DEBUG
+          if (r3 == GFP(GSM_CME_ERROR)) {
+            streamSkipUntil('\n');  // Read out the error
+          }
+#endif
+          index = 3;
+          goto finish;
+        } else if (r4 && data.endsWith(r4)) {
+          index = 4;
+          goto finish;
+        } else if (r5 && data.endsWith(r5)) {
+          index = 5;
+          goto finish;
+        } else if (data.endsWith(GF(GSM_NL "+QIURC:"))) {
+          streamSkipUntil('\"');
+          String urc = stream.readStringUntil('\"');
+          streamSkipUntil(',');
+          if (urc == "recv") {
+            int8_t mux = streamGetIntBefore('\n');
+            DBG("### URC RECV:", mux);
+            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+              sockets[mux]->got_data = true;
+            }
+          } else if (urc == "closed") {
+            int8_t mux = streamGetIntBefore('\n');
+            DBG("### URC CLOSE:", mux);
+            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+              sockets[mux]->sock_connected = false;
+            }
+          } else {
+            streamSkipUntil('\n');
+          }
+          data = "";
+        }
+      }
+    } while (millis() - startMillis < timeout_ms);
+  finish:
+    if (!index) {
+      data.trim();
+      if (data.length() && data!="RDY") { DBG("### Unhandled:", data); }
+      data = "";
+    }
+    // data.replace(GSM_NL, "/");
+    // DBG('<', index, '>', data);
+    return index;
+  }
+
+  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    String data;
+    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
+  }
+
+  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL) {
+    return waitResponse(1000, r1, r2, r3, r4, r5);
+  }
+
+ public:
+  Stream& stream;
+
+ protected:
+  GsmClientBG95* sockets[TINY_GSM_MUX_COUNT];
+  const char*    gsmNL = GSM_NL;
+  String         certificates[TINY_GSM_MUX_COUNT];
+};
+
+#endif  // SRC_TINYGSMCLIENTBG95_H_
diff --git a/src/TinyGsmCommon.h b/src/TinyGsmCommon.h
index 24a1264..bb790a4 100644
--- a/src/TinyGsmCommon.h
+++ b/src/TinyGsmCommon.h
@@ -10,7 +10,7 @@
 #define SRC_TINYGSMCOMMON_H_
 
 // The current library version number
-#define TINYGSM_VERSION "0.11.7"
+#define TINYGSM_VERSION "0.11.8"
 
 #if defined(SPARK) || defined(PARTICLE)
 #include "Particle.h"
diff --git a/src/TinyGsmTime.tpp b/src/TinyGsmTime.tpp
index fb58c7d..056a222 100644
--- a/src/TinyGsmTime.tpp
+++ b/src/TinyGsmTime.tpp
@@ -29,6 +29,11 @@ class TinyGsmTime {
     return thisModem().getNetworkTimeImpl(year, month, day, hour, minute,
                                           second, timezone);
   }
+  bool getNetworkUTCTime(int* year, int* month, int* day, int* hour, int* minute,
+                      int* second, float* timezone) {
+    return thisModem().getNetworkUTCTimeImpl(year, month, day, hour, minute,
+                                          second, timezone);
+  }
 
   /*
    * CRTP Helper

From 4a09c886d1cf206bb7cfb8d54c072d6a2e7ce401 Mon Sep 17 00:00:00 2001
From: Mikael Fredriksson <Gelemikke@users.noreply.github.com>
Date: Wed, 6 Mar 2024 10:29:16 +0100
Subject: [PATCH 033/100] Make setBaud() return a bool

Allows checking if the change baud rate command was correctly received by the modem and helps avoiding mismatch in baud rate
---
 src/TinyGsmModem.tpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index c15b1ec..4f6209f 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -29,8 +29,8 @@ class TinyGsmModem {
     thisModem().stream.flush();
     TINY_GSM_YIELD(); /* DBG("### AT:", cmd...); */
   }
-  void setBaud(uint32_t baud) {
-    thisModem().setBaudImpl(baud);
+  bool setBaud(uint32_t baud) {
+    return thisModem().setBaudImpl(baud);
   }
   // Test response to AT commands
   bool testAT(uint32_t timeout_ms = 10000L) {
@@ -106,10 +106,10 @@ class TinyGsmModem {
    * Basic functions
    */
  protected:
-  void setBaudImpl(uint32_t baud) {
+  bool setBaudImpl(uint32_t baud) {
     thisModem().sendAT(GF("+IPR="), baud);
-    thisModem().waitResponse();
-  }
+    return thisModem().waitResponse() == 1;
+  } 
 
   bool testATImpl(uint32_t timeout_ms = 10000L) {
     for (uint32_t start = millis(); millis() - start < timeout_ms;) {

From bfdbbdb617b9060858fdccf3aa3e0b4d48ebcf41 Mon Sep 17 00:00:00 2001
From: Mikael Fredriksson <Gelemikke@users.noreply.github.com>
Date: Wed, 6 Mar 2024 10:38:32 +0100
Subject: [PATCH 034/100] add getNetworkSystemMode() for SIM7600

The function implementation is more or less a copy from the SIM7000 function as the same command is supported by both modems
---
 src/TinyGsmClientSIM7600.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 9f47c5d..b6792ec 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -291,6 +291,17 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     return waitResponse() == 1;
   }
 
+  bool getNetworkSystemMode(bool& n, int16_t& stat) {
+    // n: whether to automatically report the system mode info
+    // stat: the current service. 0 if it not connected
+    sendAT(GF("+CNSMOD?"));
+    if (waitResponse(GF(GSM_NL "+CNSMOD:")) != 1) { return false; }
+    n    = streamGetIntBefore(',') != 0;
+    stat = streamGetIntBefore('\n');
+    waitResponse();
+    return true;
+  }
+
   String getLocalIPImpl() {
     sendAT(GF("+IPADDR"));  // Inquire Socket PDP address
     // sendAT(GF("+CGPADDR=1"));  // Show PDP address

From 9659e83b5988c6fb15890e907d31d6a446f22671 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 11 Apr 2024 16:04:02 -0400
Subject: [PATCH 035/100] Add some docs to FiFo

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmFifo.h | 282 +++++++++++++++++++++++++---------------------
 1 file changed, 154 insertions(+), 128 deletions(-)

diff --git a/src/TinyGsmFifo.h b/src/TinyGsmFifo.h
index 0a4028d..856e25a 100644
--- a/src/TinyGsmFifo.h
+++ b/src/TinyGsmFifo.h
@@ -2,140 +2,166 @@
 #define TinyGsmFifo_h
 
 template <class T, unsigned N>
-class TinyGsmFifo
-{
-public:
-    TinyGsmFifo()
-    {
-        clear();
+class TinyGsmFifo {
+ public:
+  /**
+   * @brief Construct a new Tiny Gsm Fifo object, setting the head and tail to
+   * 0.
+   */
+  TinyGsmFifo() {
+    clear();
+  }
+
+  /**
+   * @brief Clear the FIFO - set the read and write positions to 0
+   */
+  void clear() {
+    _r = 0;
+    _w = 0;
+  }
+
+  // writing thread/context API
+  //-------------------------------------------------------------
+
+  /**
+   * @brief Check if the buffer is writable - that is if it has any space left
+   *
+   * @return *true* The buffer has free space.
+   * @return *false* There is no space left in the buffer.
+   */
+  bool writeable(void) {
+    return free() > 0;
+  }
+
+  /**
+   * @brief Check the number of free positions in the buffer.
+   *
+   * @return *int*  The number number of free positions in the buffer
+   */
+  int free(void) {
+    int s = _r - _w;     // Check if the read is ahead of the write
+    if (s <= 0) s += N;  // if not wrap
+    return s - 1;  // return the difference between r and w, accounting for wrap
+  }
+
+  /**
+   * @brief Add a single item to the buffer. This is non-blocking.
+   *
+   * @param c Reference of the item of type 'T' to add to the buffer
+   * @return *true* The item was successfully added to the buffer
+   * @return *false* Nothing was added to the buffer
+   */
+  bool put(const T& c) {
+    int i = _w;       // check the write position
+    int j = i;        // set the spot for the new item to the write position
+    i     = _inc(i);  // check where the next increment of the write will be
+    if (i == _r)  // make sure the next spot isn't the position of the read (ie,
+                  // the buffer is full)
+      return false;
+    _b[j] = c;  // add the item at position j
+    _w    = i;  // bump the write position
+    return true;
+  }
+
+  /**
+   * @brief Add multiple items to be buffer
+   *
+   * @param p Pointer to the items to add
+   * @param n The number of items to add
+   * @param t Whether to block while waiting for space enough space to clear to
+   * add all items
+   * @return *int* The number of items successfully added
+   */
+  int put(const T* p, int n, bool t = false) {
+    int c = n;
+    while (c) {
+      int f;
+      while ((f = free()) == 0)  // wait for space
+      {
+        if (!t) return n - c;  // no more space and not blocking
+        /* nothing / just wait */;
+      }
+      // check free space
+      if (c < f) f = c;
+      int w = _w;
+      int m = N - w;
+      // check wrap
+      if (f > m) f = m;
+      memcpy(&_b[w], p, f);
+      _w = _inc(w, f);
+      c -= f;
+      p += f;
     }
+    return n - c;
+  }
 
-    void clear()
-    {
-        _r = 0;
-        _w = 0;
+  // reading thread/context API
+  // --------------------------------------------------------
+
+  bool readable(void) {
+    return (_r != _w);
+  }
+
+  size_t size(void) {
+    int s = _w - _r;
+    if (s < 0) s += N;
+    return s;
+  }
+
+  bool get(T* p) {
+    int r = _r;
+    if (r == _w)  // !readable()
+      return false;
+    *p = _b[r];
+    _r = _inc(r);
+    return true;
+  }
+
+  int get(T* p, int n, bool t = false) {
+    int c = n;
+    while (c) {
+      int f;
+      for (;;)  // wait for data
+      {
+        f = size();
+        if (f) break;          // free space
+        if (!t) return n - c;  // no space and not blocking
+        /* nothing / just wait */;
+      }
+      // check available data
+      if (c < f) f = c;
+      int r = _r;
+      int m = N - r;
+      // check wrap
+      if (f > m) f = m;
+      memcpy(p, &_b[r], f);
+      _r = _inc(r, f);
+      c -= f;
+      p += f;
     }
+    return n - c;
+  }
 
-    // writing thread/context API
-    //-------------------------------------------------------------
+  uint8_t peek() {
+    return _b[_r];
+  }
 
-    bool writeable(void)
-    {
-        return free() > 0;
-    }
+ private:
+  /**
+   * @brief Get the next increment spot in the buffer, accounting for the size
+   * of each item in the buffer
+   *
+   * @param i
+   * @param n
+   * @return *int*
+   */
+  int _inc(int i, int n = 1) {
+    return (i + n) % N;
+  }
 
-    int free(void)
-    {
-        int s = _r - _w;
-        if (s <= 0)
-            s += N;
-        return s - 1;
-    }
-
-    bool put(const T& c)
-    {
-        int i = _w;
-        int j = i;
-        i = _inc(i);
-        if (i == _r) // !writeable()
-            return false;
-        _b[j] = c;
-        _w = i;
-        return true;
-    }
-
-    int put(const T* p, int n, bool t = false)
-    {
-        int c = n;
-        while (c)
-        {
-            int f;
-            while ((f = free()) == 0) // wait for space
-            {
-                if (!t) return n - c; // no more space and not blocking
-                /* nothing / just wait */;
-            }
-            // check free space
-            if (c < f) f = c;
-            int w = _w;
-            int m = N - w;
-            // check wrap
-            if (f > m) f = m;
-            memcpy(&_b[w], p, f);
-            _w = _inc(w, f);
-            c -= f;
-            p += f;
-        }
-        return n - c;
-    }
-
-    // reading thread/context API
-    // --------------------------------------------------------
-
-    bool readable(void)
-    {
-        return (_r != _w);
-    }
-
-    size_t size(void)
-    {
-        int s = _w - _r;
-        if (s < 0)
-            s += N;
-        return s;
-    }
-
-    bool get(T* p)
-    {
-        int r = _r;
-        if (r == _w) // !readable()
-            return false;
-        *p = _b[r];
-        _r = _inc(r);
-        return true;
-    }
-
-    int get(T* p, int n, bool t = false)
-    {
-        int c = n;
-        while (c)
-        {
-            int f;
-            for (;;) // wait for data
-            {
-                f = size();
-                if (f)  break;        // free space
-                if (!t) return n - c; // no space and not blocking
-                /* nothing / just wait */;
-            }
-            // check available data
-            if (c < f) f = c;
-            int r = _r;
-            int m = N - r;
-            // check wrap
-            if (f > m) f = m;
-            memcpy(p, &_b[r], f);
-            _r = _inc(r, f);
-            c -= f;
-            p += f;
-        }
-        return n - c;
-    }
-
-	uint8_t peek()
-	{
-		return _b[_r];
-	}
-
-private:
-    int _inc(int i, int n = 1)
-    {
-        return (i + n) % N;
-    }
-
-    T    _b[N];
-    int  _w;
-    int  _r;
+  T   _b[N];  /// The buffer, containing 'N' items of type 'T'
+  int _w;     /// The write position in the buffer
+  int _r;     /// The read position in the buffer
 };
 
 #endif

From 56305cb1a450ccb99f960aff50c4f71455cb6737 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 11 Apr 2024 16:14:31 -0400
Subject: [PATCH 036/100] Moved "OK" and "ERROR" to modem template

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h             | 10 +---------
 src/TinyGsmClientBG96.h           | 10 +---------
 src/TinyGsmClientESP8266.h        |  7 ++-----
 src/TinyGsmClientM590.h           | 10 +---------
 src/TinyGsmClientM95.h            | 10 +---------
 src/TinyGsmClientMC60.h           | 10 +---------
 src/TinyGsmClientSIM5360.h        | 10 +---------
 src/TinyGsmClientSIM70xx.h        | 12 +-----------
 src/TinyGsmClientSIM7600.h        | 10 +---------
 src/TinyGsmClientSIM800.h         | 10 +---------
 src/TinyGsmClientSaraR4.h         | 10 +---------
 src/TinyGsmClientSequansMonarch.h | 11 ++---------
 src/TinyGsmClientUBLOX.h          | 10 +---------
 src/TinyGsmClientXBee.h           |  6 +-----
 src/TinyGsmModem.tpp              | 14 +++++++++++++-
 15 files changed, 29 insertions(+), 121 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index 9226960..d6959fa 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -14,6 +14,7 @@
 
 #define TINY_GSM_MUX_COUNT 8
 #define TINY_GSM_NO_MODEM_BUFFER
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -23,14 +24,6 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -574,7 +567,6 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
 
  protected:
   GsmClientA6* sockets[TINY_GSM_MUX_COUNT];
-  const char*  gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTA6_H_
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index e696404..b5c4536 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -14,6 +14,7 @@
 
 #define TINY_GSM_MUX_COUNT 12
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -26,14 +27,6 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -721,7 +714,6 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
 
  protected:
   GsmClientBG96* sockets[TINY_GSM_MUX_COUNT];
-  const char*    gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTBG96_H_
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 92763a0..e0ee341 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -14,16 +14,14 @@
 
 #define TINY_GSM_MUX_COUNT 5
 #define TINY_GSM_NO_MODEM_BUFFER
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmWifi.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-static uint8_t    TINY_GSM_TCP_KEEP_ALIVE      = 120;
+static uint8_t TINY_GSM_TCP_KEEP_ALIVE = 120;
 
 // <stat> status of ESP8266 station interface
 // 2 : ESP8266 station connected to an AP and has obtained IP
@@ -479,7 +477,6 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
 
  protected:
   GsmClientESP8266* sockets[TINY_GSM_MUX_COUNT];
-  const char*       gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTESP8266_H_
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index e921447..f89500d 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -14,6 +14,7 @@
 
 #define TINY_GSM_MUX_COUNT 2
 #define TINY_GSM_NO_MODEM_BUFFER
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
@@ -21,14 +22,6 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -467,7 +460,6 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
 
  protected:
   GsmClientM590* sockets[TINY_GSM_MUX_COUNT];
-  const char*    gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTM590_H_
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 538969a..0a902e9 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -15,6 +15,7 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_NO_CHECK
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -25,14 +26,6 @@
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -630,7 +623,6 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
 
  protected:
   GsmClientM95* sockets[TINY_GSM_MUX_COUNT];
-  const char*   gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTM95_H_
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index abc5488..f43e9b0 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -17,6 +17,7 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_NO_CHECK
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -26,14 +27,6 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -616,7 +609,6 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
 
  protected:
   GsmClientMC60* sockets[TINY_GSM_MUX_COUNT];
-  const char*    gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTMC60_H_
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index f181036..8463a34 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -14,6 +14,7 @@
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -25,14 +26,6 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -735,7 +728,6 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
 
  protected:
   GsmClientSim5360* sockets[TINY_GSM_MUX_COUNT];
-  const char*       gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTSIM5360_H_
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 45d1f5e..b672b76 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -11,6 +11,7 @@
 
 // #define TINY_GSM_DEBUG Serial
 // #define TINY_GSM_USE_HEX
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -21,14 +22,6 @@
 #include "TinyGsmNTP.tpp"
 #include "TinyGsmGSMLocation.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -451,9 +444,6 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
 
  public:
   Stream& stream;
-
- protected:
-  const char* gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTSIM70XX_H_
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 9f47c5d..1b75871 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -14,6 +14,7 @@
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -28,14 +29,6 @@
 #include "TinyGsmNTP.tpp"
 
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -860,7 +853,6 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
 
  protected:
   GsmClientSim7600* sockets[TINY_GSM_MUX_COUNT];
-  const char*       gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTSIM7600_H_
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index ebefdb9..9147d14 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -15,6 +15,7 @@
 
 #define TINY_GSM_MUX_COUNT 5
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -27,14 +28,6 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -765,7 +758,6 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
 
  protected:
   GsmClientSim800* sockets[TINY_GSM_MUX_COUNT];
-  const char*      gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTSIM800_H_
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 8cc0b4d..fe23218 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -14,6 +14,7 @@
 
 #define TINY_GSM_MUX_COUNT 7
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -26,14 +27,6 @@
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -892,7 +885,6 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
 
  protected:
   GsmClientSaraR4* sockets[TINY_GSM_MUX_COUNT];
-  const char*      gsmNL = GSM_NL;
   bool             has2GFallback;
   bool             supportsAsyncSockets;
 };
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 8d3a8cb..694733a 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -13,6 +13,7 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmCalling.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -23,14 +24,6 @@
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -727,7 +720,7 @@ class TinyGsmSequansMonarch
  protected:
   GsmClientSequansMonarch* sockets[TINY_GSM_MUX_COUNT];
   // GSM_NL (\r\n) is not accepted with SQNSSENDEXT in data mode so use \n
-  const char*              gsmNL = "\n";
+  const char* gsmNL = "\n";
 };
 
 #endif  // SRC_TINYGSMCLIENTSEQUANSMONARCH_H_
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index cf60040..1250da4 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -14,6 +14,7 @@
 
 #define TINY_GSM_MUX_COUNT 7
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -26,14 +27,6 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
 enum RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
@@ -848,7 +841,6 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
 
  protected:
   GsmClientUBLOX* sockets[TINY_GSM_MUX_COUNT];
-  const char*     gsmNL = GSM_NL;
 };
 
 #endif  // SRC_TINYGSMCLIENTUBLOX_H_
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 1c90a7b..8a15447 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -20,6 +20,7 @@
 // XBee's have a default guard time of 1 second (1000ms, 10 extra for safety
 // here)
 #define TINY_GSM_XBEE_GUARD_TIME 1010
+#define GSM_NL "\r"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -30,10 +31,6 @@
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmWifi.tpp"
 
-#define GSM_NL "\r"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-
 // Use this to avoid too many entrances and exits from command mode.
 // The cellular Bee's often freeze up and won't respond when attempting
 // to enter command mode too many times.
@@ -1623,7 +1620,6 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
 
  protected:
   GsmClientXBee* sockets[TINY_GSM_MUX_COUNT];
-  const char*    gsmNL = GSM_NL;
   int16_t        guardTime;
   XBeeType       beeType;
   int8_t         resetPin;
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index c15b1ec..e909cae 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -11,6 +11,18 @@
 
 #include "TinyGsmCommon.h"
 
+#ifndef GSM_NL
+#define GSM_NL "\r\n"
+#endif
+
+static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
+static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
+
+#if defined       TINY_GSM_DEBUG
+static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
+static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
+#endif
+
 template <class modemType>
 class TinyGsmModem {
  public:
@@ -25,7 +37,7 @@ class TinyGsmModem {
   }
   template <typename... Args>
   inline void sendAT(Args... cmd) {
-    thisModem().streamWrite("AT", cmd..., thisModem().gsmNL);
+    thisModem().streamWrite("AT", cmd..., GSM_NL);
     thisModem().stream.flush();
     TINY_GSM_YIELD(); /* DBG("### AT:", cmd...); */
   }

From f1f924fef1c0c2a3c3e071c7942927579386de2f Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 11 Apr 2024 16:16:25 -0400
Subject: [PATCH 037/100] Moved bulk of WaitResponse to modem template and gave
 modems handleURCs fxn

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .gitignore                        |   1 +
 src/TinyGsmClientA6.h             | 132 +++++----------------
 src/TinyGsmClientBG96.h           | 120 ++++---------------
 src/TinyGsmClientESP8266.h        | 152 +++++++++---------------
 src/TinyGsmClientM590.h           | 134 +++++----------------
 src/TinyGsmClientM95.h            | 132 +++++----------------
 src/TinyGsmClientMC60.h           | 152 ++++++------------------
 src/TinyGsmClientSIM5360.h        | 154 ++++++------------------
 src/TinyGsmClientSIM7000.h        | 189 +++++++++---------------------
 src/TinyGsmClientSIM7000SSL.h     | 182 +++++++++-------------------
 src/TinyGsmClientSIM7080.h        | 182 +++++++++-------------------
 src/TinyGsmClientSIM70xx.h        |  44 +------
 src/TinyGsmClientSIM7600.h        | 154 ++++++------------------
 src/TinyGsmClientSIM800.h         | 180 +++++++++-------------------
 src/TinyGsmClientSaraR4.h         | 136 +++++----------------
 src/TinyGsmClientSequansMonarch.h | 124 ++++----------------
 src/TinyGsmClientUBLOX.h          | 117 +++---------------
 src/TinyGsmClientXBee.h           | 146 +++++++----------------
 src/TinyGsmModem.tpp              | 108 +++++++++++++++++
 src/TinyGsmTCP.tpp                |   8 +-
 20 files changed, 714 insertions(+), 1833 deletions(-)

diff --git a/.gitignore b/.gitignore
index 2b40655..fb559b6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,3 +47,4 @@ extras/At Command Manuals - Unsupported/*
 filters/*
 platformio_extra_envs.ini
 *.tar.gz
+pioScripts/generate_compile_commands.py
diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index d6959fa..008e127 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -451,115 +451,37 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+CIPRCV:"))) {
-          int8_t  mux      = streamGetIntBefore(',');
-          int16_t len      = streamGetIntBefore(',');
-          int16_t len_orig = len;
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            if (len > sockets[mux]->rx.free()) {
-              DBG("### Buffer overflow: ", len, "->", sockets[mux]->rx.free());
-            } else {
-              DBG("### Got: ", len, "->", sockets[mux]->rx.free());
-            }
-            while (len--) { moveCharFromStreamToFifo(mux); }
-            // TODO(?) Deal with missing characters
-            if (len_orig > sockets[mux]->available()) {
-              DBG("### Fewer characters received than expected: ",
-                  sockets[mux]->available(), " vs ", len_orig);
-            }
-          }
-          data = "";
-        } else if (data.endsWith(GF("+TCPCLOSED:"))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+CIPRCV:"))) {
+      int8_t  mux      = streamGetIntBefore(',');
+      int16_t len      = streamGetIntBefore(',');
+      int16_t len_orig = len;
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        if (len > sockets[mux]->rx.free()) {
+          DBG("### Buffer overflow: ", len, "->", sockets[mux]->rx.free());
+          // reset the len to read to the amount free
+          len = sockets[mux]->rx.free();
+        }
+        while (len--) { moveCharFromStreamToFifo(mux); }
+        // TODO(?) Deal with missing characters
+        if (len_orig != sockets[mux]->available()) {
+          DBG("### Different number of characters received than expected: ",
+              sockets[mux]->available(), " vs ", len_orig);
         }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      DBG("### Got Data: ", len_orig, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+TCPCLOSED:"))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index b5c4536..4b3b334 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -603,110 +603,30 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+QIURC:"))) {
-          streamSkipUntil('\"');
-          String urc = stream.readStringUntil('\"');
-          streamSkipUntil(',');
-          if (urc == "recv") {
-            int8_t mux = streamGetIntBefore('\n');
-            DBG("### URC RECV:", mux);
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->got_data = true;
-            }
-          } else if (urc == "closed") {
-            int8_t mux = streamGetIntBefore('\n');
-            DBG("### URC CLOSE:", mux);
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->sock_connected = false;
-            }
-          } else {
-            streamSkipUntil('\n');
-          }
-          data = "";
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+QIURC:"))) {
+      streamSkipUntil('\"');
+      String urc = stream.readStringUntil('\"');
+      streamSkipUntil(',');
+      if (urc == "recv") {
+        int8_t mux = streamGetIntBefore('\n');
+        DBG("### URC RECV:", mux);
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->got_data = true;
         }
+      } else if (urc == "closed") {
+        int8_t mux = streamGetIntBefore('\n');
+        DBG("### URC CLOSE:", mux);
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->sock_connected = false;
+        }
+      } else {
+        streamSkipUntil('\n');
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index e0ee341..ff998f8 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -24,16 +24,20 @@
 static uint8_t TINY_GSM_TCP_KEEP_ALIVE = 120;
 
 // <stat> status of ESP8266 station interface
+// 0: ESP8266 station is not initialized.
+// 1: ESP8266 station is initialized, but not started a Wi-Fi connection yet.
 // 2 : ESP8266 station connected to an AP and has obtained IP
 // 3 : ESP8266 station created a TCP or UDP transmission
 // 4 : the TCP or UDP transmission of ESP8266 station disconnected
 // 5 : ESP8266 station did NOT connect to an AP
 enum RegStatus {
-  REG_OK_IP     = 2,
-  REG_OK_TCP    = 3,
-  REG_OK_NO_TCP = 4,
-  REG_DENIED    = 5,
-  REG_UNKNOWN   = 6,
+  REG_UNINITIALIZED = 0,
+  REG_UNREGISTERED  = 1,
+  REG_OK_IP         = 2,
+  REG_OK_TCP        = 3,
+  REG_OK_NO_TCP     = 4,
+  REG_DENIED        = 5,
+  REG_UNKNOWN       = 6,
 };
 
 class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
@@ -221,9 +225,14 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
   RegStatus getRegistrationStatus() {
     sendAT(GF("+CIPSTATUS"));
     if (waitResponse(3000, GF("STATUS:")) != 1) return REG_UNKNOWN;
-    int8_t status = waitResponse(GFP(GSM_ERROR), GF("2"), GF("3"), GF("4"),
-                                 GF("5"));
-    waitResponse();  // Returns an OK after the status
+    // after "STATUS:" it should return the status number (0,1,2,3,4,5),
+    // followed by an OK
+    // Since there are more possible status number codes than the arguments for
+    // waitResponse, we'll capture the response in a string and then parse it.
+    String res;
+    if (waitResponse(3000L, res) != 1) { return REG_UNKNOWN; }
+    res.trim();
+    int8_t status = res.toInt();
     return (RegStatus)status;
   }
 
@@ -342,11 +351,12 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
   bool modemGetConnected(uint8_t mux) {
     sendAT(GF("+CIPSTATUS"));
     if (waitResponse(3000, GF("STATUS:")) != 1) { return false; }
-    int8_t status = waitResponse(GFP(GSM_ERROR), GF("2"), GF("3"), GF("4"),
-                                 GF("5"));
-    if (status != 3) {
-      // if the status is anything but 3, there are no connections open
-      waitResponse();  // Returns an OK after the status
+    // after "STATUS:" it should return the status number (0,1,2,3,4,5),
+    // followed by an OK
+    // Hopefully we'll catch the "3" here, but fall back to the OK or Error
+    int8_t status = waitResponse(GF("3"), GFP(GSM_OK), GFP(GSM_ERROR));
+    // if the status is anything but 3, there are no connections open
+    if (status != 1) {
       for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
         if (sockets[muxNo]) { sockets[muxNo]->sock_connected = false; }
       }
@@ -380,96 +390,40 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+IPD,"))) {
-          int8_t  mux      = streamGetIntBefore(',');
-          int16_t len      = streamGetIntBefore(':');
-          int16_t len_orig = len;
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            if (len > sockets[mux]->rx.free()) {
-              DBG("### Buffer overflow: ", len, "received vs",
-                  sockets[mux]->rx.free(), "available");
-            } else {
-              // DBG("### Got Data: ", len, "on", mux);
-            }
-            while (len--) { moveCharFromStreamToFifo(mux); }
-            // TODO(SRGDamia1): deal with buffer overflow/missed characters
-            if (len_orig > sockets[mux]->available()) {
-              DBG("### Fewer characters received than expected: ",
-                  sockets[mux]->available(), " vs ", len_orig);
-            }
-          }
-          data = "";
-        } else if (data.endsWith(GF("CLOSED"))) {
-          int8_t muxStart =
-              TinyGsmMax(0, data.lastIndexOf(GSM_NL, data.length() - 8));
-          int8_t coma = data.indexOf(',', muxStart);
-          int8_t mux  = data.substring(muxStart, coma).toInt();
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+IPD,"))) {
+      int8_t  mux      = streamGetIntBefore(',');
+      int16_t len      = streamGetIntBefore(':');
+      int16_t len_orig = len;
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        if (len > sockets[mux]->rx.free()) {
+          DBG("### Buffer overflow: ", len, "->", sockets[mux]->rx.free());
+          // reset the len to read to the amount free
+          len = sockets[mux]->rx.free();
+        }
+        while (len--) { moveCharFromStreamToFifo(mux); }
+        // TODO(SRGDamia1): deal with buffer overflow/missed characters
+        if (len_orig != sockets[mux]->available()) {
+          DBG("### Different number of characters received than expected: ",
+              sockets[mux]->available(), " vs ", len_orig);
         }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      DBG("### Got Data: ", len_orig, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("CLOSED"))) {
+      int8_t muxStart = TinyGsmMax(0,
+                                   data.lastIndexOf(GSM_NL, data.length() - 8));
+      int8_t coma     = data.indexOf(',', muxStart);
+      int8_t mux      = data.substring(muxStart, coma).toInt();
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index f89500d..46041bd 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -343,116 +343,38 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+TCPRECV:"))) {
-          int8_t  mux      = streamGetIntBefore(',');
-          int16_t len      = streamGetIntBefore(',');
-          int16_t len_orig = len;
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            if (len > sockets[mux]->rx.free()) {
-              DBG("### Buffer overflow: ", len, "->", sockets[mux]->rx.free());
-            } else {
-              DBG("### Got: ", len, "->", sockets[mux]->rx.free());
-            }
-            while (len--) { moveCharFromStreamToFifo(mux); }
-            // TODO(?): Handle lost characters
-            if (len_orig > sockets[mux]->available()) {
-              DBG("### Fewer characters received than expected: ",
-                  sockets[mux]->available(), " vs ", len_orig);
-            }
-          }
-          data = "";
-        } else if (data.endsWith(GF("+TCPCLOSE:"))) {
-          int8_t mux = streamGetIntBefore(',');
-          streamSkipUntil('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+TCPRECV:"))) {
+      int8_t  mux      = streamGetIntBefore(',');
+      int16_t len      = streamGetIntBefore(',');
+      int16_t len_orig = len;
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        if (len > sockets[mux]->rx.free()) {
+          DBG("### Buffer overflow: ", len, "->", sockets[mux]->rx.free());
+          // reset the len to read to the amount free
+          len = sockets[mux]->rx.free();
+        }
+        while (len--) { moveCharFromStreamToFifo(mux); }
+        // TODO(?): Handle lost characters
+        if (len_orig != sockets[mux]->available()) {
+          DBG("### Different number of characters received than expected: ",
+              sockets[mux]->available(), " vs ", len_orig);
         }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      DBG("### Got Data: ", len_orig, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+TCPCLOSE:"))) {
+      int8_t mux = streamGetIntBefore(',');
+      streamSkipUntil('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 0a902e9..e66c731 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -508,114 +508,36 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+QIRDI:"))) {
-          streamSkipUntil(',');  // Skip the context
-          streamSkipUntil(',');  // Skip the role
-          int8_t mux = streamGetIntBefore('\n');
-          // DBG("### Got Data:", mux);
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            // We have no way of knowing how much data actually came in, so
-            // we set the value to 1500, the maximum possible size.
-            sockets[mux]->sock_available = 1500;
-          }
-          data = "";
-        } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-          int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
-          int8_t coma = data.indexOf(',', nl + 2);
-          int8_t mux  = data.substring(nl + 2, coma).toInt();
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
-        } else if (data.endsWith(GF("+QNITZ:"))) {
-          streamSkipUntil('\n');  // URC for time sync
-          data = "";
-          DBG("### Network time updated.");
-        }
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+QIRDI:"))) {
+      streamSkipUntil(',');  // Skip the context
+      streamSkipUntil(',');  // Skip the role
+      int8_t mux = streamGetIntBefore('\n');
+      // DBG("### Got Data:", mux);
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        // We have no way of knowing how much data actually came in, so
+        // we set the value to 1500, the maximum possible size.
+        sockets[mux]->sock_available = 1500;
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      return true;
+    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
+      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+      int8_t coma = data.indexOf(',', nl + 2);
+      int8_t mux  = data.substring(nl + 2, coma).toInt();
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("+QNITZ:"))) {
+      streamSkipUntil('\n');  // URC for time sync
+      data = "";
+      DBG("### Network time updated.");
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index f43e9b0..83353b5 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -481,127 +481,43 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    String r6s(r6); r6s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s, ",", r6s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (r6 && data.endsWith(r6)) {
-          index = 6;
-          goto finish;
-        } else if (data.endsWith(
-                       GF(GSM_NL "+QIRDI:"))) {  // TODO(?):  QIRD? or QIRDI?
-          // +QIRDI: <id>,<sc>,<sid>,<num>,<len>,< tlen>
-          streamSkipUntil(',');  // Skip the context
-          streamSkipUntil(',');  // Skip the role
-          // read the connection id
-          int8_t mux = streamGetIntBefore(',');
-          // read the number of packets in the buffer
-          int8_t num_packets = streamGetIntBefore(',');
-          // read the length of the current packet
-          streamSkipUntil(
-              ',');  // Skip the length of the current package in the buffer
-          int16_t len_total =
-              streamGetIntBefore('\n');  // Total length of all packages
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux] &&
-              num_packets >= 0 && len_total >= 0) {
-            sockets[mux]->sock_available = len_total;
-          }
-          data = "";
-          // DBG("### Got Data:", len_total, "on", mux);
-        } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-          int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
-          int8_t coma = data.indexOf(',', nl + 2);
-          int8_t mux  = data.substring(nl + 2, coma).toInt();
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
-        } else if (data.endsWith(GF("+QNITZ:"))) {
-          streamSkipUntil('\n');  // URC for time sync
-          DBG("### Network time updated.");
-          data = "";
-        }
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+QIRDI:"))) {  // TODO(?):  QIRD? or QIRDI?
+      // +QIRDI: <id>,<sc>,<sid>,<num>,<len>,< tlen>
+      streamSkipUntil(',');  // Skip the context
+      streamSkipUntil(',');  // Skip the role
+      // read the connection id
+      int8_t mux = streamGetIntBefore(',');
+      // read the number of packets in the buffer
+      int8_t num_packets = streamGetIntBefore(',');
+      // read the length of the current packet
+      streamSkipUntil(
+          ',');  // Skip the length of the current package in the buffer
+      int16_t len_total =
+          streamGetIntBefore('\n');  // Total length of all packages
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux] &&
+          num_packets >= 0 && len_total >= 0) {
+        sockets[mux]->sock_available = len_total;
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
+      data = "";
+      // DBG("### Got Data:", len_total, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
+      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+      int8_t coma = data.indexOf(',', nl + 2);
+      int8_t mux  = data.substring(nl + 2, coma).toInt();
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("+QNITZ:"))) {
+      streamSkipUntil('\n');  // URC for time sync
+      DBG("### Network time updated.");
       data = "";
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5, r6);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5, r6);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 8463a34..9d32bdc 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -602,125 +602,49 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
-          int8_t mode = streamGetIntBefore(',');
-          if (mode == 1) {
-            int8_t mux = streamGetIntBefore('\n');
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->got_data = true;
-            }
-            data = "";
-            // DBG("### Got Data:", mux);
-          } else {
-            data += mode;
-          }
-        } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          // DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("+IPCLOSE:"))) {
-          int8_t mux = streamGetIntBefore(',');
-          streamSkipUntil('\n');  // Skip the reason code
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
-        } else if (data.endsWith(GF("+CIPEVENT:"))) {
-          // Need to close all open sockets and release the network library.
-          // User will then need to reconnect.
-          DBG("### Network error!");
-          if (!isGprsConnected()) { gprsDisconnect(); }
-          data = "";
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+      int8_t mode = streamGetIntBefore(',');
+      if (mode == 1) {
+        int8_t mux = streamGetIntBefore('\n');
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->got_data = true;
         }
+        data = "";
+        // DBG("### Got Data:", mux);
+        return true;
+      } else {
+        data += mode;
+        return false;
+      }
+    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      // DBG("### Got Data:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+IPCLOSE:"))) {
+      int8_t mux = streamGetIntBefore(',');
+      streamSkipUntil('\n');  // Skip the reason code
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("+CIPEVENT:"))) {
+      // Need to close all open sockets and release the network library.
+      // User will then need to reconnect.
+      DBG("### Network error!");
+      if (!isGprsConnected()) { gprsDisconnect(); }
+      data = "";
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index e708845..a723a1c 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -390,141 +390,68 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
-          int8_t mode = streamGetIntBefore(',');
-          if (mode == 1) {
-            int8_t mux = streamGetIntBefore('\n');
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->got_data = true;
-            }
-            data = "";
-            // DBG("### Got Data:", mux);
-          } else {
-            data += mode;
-          }
-        } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          // DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-          int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
-          int8_t coma = data.indexOf(',', nl + 2);
-          int8_t mux  = data.substring(nl + 2, coma).toInt();
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
-        } else if (data.endsWith(GF("*PSNWID:"))) {
-          streamSkipUntil('\n');  // Refresh network name by network
-          data = "";
-          DBG("### Network name updated.");
-        } else if (data.endsWith(GF("*PSUTTZ:"))) {
-          streamSkipUntil('\n');  // Refresh time and time zone by network
-          data = "";
-          DBG("### Network time and time zone updated.");
-        } else if (data.endsWith(GF("+CTZV:"))) {
-          streamSkipUntil('\n');  // Refresh network time zone by network
-          data = "";
-          DBG("### Network time zone updated.");
-        } else if (data.endsWith(GF("DST: "))) {
-          streamSkipUntil(
-              '\n');  // Refresh Network Daylight Saving Time by network
-          data = "";
-          DBG("### Daylight savings time state updated.");
-        } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
-          data = "";
-          DBG("### Unexpected module reset!");
-          init();
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+      int8_t mode = streamGetIntBefore(',');
+      if (mode == 1) {
+        int8_t mux = streamGetIntBefore('\n');
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->got_data = true;
         }
+        data = "";
+        // DBG("### Got Data:", mux);
+        return true;
+      } else {
+        data += mode;
+        return false;
+      }
+    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      // DBG("### Got Data:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
+      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+      int8_t coma = data.indexOf(',', nl + 2);
+      int8_t mux  = data.substring(nl + 2, coma).toInt();
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("*PSNWID:"))) {
+      streamSkipUntil('\n');  // Refresh network name by network
+      data = "";
+      DBG("### Network name updated.");
+      return true;
+    } else if (data.endsWith(GF("*PSUTTZ:"))) {
+      streamSkipUntil('\n');  // Refresh time and time zone by network
+      data = "";
+      DBG("### Network time and time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("+CTZV:"))) {
+      streamSkipUntil('\n');  // Refresh network time zone by network
+      data = "";
+      DBG("### Network time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("DST: "))) {
+      streamSkipUntil('\n');  // Refresh Network Daylight Saving Time by network
+      data = "";
+      DBG("### Daylight savings time state updated.");
+      return true;
+    } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
+      data = "";
+      DBG("### Unexpected module reset!");
+      init();
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  protected:
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index 2f88e89..f9499a3 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -588,138 +588,64 @@ class TinyGsmSim7000SSL
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+CARECV:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("+CADATAIND:"))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-          }
-          data = "";
-          DBG("### Got Data:", mux);
-        } else if (data.endsWith(GF("+CASTATE:"))) {
-          int8_t mux   = streamGetIntBefore(',');
-          int8_t state = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            if (state != 1) {
-              sockets[mux]->sock_connected = false;
-              DBG("### Closed: ", mux);
-            }
-          }
-          data = "";
-        } else if (data.endsWith(GF("*PSNWID:"))) {
-          streamSkipUntil('\n');  // Refresh network name by network
-          data = "";
-          DBG("### Network name updated.");
-        } else if (data.endsWith(GF("*PSUTTZ:"))) {
-          streamSkipUntil('\n');  // Refresh time and time zone by network
-          data = "";
-          DBG("### Network time and time zone updated.");
-        } else if (data.endsWith(GF("+CTZV:"))) {
-          streamSkipUntil('\n');  // Refresh network time zone by network
-          data = "";
-          DBG("### Network time zone updated.");
-        } else if (data.endsWith(GF("DST: "))) {
-          streamSkipUntil(
-              '\n');  // Refresh Network Daylight Saving Time by network
-          data = "";
-          DBG("### Daylight savings time state updated.");
-        } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
-          data = "";
-          DBG("### Unexpected module reset!");
-          init();
-          data = "";
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+CARECV:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
+      }
+      data = "";
+      DBG("### Got Data:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+CADATAIND:"))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+      }
+      data = "";
+      DBG("### Got Data:", mux);
+      return true;
+    } else if (data.endsWith(GF("+CASTATE:"))) {
+      int8_t mux   = streamGetIntBefore(',');
+      int8_t state = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        if (state != 1) {
+          sockets[mux]->sock_connected = false;
+          DBG("### Closed: ", mux);
         }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      return true;
+    } else if (data.endsWith(GF("*PSNWID:"))) {
+      streamSkipUntil('\n');  // Refresh network name by network
+      data = "";
+      DBG("### Network name updated.");
+      return true;
+    } else if (data.endsWith(GF("*PSUTTZ:"))) {
+      streamSkipUntil('\n');  // Refresh time and time zone by network
+      data = "";
+      DBG("### Network time and time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("+CTZV:"))) {
+      streamSkipUntil('\n');  // Refresh network time zone by network
+      data = "";
+      DBG("### Network time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("DST: "))) {
+      streamSkipUntil('\n');  // Refresh Network Daylight Saving Time by network
+      data = "";
+      DBG("### Daylight savings time state updated.");
+      return true;
+    } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
+      data = "";
+      DBG("### Unexpected module reset!");
+      init();
+      data = "";
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  protected:
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index f5584a9..a0638ad 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -587,138 +587,64 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+CARECV:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("+CADATAIND:"))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-          }
-          data = "";
-          DBG("### Got Data:", mux);
-        } else if (data.endsWith(GF("+CASTATE:"))) {
-          int8_t mux   = streamGetIntBefore(',');
-          int8_t state = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            if (state != 1) {
-              sockets[mux]->sock_connected = false;
-              DBG("### Closed: ", mux);
-            }
-          }
-          data = "";
-        } else if (data.endsWith(GF("*PSNWID:"))) {
-          streamSkipUntil('\n');  // Refresh network name by network
-          data = "";
-          DBG("### Network name updated.");
-        } else if (data.endsWith(GF("*PSUTTZ:"))) {
-          streamSkipUntil('\n');  // Refresh time and time zone by network
-          data = "";
-          DBG("### Network time and time zone updated.");
-        } else if (data.endsWith(GF("+CTZV:"))) {
-          streamSkipUntil('\n');  // Refresh network time zone by network
-          data = "";
-          DBG("### Network time zone updated.");
-        } else if (data.endsWith(GF("DST: "))) {
-          streamSkipUntil(
-              '\n');  // Refresh Network Daylight Saving Time by network
-          data = "";
-          DBG("### Daylight savings time state updated.");
-        } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
-          data = "";
-          DBG("### Unexpected module reset!");
-          init();
-          data = "";
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+CARECV:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
+      }
+      data = "";
+      DBG("### Got Data:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+CADATAIND:"))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+      }
+      data = "";
+      DBG("### Got Data:", mux);
+      return true;
+    } else if (data.endsWith(GF("+CASTATE:"))) {
+      int8_t mux   = streamGetIntBefore(',');
+      int8_t state = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        if (state != 1) {
+          sockets[mux]->sock_connected = false;
+          DBG("### Closed: ", mux);
         }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      return true;
+    } else if (data.endsWith(GF("*PSNWID:"))) {
+      streamSkipUntil('\n');  // Refresh network name by network
+      data = "";
+      DBG("### Network name updated.");
+      return true;
+    } else if (data.endsWith(GF("*PSUTTZ:"))) {
+      streamSkipUntil('\n');  // Refresh time and time zone by network
+      data = "";
+      DBG("### Network time and time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("+CTZV:"))) {
+      streamSkipUntil('\n');  // Refresh network time zone by network
+      data = "";
+      DBG("### Network time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("DST: "))) {
+      streamSkipUntil('\n');  // Refresh Network Daylight Saving Time by network
+      data = "";
+      DBG("### Daylight savings time state updated.");
+      return true;
+    } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
+      data = "";
+      DBG("### Unexpected module reset!");
+      init();
+      data = "";
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  protected:
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index b672b76..31702fa 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -398,48 +398,8 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
    * Client related functions
    */
   // should implement in sub-classes
-
-  /*
-   * Utilities
-   */
- public:
-  // should implement in sub-classes
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return thisModem().waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return thisModem().waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return thisModem().waitResponse(1000, r1, r2, r3, r4, r5);
+  bool handleURCs(String& data) {
+    return thisModem().handleURCs(data);
   }
 
  public:
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 1b75871..50ee85a 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -727,125 +727,49 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
-          int8_t mode = streamGetIntBefore(',');
-          if (mode == 1) {
-            int8_t mux = streamGetIntBefore('\n');
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->got_data = true;
-            }
-            data = "";
-            // DBG("### Got Data:", mux);
-          } else {
-            data += mode;
-          }
-        } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          // DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("+IPCLOSE:"))) {
-          int8_t mux = streamGetIntBefore(',');
-          streamSkipUntil('\n');  // Skip the reason code
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
-        } else if (data.endsWith(GF("+CIPEVENT:"))) {
-          // Need to close all open sockets and release the network library.
-          // User will then need to reconnect.
-          DBG("### Network error!");
-          if (!isGprsConnected()) { gprsDisconnect(); }
-          data = "";
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+      int8_t mode = streamGetIntBefore(',');
+      if (mode == 1) {
+        int8_t mux = streamGetIntBefore('\n');
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->got_data = true;
         }
+        data = "";
+        // DBG("### Got Data:", mux);
+        return true;
+      } else {
+        data += mode;
+        return false;
+      }
+    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      // DBG("### Got Data:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+IPCLOSE:"))) {
+      int8_t mux = streamGetIntBefore(',');
+      streamSkipUntil('\n');  // Skip the reason code
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("+CIPEVENT:"))) {
+      // Need to close all open sockets and release the network library.
+      // User will then need to reconnect.
+      DBG("### Network error!");
+      if (!isGprsConnected()) { gprsDisconnect(); }
+      data = "";
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 9147d14..1e31e21 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -620,137 +620,63 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
-          int8_t mode = streamGetIntBefore(',');
-          if (mode == 1) {
-            int8_t mux = streamGetIntBefore('\n');
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->got_data = true;
-            }
-            data = "";
-            // DBG("### Got Data:", mux);
-          } else {
-            data += mode;
-          }
-        } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          // DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-          int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
-          int8_t coma = data.indexOf(',', nl + 2);
-          int8_t mux  = data.substring(nl + 2, coma).toInt();
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### Closed: ", mux);
-        } else if (data.endsWith(GF("*PSNWID:"))) {
-          streamSkipUntil('\n');  // Refresh network name by network
-          data = "";
-          DBG("### Network name updated.");
-        } else if (data.endsWith(GF("*PSUTTZ:"))) {
-          streamSkipUntil('\n');  // Refresh time and time zone by network
-          data = "";
-          DBG("### Network time and time zone updated.");
-        } else if (data.endsWith(GF("+CTZV:"))) {
-          streamSkipUntil('\n');  // Refresh network time zone by network
-          data = "";
-          DBG("### Network time zone updated.");
-        } else if (data.endsWith(GF("DST:"))) {
-          streamSkipUntil(
-              '\n');  // Refresh Network Daylight Saving Time by network
-          data = "";
-          DBG("### Daylight savings time state updated.");
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+      int8_t mode = streamGetIntBefore(',');
+      if (mode == 1) {
+        int8_t mux = streamGetIntBefore('\n');
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->got_data = true;
         }
+        data = "";
+        // DBG("### Got Data:", mux);
+        return true;
+      } else {
+        data += mode;
+        return false;
+      }
+    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      // DBG("### Got Data:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
+      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+      int8_t coma = data.indexOf(',', nl + 2);
+      int8_t mux  = data.substring(nl + 2, coma).toInt();
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("*PSNWID:"))) {
+      streamSkipUntil('\n');  // Refresh network name by network
+      data = "";
+      DBG("### Network name updated.");
+      return true;
+    } else if (data.endsWith(GF("*PSUTTZ:"))) {
+      streamSkipUntil('\n');  // Refresh time and time zone by network
+      data = "";
+      DBG("### Network time and time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("+CTZV:"))) {
+      streamSkipUntil('\n');  // Refresh network time zone by network
+      data = "";
+      DBG("### Network time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("DST:"))) {
+      streamSkipUntil('\n');  // Refresh Network Daylight Saving Time by network
+      data = "";
+      DBG("### Daylight savings time state updated.");
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index fe23218..bc333ed 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -768,116 +768,38 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+UUSORD:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            // max size is 1024
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          DBG("### URC Data Received:", len, "on", mux);
-        } else if (data.endsWith(GF("+UUSOCL:"))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### URC Sock Closed: ", mux);
-        } else if (data.endsWith(GF("+UUSOCO:"))) {
-          int8_t mux          = streamGetIntBefore('\n');
-          int8_t socket_error = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux] &&
-              socket_error == 0) {
-            sockets[mux]->sock_connected = true;
-          }
-          data = "";
-          DBG("### URC Sock Opened: ", mux);
-        }
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+UUSORD:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        // max size is 1024
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      DBG("### URC Data Received:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+UUSOCL:"))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### URC Sock Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("+UUSOCO:"))) {
+      int8_t mux          = streamGetIntBefore('\n');
+      int8_t socket_error = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux] &&
+          socket_error == 0) {
+        sockets[mux]->sock_connected = true;
+      }
+      data = "";
+      DBG("### URC Sock Opened: ", mux);
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 694733a..944876e 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -503,9 +503,10 @@ class TinyGsmSequansMonarch
     waitResponse(10000L, GF(GSM_NL "> "));
     // Translate bytes into char to be able to send them as an hex string
     char char_command[2];
-    for (size_t i=0; i<len; i++) {
+    for (size_t i = 0; i < len; i++) {
       memset(&char_command, 0, sizeof(char_command));
-      sprintf(&char_command[0], "%02X", reinterpret_cast<const uint8_t*>(buff)[i]);
+      sprintf(&char_command[0], "%02X",
+              reinterpret_cast<const uint8_t*>(buff)[i]);
       stream.write(char_command, sizeof(char_command));
     }
     stream.flush();
@@ -610,108 +611,29 @@ class TinyGsmSequansMonarch
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+SQNSRING:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT &&
-              sockets[mux % TINY_GSM_MUX_COUNT]) {
-            sockets[mux % TINY_GSM_MUX_COUNT]->got_data       = true;
-            sockets[mux % TINY_GSM_MUX_COUNT]->sock_available = len;
-          }
-          data = "";
-          DBG("### URC Data Received:", len, "on", mux);
-        } else if (data.endsWith(GF("SQNSH: "))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT &&
-              sockets[mux % TINY_GSM_MUX_COUNT]) {
-            sockets[mux % TINY_GSM_MUX_COUNT]->sock_connected = false;
-          }
-          data = "";
-          DBG("### URC Sock Closed: ", mux);
-        }
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(GSM_NL "+SQNSRING:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT &&
+          sockets[mux % TINY_GSM_MUX_COUNT]) {
+        sockets[mux % TINY_GSM_MUX_COUNT]->got_data       = true;
+        sockets[mux % TINY_GSM_MUX_COUNT]->sock_available = len;
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      DBG("### URC Data Received:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("SQNSH: "))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT &&
+          sockets[mux % TINY_GSM_MUX_COUNT]) {
+        sockets[mux % TINY_GSM_MUX_COUNT]->sock_connected = false;
+      }
+      data = "";
+      DBG("### URC Sock Closed: ", mux);
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index 1250da4..0fb09e5 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -733,107 +733,28 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+UUSORD:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            // max size is 1024
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          // DBG("### URC Data Received:", len, "on", mux);
-        } else if (data.endsWith(GF("+UUSOCL:"))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### URC Sock Closed: ", mux);
-        }
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+UUSORD:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        // max size is 1024
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      // DBG("### URC Data Received:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+UUSOCL:"))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### URC Sock Closed: ", mux);
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 8a15447..7b68bbd 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -828,7 +828,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         changesMade = true;
       }
     } else {
-      changesMade |= changeSettingIfNeeded(GF("EE"), 0x0);  // Set No security
+      changesMade |= changeSettingIfNeeded(GF("EE"),
+                                           0x0);  // Set No security
     }
 
     if (changesMade) { retVal &= writeChanges(); }
@@ -878,7 +879,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         changesMade = true;
       }
     }
-    changesMade |= changeSettingIfNeeded(GF("AN"), String(apn));  // Set the APN
+    changesMade |= changeSettingIfNeeded(GF("AN"),
+                                         String(apn));  // Set the APN
 
     changesMade |= changeSettingIfNeeded(GF("AM"), 0x0,
                                          5000L);  // Airplane mode off
@@ -1029,9 +1031,9 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         0,
     };
     res.toCharArray(buf, 5);
-    int8_t intRes = (int8_t)strtol(
-        buf, 0,
-        16);  // degrees Celsius displayed in 8-bit two's complement format.
+    int8_t intRes = (int8_t)strtol(buf, 0,
+                                   16);  // degrees Celsius displayed in
+                                         // 8-bit two's complement format.
     XBEE_COMMAND_END_DECORATOR
     return static_cast<float>(intRes);
   }
@@ -1072,9 +1074,9 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     uint32_t timeout_ms  = ((uint32_t)timeout_s) * 1000;
     bool     gotIP       = false;
     XBEE_COMMAND_START_DECORATOR(5, IPAddress(0, 0, 0, 0))
-    // XBee's require a numeric IP address for connection, but do provide the
-    // functionality to look up the IP address from a fully qualified domain
-    // name
+    // XBee's require a numeric IP address for connection, but do provide
+    // the functionality to look up the IP address from a fully qualified
+    // domain name
     // NOTE: the lookup can take a while
     while ((millis() - startMillis) < timeout_ms) {
       sendAT(GF("LA"), host);
@@ -1104,8 +1106,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     bool retVal = false;
     XBEE_COMMAND_START_DECORATOR(5, false)
 
-    // If this is a new host name, replace the saved host and wipe out the saved
-    // host IP
+    // If this is a new host name, replace the saved host and wipe out the
+    // saved host IP
     if (this->savedHost != String(host)) {
       this->savedHost = String(host);
       savedHostIP     = IPAddress(0, 0, 0, 0);
@@ -1175,7 +1177,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
       if (changesMade) { success &= writeChanges(); }
     }
 
-    // confirm the XBee type if needed so we know if we can know if connected
+    // confirm the XBee type if needed so we know if we can know if
+    // connected
     if (beeType == XBEE_UNKNOWN) { getSeries(); }
     // we'll accept either unknown or connected
     if (beeType != XBEE_S6B_WIFI) {
@@ -1205,9 +1208,10 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
       sendAT(GF("TM"));
       String timeoutUsed = readResponseString(5000L);
 
-      // For cellular models, per documentation: If you write the TM (socket
-      // timeout) value while in Transparent Mode, the current connection is
-      // immediately closed - this works even if the TM values is unchanged
+      // For cellular models, per documentation: If you write the TM
+      // (socket timeout) value while in Transparent Mode, the current
+      // connection is immediately closed - this works even if the TM
+      // values is unchanged
       sendAT(GF("TM"), timeoutUsed);  // Re-set socket timeout
       waitResponse(maxWaitMs);        // This response can be slow
     }
@@ -1229,7 +1233,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         modemGetConnected(0);
       } else if (len > 5) {
         // After sending several characters, also re-check
-        // NOTE:  I'm intentionally not checking after every single character!
+        // NOTE:  I'm intentionally not checking after every single
+        // character!
         modemGetConnected(0);
       }
     }
@@ -1237,10 +1242,11 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return len;
   }
 
-  // NOTE:  The CI command returns the status of the TCP connection as open only
-  // after data has been sent on the socket.  If it returns 0xFF the socket may
-  // really be open, but no data has yet been sent.  We return this unknown
-  // value as true so there's a possibility it's wrong.
+  // NOTE:  The CI command returns the status of the TCP connection as
+  // open only after data has been sent on the socket.  If it returns 0xFF
+  // the socket may really be open, but no data has yet been sent.  We
+  // return this unknown value as true so there's a possibility it's
+  // wrong.
   bool modemGetConnected(uint8_t) {
     // If the IP address is 0, it's not valid so we can't be connected
     if (savedIP == IPAddress(0, 0, 0, 0)) { return false; }
@@ -1281,11 +1287,12 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
           }
 
           // 0x28 = "Unknown."
-          // 0xFF = No known status - always returned prior to sending data
+          // 0xFF = No known status - always returned prior to sending
+          // data
           case 0x28:
           case 0xFF: {
-            // If we previously had an operating destination and we no longer
-            // do, the socket must have closed
+            // If we previously had an operating destination and we no
+            // longer do, the socket must have closed
             if (od == IPAddress(0, 0, 0, 0) &&
                 savedOperatingIP != IPAddress(0, 0, 0, 0)) {
               savedOperatingIP           = od;
@@ -1297,13 +1304,14 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
               sockets[0]->stop();
               return false;
             } else if (od != IPAddress(0, 0, 0, 0) && od == savedIP) {
-              // else if the operating destination exists and matches, we're
-              // good to go
+              // else if the operating destination exists and matches,
+              // we're good to go
               savedOperatingIP = od;
               return true;
             } else {
-              // If we never had an operating destination, then sock may be open
-              // but data never sent - this is the dreaded "we don't know"
+              // If we never had an operating destination, then sock may
+              // be open but data never sent - this is the dreaded "we
+              // don't know"
               savedOperatingIP = od;
               return true;
             }
@@ -1347,8 +1355,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
 
           // 0x02 = Invalid parameters (bad IP/host)
           // 0x12 = DNS query lookup failure
-          // 0x25 = Unknown server - DNS lookup failed (0x22 for UDP socket!)
-          // fall through
+          // 0x25 = Unknown server - DNS lookup failed (0x22 for UDP
+          // socket!) fall through
           case 0x02:
           case 0x12:
           case 0x25: {
@@ -1378,80 +1386,9 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
       TINY_GSM_YIELD();
     }
   }
-
-  // TODO(vshymanskyy): Optimize this!
-  // NOTE:  This function is used while INSIDE command mode, so we're only
-  // waiting for requested responses.  The XBee has no unsoliliced responses
-  // (URC's) when in command mode.
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(16);  // Should never be getting much here for the XBee
-    int8_t   index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        }
-      }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      data.replace(GSM_NL GSM_NL, GSM_NL);
-      data.replace(GSM_NL, "\r\n    ");
-      if (data.length()) {
-        DBG("### Unhandled:", data, "\r\n");
-      } else {
-        DBG("### NO RESPONSE FROM MODEM!\r\n");
-      }
-    } else {
-      data.trim();
-      data.replace(GSM_NL GSM_NL, GSM_NL);
-      data.replace(GSM_NL, "\r\n    ");
-    }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+  // The XBee has no unsoliliced responses (URC's) when in command mode.
+  bool handleURCs(String& data) {
+    return true;
   }
 
   bool commandMode(uint8_t retries = 5) {
@@ -1467,8 +1404,9 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     streamClear();  // Empty everything in the buffer before starting
 
     while (!success && triesMade < retries) {
-      // Cannot send anything for 1 "guard time" before entering command mode
-      // Default guard time is 1s, but the init fxn decreases it to 100 ms
+      // Cannot send anything for 1 "guard time" before entering command
+      // mode Default guard time is 1s, but the init fxn decreases it to
+      // 100 ms
       delay(guardTime + 10);
       streamWrite(GF("+++"));  // enter command mode
 
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index e909cae..d70b2e5 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -48,6 +48,48 @@ class TinyGsmModem {
   bool testAT(uint32_t timeout_ms = 10000L) {
     return thisModem().testATImpl(timeout_ms);
   }
+  // Listen for responses to commands and handle URCs
+  int8_t waitResponse(uint32_t timeout_ms, String& data,
+                      GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
+                      GsmConstStr r7 = NULL) {
+    return thisModem().waitResponseImpl(timeout_ms, data, r1, r2, r3, r4, r5,
+                                        r6, r7);
+  }
+
+  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
+                      GsmConstStr r7 = NULL) {
+    String data;
+    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5, r6, r7);
+  }
+
+  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
+                      GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
+                      GsmConstStr r7 = NULL) {
+    return waitResponse(1000L, r1, r2, r3, r4, r5, r6, r7);
+  }
 
   // Asks for modem information via the V.25TER standard ATI command
   // NOTE:  The actual value and style of the response is quite varied
@@ -132,6 +174,72 @@ class TinyGsmModem {
     return false;
   }
 
+
+  // TODO(vshymanskyy): Optimize this!
+  int8_t waitResponseImpl(uint32_t timeout_ms, String& data,
+                          GsmConstStr r1 = GFP(GSM_OK),
+                          GsmConstStr r2 = GFP(GSM_ERROR),
+#if defined TINY_GSM_DEBUG
+                          GsmConstStr r3 = GFP(GSM_CME_ERROR),
+                          GsmConstStr r4 = GFP(GSM_CMS_ERROR),
+#else
+                          GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
+#endif
+                          GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
+                          GsmConstStr r7 = NULL) {
+    data.reserve(64);
+    uint8_t  index       = 0;
+    uint32_t startMillis = millis();
+    do {
+      TINY_GSM_YIELD();
+      while (thisModem().stream.available() > 0) {
+        TINY_GSM_YIELD();
+        int8_t a = thisModem().stream.read();
+        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
+        data += static_cast<char>(a);
+        if (r1 && data.endsWith(r1)) {
+          index = 1;
+          goto finish;
+        } else if (r2 && data.endsWith(r2)) {
+          index = 2;
+          goto finish;
+        } else if (r3 && data.endsWith(r3)) {
+#if defined TINY_GSM_DEBUG
+          if (r3 == GFP(GSM_CME_ERROR)) {
+            streamSkipUntil('\n');  // Read out the error
+          }
+#endif
+          index = 3;
+          goto finish;
+        } else if (r4 && data.endsWith(r4)) {
+          index = 4;
+          goto finish;
+        } else if (r5 && data.endsWith(r5)) {
+          index = 5;
+          goto finish;
+        } else if (r6 && data.endsWith(r6)) {
+          index = 6;
+          goto finish;
+        } else if (r7 && data.endsWith(r7)) {
+          index = 7;
+          goto finish;
+        } else if (thisModem().handleURCs(data)) {
+          data = "";
+        }
+      }
+    } while (millis() - startMillis < timeout_ms);
+  finish:
+    if (!index) {
+      data.trim();
+      if (data.length()) { DBG("### Unhandled:", data); }
+      data = "";
+    }
+    // data.replace(AT_NL, "/");
+    // DBG('<', index, '>', data);
+    return index;
+  }
+
+
   String getModemInfoImpl() {
     thisModem().sendAT(GF("I"));
     String res;
diff --git a/src/TinyGsmTCP.tpp b/src/TinyGsmTCP.tpp
index 391d1fe..23e7fac 100644
--- a/src/TinyGsmTCP.tpp
+++ b/src/TinyGsmTCP.tpp
@@ -241,9 +241,9 @@ class TinyGsmTCP {
       return -1;
     }
 
-	int peek() override {
-		return (uint8_t)rx.peek();
-	}
+    int peek() override {
+      return (uint8_t)rx.peek();
+    }
 
     void flush() override {
       at->stream.flush();
@@ -345,7 +345,7 @@ class TinyGsmTCP {
 
   // Yields up to a time-out period and then reads a character from the stream
   // into the mux FIFO
-  // TODO(SRGDamia1):  Do we need to wait two _timeout periods for no
+  // TODO(SRGDamia1):  Do we really need to wait _two_ timeout periods for no
   // character return?  Will wait once in the first "while
   // !stream.available()" and then will wait again in the stream.read()
   // function.

From 640158a344dbaf9477b373511d04d4459226b7dc Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 10 May 2024 10:19:43 -0400
Subject: [PATCH 038/100] Fix fall through marker

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientXBee.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 7b68bbd..dfae481 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -1356,7 +1356,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
           // 0x02 = Invalid parameters (bad IP/host)
           // 0x12 = DNS query lookup failure
           // 0x25 = Unknown server - DNS lookup failed (0x22 for UDP
-          // socket!) fall through
+          // socket!)
+          // fall through
           case 0x02:
           case 0x12:
           case 0x25: {

From 1a6f36d66d29bc6f2f0fde9c02118ee63cd81402 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 13 May 2024 12:12:03 -0400
Subject: [PATCH 039/100] Undef GSM_NL

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h             | 3 +++
 src/TinyGsmClientBG96.h           | 3 +++
 src/TinyGsmClientESP8266.h        | 3 +++
 src/TinyGsmClientM590.h           | 3 +++
 src/TinyGsmClientM95.h            | 3 +++
 src/TinyGsmClientMC60.h           | 3 +++
 src/TinyGsmClientSIM5360.h        | 3 +++
 src/TinyGsmClientSIM70xx.h        | 3 +++
 src/TinyGsmClientSIM7600.h        | 3 +++
 src/TinyGsmClientSIM800.h         | 3 +++
 src/TinyGsmClientSaraR4.h         | 3 +++
 src/TinyGsmClientSequansMonarch.h | 3 +++
 src/TinyGsmClientUBLOX.h          | 3 +++
 src/TinyGsmClientXBee.h           | 5 ++++-
 src/TinyGsmModem.tpp              | 3 +++
 15 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index 008e127..f617a7c 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 8
 #define TINY_GSM_NO_MODEM_BUFFER
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 4b3b334..b6057ec 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 12
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index ff998f8..590eb8d 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 5
 #define TINY_GSM_NO_MODEM_BUFFER
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmSSL.tpp"
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index 46041bd..fab9deb 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 2
 #define TINY_GSM_NO_MODEM_BUFFER
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index e66c731..5ea9d55 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -15,7 +15,10 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_NO_CHECK
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index 83353b5..f6a02df 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -17,7 +17,10 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_NO_CHECK
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 9d32bdc..212101e 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 31702fa..7d69df9 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -11,7 +11,10 @@
 
 // #define TINY_GSM_DEBUG Serial
 // #define TINY_GSM_USE_HEX
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 50ee85a..558e8ce 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 1e31e21..6727209 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -15,7 +15,10 @@
 
 #define TINY_GSM_MUX_COUNT 5
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index bc333ed..3d3b28d 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 7
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 944876e..7cf196b 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -13,7 +13,10 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmCalling.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index 0fb09e5..f729981 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -14,7 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 7
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index dfae481..9a386cd 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -20,7 +20,10 @@
 // XBee's have a default guard time of 1 second (1000ms, 10 extra for safety
 // here)
 #define TINY_GSM_XBEE_GUARD_TIME 1010
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r"  // NOTE:  define before including TinyGsmModem!
+#endif
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -1388,7 +1391,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     }
   }
   // The XBee has no unsoliliced responses (URC's) when in command mode.
-  bool handleURCs(String& data) {
+  bool handleURCs(String&) {
     return true;
   }
 
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index d70b2e5..7cf2c60 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -12,8 +12,11 @@
 #include "TinyGsmCommon.h"
 
 #ifndef GSM_NL
+#ifdef GSM_NL
+#undef GSM_NL
 #define GSM_NL "\r\n"
 #endif
+#endif
 
 static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
 static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;

From e80d9428c3eb7117c248fed03308096bba3e0a5b Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 13 May 2024 12:32:03 -0400
Subject: [PATCH 040/100] Fix XBee URC

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientXBee.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 9a386cd..4a28763 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -1392,7 +1392,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
   }
   // The XBee has no unsoliliced responses (URC's) when in command mode.
   bool handleURCs(String&) {
-    return true;
+    return false;
   }
 
   bool commandMode(uint8_t retries = 5) {

From 3e7e615ef22a33474f043582c344a0fe1b243aa4 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 13 May 2024 13:51:33 -0400
Subject: [PATCH 041/100] Clean verbose detection

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmModem.tpp | 94 +++++++++++++++++++++++---------------------
 1 file changed, 49 insertions(+), 45 deletions(-)

diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 7cf2c60..b0a06f7 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -12,18 +12,33 @@
 #include "TinyGsmCommon.h"
 
 #ifndef GSM_NL
-#ifdef GSM_NL
-#undef GSM_NL
 #define GSM_NL "\r\n"
 #endif
+
+#ifndef GSM_OK
+#define GSM_OK "OK"
 #endif
 
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
+#ifndef GSM_ERROR
+#define GSM_ERROR "ERROR"
+#endif
+
+#if defined TINY_GSM_DEBUG
+#ifndef GSM_VERBOSE
+#define GSM_VERBOSE "+CME ERROR:"
+#endif
+
+#ifndef GSM_VERBOSE_2
+#define GSM_VERBOSE_2 "+CMS ERROR:"
+#endif
+#endif
+
+static const char GSM_OK[] TINY_GSM_PROGMEM    = GSM_OK GSM_NL;
+static const char GSM_ERROR[] TINY_GSM_PROGMEM = GSM_ERROR GSM_NL;
 
 #if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
+static const char GSM_VERBOSE[] TINY_GSM_PROGMEM   = GSM_VERBOSE;
+static const char GSM_VERBOSE_2[] TINY_GSM_PROGMEM = GSM_VERBOSE_2;
 #endif
 
 template <class modemType>
@@ -54,43 +69,25 @@ class TinyGsmModem {
   // Listen for responses to commands and handle URCs
   int8_t waitResponse(uint32_t timeout_ms, String& data,
                       GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
-                      GsmConstStr r7 = NULL) {
+                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
+                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL,
+                      GsmConstStr r6 = NULL, GsmConstStr r7 = NULL) {
     return thisModem().waitResponseImpl(timeout_ms, data, r1, r2, r3, r4, r5,
                                         r6, r7);
   }
 
   int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
-                      GsmConstStr r7 = NULL) {
+                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
+                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL,
+                      GsmConstStr r6 = NULL, GsmConstStr r7 = NULL) {
     String data;
     return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5, r6, r7);
   }
 
   int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
-                      GsmConstStr r7 = NULL) {
+                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
+                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL,
+                      GsmConstStr r6 = NULL, GsmConstStr r7 = NULL) {
     return waitResponse(1000L, r1, r2, r3, r4, r5, r6, r7);
   }
 
@@ -182,15 +179,14 @@ class TinyGsmModem {
   int8_t waitResponseImpl(uint32_t timeout_ms, String& data,
                           GsmConstStr r1 = GFP(GSM_OK),
                           GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                          GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                          GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
                           GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
                           GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
                           GsmConstStr r7 = NULL) {
     data.reserve(64);
+    // DBG(GF("r1 <"), r1 ? r1 : GF("NULL"), GF("> r2 <"), r2 ? r2 : GF("NULL"),
+    //     GF("> r3 <"), r3 ? r3 : GF("NULL"), GF("> r4 <"), r4 ? r4 :
+    //     GF("NULL"), GF("> r5 <"), r5 ? r5 : GF("NULL"), GF("> r6 <"), r6 ? r6
+    //     : GF("NULL"), GF("> r7 <"), r7 ? r7 : GF("NULL"), '>');
     uint8_t  index       = 0;
     uint32_t startMillis = millis();
     do {
@@ -207,11 +203,6 @@ class TinyGsmModem {
           index = 2;
           goto finish;
         } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
           index = 3;
           goto finish;
         } else if (r4 && data.endsWith(r4)) {
@@ -226,7 +217,20 @@ class TinyGsmModem {
         } else if (r7 && data.endsWith(r7)) {
           index = 7;
           goto finish;
-        } else if (thisModem().handleURCs(data)) {
+        }
+#if defined TINY_GSM_DEBUG
+        else if (data.endsWith(GFP(GSM_VERBOSE)) ||
+                 data.endsWith(GFP(GSM_VERBOSE_2))) {
+          // DBG(GF("Verbose details <<<"));
+          // Read out the verbose message, until whichever type of new line
+          // comes first
+          thisModem().stream.findUntil(const_cast<char*>("\r"),
+                                       const_cast<char*>("\n"));
+          // DBG(GF(">>>"));
+          data = "";
+        }
+#endif
+        else if (thisModem().handleURCs(data)) {
           data = "";
         }
       }
@@ -237,7 +241,7 @@ class TinyGsmModem {
       if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
     }
-    // data.replace(AT_NL, "/");
+    // data.replace(GSM_NL, "/");
     // DBG('<', index, '>', data);
     return index;
   }

From b8efb21f29cdd01ed30e0424b947ca3a7f84109a Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 13 May 2024 14:03:29 -0400
Subject: [PATCH 042/100] Rename GSM_NL to AT_NL

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .../SIM800_SslSetCert/SIM800_SslSetCert.ino   | 24 ++++------
 src/TinyGsmClientA6.h                         | 44 +++++++++----------
 src/TinyGsmClientBG96.h                       | 20 ++++-----
 src/TinyGsmClientESP8266.h                    | 26 +++++------
 src/TinyGsmClientM590.h                       | 23 +++++-----
 src/TinyGsmClientM95.h                        | 28 ++++++------
 src/TinyGsmClientMC60.h                       | 26 +++++------
 src/TinyGsmClientSIM5360.h                    | 40 ++++++++---------
 src/TinyGsmClientSIM7000.h                    | 23 +++++-----
 src/TinyGsmClientSIM7000SSL.h                 | 17 ++++---
 src/TinyGsmClientSIM7080.h                    | 15 +++----
 src/TinyGsmClientSIM70xx.h                    | 24 +++++-----
 src/TinyGsmClientSIM7600.h                    | 44 +++++++++----------
 src/TinyGsmClientSIM800.h                     | 34 +++++++-------
 src/TinyGsmClientSIM808.h                     | 28 ++++++------
 src/TinyGsmClientSaraR4.h                     | 36 +++++++--------
 src/TinyGsmClientSequansMonarch.h             | 24 +++++-----
 src/TinyGsmClientUBLOX.h                      | 34 +++++++-------
 src/TinyGsmClientXBee.h                       |  8 ++--
 src/TinyGsmModem.tpp                          | 36 +++++++--------
 20 files changed, 271 insertions(+), 283 deletions(-)

diff --git a/examples/more/SIM800_SslSetCert/SIM800_SslSetCert.ino b/examples/more/SIM800_SslSetCert/SIM800_SslSetCert.ino
index eef4207..cefb37c 100644
--- a/examples/more/SIM800_SslSetCert/SIM800_SslSetCert.ino
+++ b/examples/more/SIM800_SslSetCert/SIM800_SslSetCert.ino
@@ -32,11 +32,11 @@
 
 
 #ifdef DUMP_AT_COMMANDS
-  #include <StreamDebugger.h>
-  StreamDebugger debugger(SerialAT, SerialMon);
-  TinyGsm modem(debugger);
+#include <StreamDebugger.h>
+StreamDebugger debugger(SerialAT, SerialMon);
+TinyGsm        modem(debugger);
 #else
-  TinyGsm modem(SerialAT);
+TinyGsm modem(SerialAT);
 #endif
 
 void setup() {
@@ -57,23 +57,21 @@ void setup() {
   const int cert_size = sizeof(cert);
 
   modem.sendAT(GF("+FSWRITE=" CERT_FILE ",0,"), cert_size, GF(",10"));
-  if (modem.waitResponse(GF(">")) != 1) {
-    return;
-  }
+  if (modem.waitResponse(GF(">")) != 1) { return; }
 
   for (int i = 0; i < cert_size; i++) {
     char c = pgm_read_byte(&cert[i]);
     modem.stream.write(c);
   }
 
-  modem.stream.write(GSM_NL);
+  modem.stream.write(AT_NL);
   modem.stream.flush();
 
   if (modem.waitResponse(2000) != 1) return;
 
   modem.sendAT(GF("+SSLSETCERT=\"" CERT_FILE "\""));
   if (modem.waitResponse() != 1) return;
-  if (modem.waitResponse(5000L, GF(GSM_NL "+SSLSETCERT:")) != 1) return;
+  if (modem.waitResponse(5000L, GF(AT_NL "+SSLSETCERT:")) != 1) return;
   const int retCode = modem.stream.readStringUntil('\n').toInt();
 
 
@@ -86,11 +84,7 @@ void setup() {
 }
 
 void loop() {
-  if (SerialAT.available()) {
-    SerialMon.write(SerialAT.read());
-  }
-  if (SerialMon.available()) {
-    SerialAT.write(SerialMon.read());
-  }
+  if (SerialAT.available()) { SerialMon.write(SerialAT.read()); }
+  if (SerialMon.available()) { SerialAT.write(SerialMon.read()); }
   delay(0);
 }
diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index f617a7c..4763ecb 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 8
 #define TINY_GSM_NO_MODEM_BUFFER
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -208,8 +208,8 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     sendAT(GF("+CIFSR"));
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, "");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, "");
     res.trim();
     return res;
   }
@@ -262,7 +262,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     waitResponse();
 
     sendAT(GF("+COPS?"));
-    if (waitResponse(GF(GSM_NL "+COPS:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+COPS:")) != 1) { return ""; }
     streamSkipUntil('"');  // Skip mode and format
     String res = stream.readStringUntil('"');
     waitResponse();
@@ -275,7 +275,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
  protected:
   String getSimCCIDImpl() {
     sendAT(GF("+CCID"));
-    if (waitResponse(GF(GSM_NL "+SCID: SIM Card ID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+SCID: SIM Card ID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -296,16 +296,16 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
 
     if (waitResponse(5000L) != 1) { return false; }
 
-    if (waitResponse(60000L, GF(GSM_NL "+CIEV: \"CALL\",1"),
-                     GF(GSM_NL "+CIEV: \"CALL\",0"), GFP(GSM_ERROR)) != 1) {
+    if (waitResponse(60000L, GF(AT_NL "+CIEV: \"CALL\",1"),
+                     GF(AT_NL "+CIEV: \"CALL\",0"), GFP(GSM_ERROR)) != 1) {
       return false;
     }
 
-    int8_t rsp = waitResponse(60000L, GF(GSM_NL "+CIEV: \"SOUNDER\",0"),
-                              GF(GSM_NL "+CIEV: \"CALL\",0"));
+    int8_t rsp = waitResponse(60000L, GF(AT_NL "+CIEV: \"SOUNDER\",0"),
+                              GF(AT_NL "+CIEV: \"CALL\",0"));
 
-    int8_t rsp2 = waitResponse(300L, GF(GSM_NL "BUSY" GSM_NL),
-                               GF(GSM_NL "NO ANSWER" GSM_NL));
+    int8_t rsp2 = waitResponse(300L, GF(AT_NL "BUSY" AT_NL),
+                               GF(AT_NL "NO ANSWER" AT_NL));
 
     return rsp == 1 && rsp2 == 0;
   }
@@ -358,7 +358,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     waitResponse();
     sendAT(GF("+CUSD=1,\""), code, GF("\",15"));
     if (waitResponse(10000L) != 1) { return ""; }
-    if (waitResponse(GF(GSM_NL "+CUSD:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+CUSD:")) != 1) { return ""; }
     streamSkipUntil('"');
     String hex = stream.readStringUntil('"');
     streamSkipUntil(',');
@@ -389,7 +389,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
   // Needs a '?' after CBC, unlike most
   int8_t getBattPercentImpl() {
     sendAT(GF("+CBC?"));
-    if (waitResponse(GF(GSM_NL "+CBC:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return false; }
     streamSkipUntil(',');  // Skip battery charge status
     // Read battery charge level
     int8_t res = streamGetIntBefore('\n');
@@ -402,7 +402,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
   bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
                         uint16_t& milliVolts) {
     sendAT(GF("+CBC?"));
-    if (waitResponse(GF(GSM_NL "+CBC:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return false; }
     chargeState = streamGetIntBefore(',');
     percent     = streamGetIntBefore('\n');
     milliVolts  = 0;
@@ -421,12 +421,12 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     uint32_t timeout_ms  = ((uint32_t)timeout_s) * 1000;
 
     sendAT(GF("+CIPSTART="), GF("\"TCP"), GF("\",\""), host, GF("\","), port);
-    if (waitResponse(timeout_ms, GF(GSM_NL "+CIPNUM:")) != 1) { return false; }
+    if (waitResponse(timeout_ms, GF(AT_NL "+CIPNUM:")) != 1) { return false; }
     int8_t newMux = streamGetIntBefore('\n');
 
-    int8_t rsp = waitResponse(
-        (timeout_ms - (millis() - startMillis)), GF("CONNECT OK" GSM_NL),
-        GF("CONNECT FAIL" GSM_NL), GF("ALREADY CONNECT" GSM_NL));
+    int8_t rsp = waitResponse((timeout_ms - (millis() - startMillis)),
+                              GF("CONNECT OK" AT_NL), GF("CONNECT FAIL" AT_NL),
+                              GF("ALREADY CONNECT" AT_NL));
     if (waitResponse() != 1) { return false; }
     *mux = newMux;
 
@@ -435,10 +435,10 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
 
   int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
     sendAT(GF("+CIPSEND="), mux, ',', (uint16_t)len);
-    if (waitResponse(2000L, GF(GSM_NL ">")) != 1) { return 0; }
+    if (waitResponse(2000L, GF(AT_NL ">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(10000L, GFP(GSM_OK), GF(GSM_NL "FAIL")) != 1) { return 0; }
+    if (waitResponse(10000L, GFP(GSM_OK), GF(AT_NL "FAIL")) != 1) { return 0; }
     return len;
   }
 
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index b6057ec..70f6a2e 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 12
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -289,7 +289,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
  protected:
   String getSimCCIDImpl() {
     sendAT(GF("+QCCID"));
-    if (waitResponse(GF(GSM_NL "+QCCID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+QCCID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -337,7 +337,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   // get the RAW GPS output
   String getGPSrawImpl() {
     sendAT(GF("+QGPSLOC=2"));
-    if (waitResponse(10000L, GF(GSM_NL "+QGPSLOC:")) != 1) { return ""; }
+    if (waitResponse(10000L, GF(AT_NL "+QGPSLOC:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -350,7 +350,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
                   int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
                   int* minute = 0, int* second = 0) {
     sendAT(GF("+QGPSLOC=2"));
-    if (waitResponse(10000L, GF(GSM_NL "+QGPSLOC:")) != 1) {
+    if (waitResponse(10000L, GF(AT_NL "+QGPSLOC:")) != 1) {
       // NOTE:  Will return an error if the position isn't fixed
       return false;
     }
@@ -510,7 +510,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   // get temperature in degree celsius
   uint16_t getTemperatureImpl() {
     sendAT(GF("+QTEMP"));
-    if (waitResponse(GF(GSM_NL "+QTEMP:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+QTEMP:")) != 1) { return 0; }
     // return temperature in C
     uint16_t res =
         streamGetIntBefore(',');  // read PMIC (primary ic) temperature
@@ -538,7 +538,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
            GF("\","), port, GF(",0,0"));
     waitResponse();
 
-    if (waitResponse(timeout_ms, GF(GSM_NL "+QIOPEN:")) != 1) { return false; }
+    if (waitResponse(timeout_ms, GF(AT_NL "+QIOPEN:")) != 1) { return false; }
 
     if (streamGetIntBefore(',') != mux) { return false; }
     // Read status
@@ -550,7 +550,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "SEND OK")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
     // TODO(?): Wait for ACK? AT+QISEND=id,0
     return len;
   }
@@ -607,7 +607,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+QIURC:"))) {
+    if (data.endsWith(GF(AT_NL "+QIURC:"))) {
       streamSkipUntil('\"');
       String urc = stream.readStringUntil('\"');
       streamSkipUntil(',');
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 590eb8d..8f8ab52 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 5
 #define TINY_GSM_NO_MODEM_BUFFER
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmModem.tpp"
@@ -190,8 +190,8 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     sendAT(GF("+GMR"));
     String res;
     if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, " ");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, " ");
     res.trim();
     return res;
   }
@@ -204,7 +204,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     if (!testAT()) { return false; }
     sendAT(GF("+RST"));
     if (waitResponse(10000L) != 1) { return false; }
-    if (waitResponse(10000L, GF(GSM_NL "ready" GSM_NL)) != 1) { return false; }
+    if (waitResponse(10000L, GF(AT_NL "ready" AT_NL)) != 1) { return false; }
     delay(500);
     return init(pin);
   }
@@ -303,9 +303,9 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     // attempt first without than with the 'current' flag used in some firmware
     // versions
     sendAT(GF("+CWJAP=\""), ssid, GF("\",\""), pwd, GF("\""));
-    if (waitResponse(30000L, GFP(GSM_OK), GF(GSM_NL "FAIL" GSM_NL)) != 1) {
+    if (waitResponse(30000L, GFP(AT_OK), GF(AT_NL "FAIL" AT_NL)) != 1) {
       sendAT(GF("+CWJAP_CUR=\""), ssid, GF("\",\""), pwd, GF("\""));
-      if (waitResponse(30000L, GFP(GSM_OK), GF(GSM_NL "FAIL" GSM_NL)) != 1) {
+      if (waitResponse(30000L, GFP(AT_OK), GF(AT_NL "FAIL" AT_NL)) != 1) {
         return false;
       }
     }
@@ -335,7 +335,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
            GF("\",\""), host, GF("\","), port, GF(","),
            TINY_GSM_TCP_KEEP_ALIVE);
     // TODO(?): Check mux
-    int8_t rsp = waitResponse(timeout_ms, GFP(GSM_OK), GFP(GSM_ERROR),
+    int8_t rsp = waitResponse(timeout_ms, GFP(AT_OK), GFP(GSM_ERROR),
                               GF("ALREADY CONNECT"));
     // if (rsp == 3) waitResponse();
     // May return "ERROR" after the "ALREADY CONNECT"
@@ -347,7 +347,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(10000L, GF(GSM_NL "SEND OK" GSM_NL)) != 1) { return 0; }
+    if (waitResponse(10000L, GF(AT_NL "SEND OK" AT_NL)) != 1) { return 0; }
     return len;
   }
 
@@ -357,7 +357,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     // after "STATUS:" it should return the status number (0,1,2,3,4,5),
     // followed by an OK
     // Hopefully we'll catch the "3" here, but fall back to the OK or Error
-    int8_t status = waitResponse(GF("3"), GFP(GSM_OK), GFP(GSM_ERROR));
+    int8_t status = waitResponse(GF("3"), GFP(AT_OK), GFP(GSM_ERROR));
     // if the status is anything but 3, there are no connections open
     if (status != 1) {
       for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
@@ -367,7 +367,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     }
     bool verified_connections[TINY_GSM_MUX_COUNT] = {0, 0, 0, 0, 0};
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
-      uint8_t has_status = waitResponse(GF("+CIPSTATUS:"), GFP(GSM_OK),
+      uint8_t has_status = waitResponse(GF("+CIPSTATUS:"), GFP(AT_OK),
                                         GFP(GSM_ERROR));
       if (has_status == 1) {
         int8_t returned_mux = streamGetIntBefore(',');
@@ -416,7 +416,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
       return true;
     } else if (data.endsWith(GF("CLOSED"))) {
       int8_t muxStart = TinyGsmMax(0,
-                                   data.lastIndexOf(GSM_NL, data.length() - 8));
+                                   data.lastIndexOf(AT_NL, data.length() - 8));
       int8_t coma     = data.indexOf(',', muxStart);
       int8_t mux      = data.substring(muxStart, coma).toInt();
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index fab9deb..558f71b 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 2
 #define TINY_GSM_NO_MODEM_BUFFER
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmGPRS.tpp"
@@ -171,7 +171,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(15)) { return false; }
     // MODEM:STARTUP
-    waitResponse(60000L, GF(GSM_NL "+PBREADY" GSM_NL));
+    waitResponse(60000L, GF(AT_NL "+PBREADY" AT_NL));
     return init(pin);
   }
 
@@ -206,7 +206,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
 
   String getLocalIPImpl() {
     sendAT(GF("+XIIC?"));
-    if (waitResponse(GF(GSM_NL "+XIIC:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+XIIC:")) != 1) { return ""; }
     streamSkipUntil(',');
     String res = stream.readStringUntil('\n');
     waitResponse();
@@ -264,7 +264,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
 
   bool isGprsConnectedImpl() {
     sendAT(GF("+XIIC?"));
-    if (waitResponse(GF(GSM_NL "+XIIC:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+XIIC:")) != 1) { return false; }
     int8_t res = streamGetIntBefore(',');
     waitResponse();
     return res == 1;
@@ -300,9 +300,8 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
       String ip = dnsIpQuery(host);
 
       sendAT(GF("+TCPSETUP="), mux, GF(","), ip, GF(","), port);
-      int8_t rsp = waitResponse(timeout_ms, GF(",OK" GSM_NL),
-                                GF(",FAIL" GSM_NL),
-                                GF("+TCPSETUP:Error" GSM_NL));
+      int8_t rsp = waitResponse(timeout_ms, GF(",OK" AT_NL), GF(",FAIL" AT_NL),
+                                GF("+TCPSETUP:Error" AT_NL));
       if (1 == rsp) {
         return true;
       } else if (3 == rsp) {
@@ -320,7 +319,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.write(static_cast<char>(0x0D));
     stream.flush();
-    if (waitResponse(30000L, GF(GSM_NL "+TCPSEND:")) != 1) { return 0; }
+    if (waitResponse(30000L, GF(AT_NL "+TCPSEND:")) != 1) { return 0; }
     streamSkipUntil('\n');
     return len;
   }
@@ -335,9 +334,9 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
 
   String dnsIpQuery(const char* host) {
     sendAT(GF("+DNS=\""), host, GF("\""));
-    if (waitResponse(10000L, GF(GSM_NL "+DNS:")) != 1) { return ""; }
+    if (waitResponse(10000L, GF(AT_NL "+DNS:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
-    waitResponse(GF("+DNS:OK" GSM_NL));
+    waitResponse(GF("+DNS:OK" AT_NL));
     res.trim();
     return res;
   }
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 5ea9d55..fa3212f 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -15,9 +15,9 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_NO_CHECK
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -342,7 +342,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
  protected:
   String getSimCCIDImpl() {
     sendAT(GF("+QCCID"));
-    if (waitResponse(GF(GSM_NL "+QCCID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+QCCID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -388,7 +388,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
  protected:
   float getTemperatureImpl() {
     sendAT(GF("+QTEMP?"));
-    if (waitResponse(GF(GSM_NL "+QTEMP:")) != 1) {
+    if (waitResponse(GF(AT_NL "+QTEMP:")) != 1) {
       return static_cast<float>(-9999);
     }
     streamSkipUntil(',');  // Skip mode
@@ -411,9 +411,9 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
     sendAT(GF("+QIOPEN="), mux, GF(",\""), GF("TCP"), GF("\",\""), host,
            GF("\","), port);
-    int8_t rsp = waitResponse(timeout_ms, GF("CONNECT OK" GSM_NL),
-                              GF("CONNECT FAIL" GSM_NL),
-                              GF("ALREADY CONNECT" GSM_NL));
+    int8_t rsp = waitResponse(timeout_ms, GF("CONNECT OK" AT_NL),
+                              GF("CONNECT FAIL" AT_NL),
+                              GF("ALREADY CONNECT" AT_NL));
     return (1 == rsp);
   }
 
@@ -422,13 +422,13 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "SEND OK")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
 
     // bool allAcknowledged = false;
     // // bool failed = false;
     // while ( !allAcknowledged ) {
     //   sendAT( GF("+QISACK"));
-    //   if (waitResponse(5000L, GF(GSM_NL "+QISACK:")) != 1) {
+    //   if (waitResponse(5000L, GF(AT_NL "+QISACK:")) != 1) {
     //     return -1;
     //   } else {
     //     streamSkipUntil(',');  // Skip total length sent on connection
@@ -455,7 +455,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
     sendAT(GF("+QIRD=0,1,"), mux, ',', (uint16_t)size);
     // If it replies only OK for the write command, it means there is no
     // received data in the buffer of the connection.
-    int8_t res = waitResponse(GF("+QIRD:"), GFP(GSM_OK), GFP(GSM_ERROR));
+    int8_t res = waitResponse(GF("+QIRD:"), GFP(AT_OK), GFP(GSM_ERROR));
     if (res == 1) {
       streamSkipUntil(':');  // skip IP address
       streamSkipUntil(',');  // skip port
@@ -512,7 +512,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+QIRDI:"))) {
+    if (data.endsWith(GF(AT_NL "+QIRDI:"))) {
       streamSkipUntil(',');  // Skip the context
       streamSkipUntil(',');  // Skip the role
       int8_t mux = streamGetIntBefore('\n');
@@ -524,8 +524,8 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
       }
       data = "";
       return true;
-    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+    } else if (data.endsWith(GF("CLOSED" AT_NL))) {
+      int8_t nl   = data.lastIndexOf(AT_NL, data.length() - 8);
       int8_t coma = data.indexOf(',', nl + 2);
       int8_t mux  = data.substring(nl + 2, coma).toInt();
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index f6a02df..a5400f7 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -17,9 +17,9 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_NO_CHECK
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -312,7 +312,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
   SimStatus getSimStatusImpl(uint32_t timeout_ms = 10000L) {
     for (uint32_t start = millis(); millis() - start < timeout_ms;) {
       sendAT(GF("+CPIN?"));
-      if (waitResponse(GF(GSM_NL "+CPIN:")) != 1) {
+      if (waitResponse(GF(AT_NL "+CPIN:")) != 1) {
         delay(1000);
         continue;
       }
@@ -384,9 +384,9 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
     sendAT(GF("+QIOPEN="), mux, GF(",\""), GF("TCP"), GF("\",\""), host,
            GF("\","), port);
-    int8_t rsp = waitResponse(timeout_ms, GF("CONNECT OK" GSM_NL),
-                              GF("CONNECT FAIL" GSM_NL),
-                              GF("ALREADY CONNECT" GSM_NL));
+    int8_t rsp = waitResponse(timeout_ms, GF("CONNECT OK" AT_NL),
+                              GF("CONNECT FAIL" AT_NL),
+                              GF("ALREADY CONNECT" AT_NL));
     return (1 == rsp);
   }
 
@@ -395,14 +395,14 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "SEND OK")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
 
     bool allAcknowledged = false;
     // bool failed = false;
     while (!allAcknowledged) {
       sendAT(GF("+QISACK="), mux);  // If 'mux' is not specified, MC60 returns
                                     // 'ERRROR' (for QIMUX == 1)
-      if (waitResponse(5000L, GF(GSM_NL "+QISACK:")) != 1) {
+      if (waitResponse(5000L, GF(AT_NL "+QISACK:")) != 1) {
         return -1;
       } else {
         streamSkipUntil(','); /** Skip total */
@@ -429,7 +429,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
     sendAT(GF("+QIRD=0,1,"), mux, ',', (uint16_t)size);
     // If it replies only OK for the write command, it means there is no
     // received data in the buffer of the connection.
-    int8_t res = waitResponse(GF("+QIRD:"), GFP(GSM_OK), GFP(GSM_ERROR));
+    int8_t res = waitResponse(GF("+QIRD:"), GFP(AT_OK), GFP(GSM_ERROR));
     if (res == 1) {
       streamSkipUntil(':');  // skip IP address
       streamSkipUntil(',');  // skip port
@@ -485,7 +485,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+QIRDI:"))) {  // TODO(?):  QIRD? or QIRDI?
+    if (data.endsWith(GF(AT_NL "+QIRDI:"))) {  // TODO(?):  QIRD? or QIRDI?
       // +QIRDI: <id>,<sc>,<sid>,<num>,<len>,< tlen>
       streamSkipUntil(',');  // Skip the context
       streamSkipUntil(',');  // Skip the role
@@ -505,8 +505,8 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
       data = "";
       // DBG("### Got Data:", len_total, "on", mux);
       return true;
-    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+    } else if (data.endsWith(GF("CLOSED" AT_NL))) {
+      int8_t nl   = data.lastIndexOf(AT_NL, data.length() - 8);
       int8_t coma = data.indexOf(',', nl + 2);
       int8_t mux  = data.substring(nl + 2, coma).toInt();
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 212101e..4a4b54e 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -197,7 +197,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     sendAT(GF("+CGMM"));
     String res2;
     if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.replace("_", " ");
     res2.trim();
 
@@ -221,7 +221,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     if (waitResponse(10000L) != 1) { return false; }
     // After booting, modem sends out messages as each of its
     // internal modules loads.  The final message is "PB DONE".
-    if (waitResponse(40000L, GF(GSM_NL "PB DONE")) != 1) { return false; }
+    if (waitResponse(40000L, GF(AT_NL "PB DONE")) != 1) { return false; }
     return init(pin);
   }
 
@@ -263,7 +263,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
  public:
   String getNetworkModes() {
     sendAT(GF("+CNMP=?"));
-    if (waitResponse(GF(GSM_NL "+CNMP:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+CNMP:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     return res;
@@ -271,7 +271,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
 
   int16_t getNetworkMode() {
     sendAT(GF("+CNMP?"));
-    if (waitResponse(GF(GSM_NL "+CNMP:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CNMP:")) != 1) { return false; }
     int16_t mode = streamGetIntBefore('\n');
     waitResponse();
     return mode;
@@ -287,8 +287,8 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     // sendAT(GF("+CGPADDR=1"));  // Show PDP address
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, "");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, "");
     res.trim();
     return res;
   }
@@ -372,7 +372,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     // We to ignore any immediate response and wait for the
     // URC to show it's really connected.
     sendAT(GF("+NETOPEN"));
-    if (waitResponse(75000L, GF(GSM_NL "+NETOPEN: 0")) != 1) { return false; }
+    if (waitResponse(75000L, GF(AT_NL "+NETOPEN: 0")) != 1) { return false; }
 
     return true;
   }
@@ -388,7 +388,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     // Note: all sockets should be closed first - on 3G/4G models the sockets
     // must be closed manually
     sendAT(GF("+NETCLOSE"));
-    if (waitResponse(60000L, GF(GSM_NL "+NETCLOSE: 0")) != 1) { return false; }
+    if (waitResponse(60000L, GF(AT_NL "+NETCLOSE: 0")) != 1) { return false; }
 
     return true;
   }
@@ -396,7 +396,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   bool isGprsConnectedImpl() {
     sendAT(GF("+NETOPEN?"));
     // May return +NETOPEN: 1, 0.  We just confirm that the first number is 1
-    if (waitResponse(GF(GSM_NL "+NETOPEN: 1")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+NETOPEN: 1")) != 1) { return false; }
     waitResponse();
 
     sendAT(GF("+IPADDR"));  // Inquire Socket PDP address
@@ -413,7 +413,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   // Gets the CCID of a sim card via AT+CCID
   String getSimCCIDImpl() {
     sendAT(GF("+CICCID"));
-    if (waitResponse(GF(GSM_NL "+ICCID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+ICCID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -451,7 +451,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   // SRGD Note:  Returns voltage in VOLTS instead of millivolts
   uint16_t getBattVoltageImpl() {
     sendAT(GF("+CBC"));
-    if (waitResponse(GF(GSM_NL "+CBC:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip battery charge status
     streamSkipUntil(',');  // Skip battery charge level
     // get voltage in VOLTS
@@ -467,7 +467,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
                         uint16_t& milliVolts) {
     sendAT(GF("+CBC"));
-    if (waitResponse(GF(GSM_NL "+CBC:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return false; }
     chargeState = streamGetIntBefore(',');
     percent     = streamGetIntBefore(',');
     // get voltage in VOLTS
@@ -489,7 +489,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     if (waitResponse() != 1) { return 0; }
     // Get Temparature Value
     sendAT(GF("+CMTE?"));
-    if (waitResponse(GF(GSM_NL "+CMTE:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CMTE:")) != 1) { return false; }
     float res = streamGetFloatBefore('\n');
     // Wait for final OK
     waitResponse();
@@ -512,7 +512,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     sendAT(GF("+CIPOPEN="), mux, ',', GF("\"TCP"), GF("\",\""), host, GF("\","),
            port);
     // The reply is +CIPOPEN: ## of socket created
-    if (waitResponse(timeout_ms, GF(GSM_NL "+CIPOPEN:")) != 1) { return false; }
+    if (waitResponse(timeout_ms, GF(AT_NL "+CIPOPEN:")) != 1) { return false; }
     return true;
   }
 
@@ -521,7 +521,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "+CIPSEND:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CIPSEND:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     streamSkipUntil(',');  // Skip requested bytes to send
     // TODO(?):  make sure requested and confirmed bytes match
@@ -606,7 +606,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+    if (data.endsWith(GF(AT_NL "+CIPRXGET:"))) {
       int8_t mode = streamGetIntBefore(',');
       if (mode == 1) {
         int8_t mux = streamGetIntBefore('\n');
@@ -620,7 +620,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
         data += mode;
         return false;
       }
-    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+    } else if (data.endsWith(GF(AT_NL "+RECEIVE:"))) {
       int8_t  mux = streamGetIntBefore(',');
       int16_t len = streamGetIntBefore('\n');
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index a723a1c..721a366 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -152,8 +152,8 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
     sendAT(GF("+CIFSR;E0"));
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, "");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, "");
     res.trim();
     return res;
   }
@@ -293,10 +293,9 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
     sendAT(GF("+CIPSTART="), mux, ',', GF("\"TCP"), GF("\",\""), host,
            GF("\","), port);
     return (1 ==
-            waitResponse(timeout_ms, GF("CONNECT OK" GSM_NL),
-                         GF("CONNECT FAIL" GSM_NL),
-                         GF("ALREADY CONNECT" GSM_NL), GF("ERROR" GSM_NL),
-                         GF("CLOSE OK" GSM_NL)));
+            waitResponse(timeout_ms, GF("CONNECT OK" AT_NL),
+                         GF("CONNECT FAIL" AT_NL), GF("ALREADY CONNECT" AT_NL),
+                         GF("ERROR" AT_NL), GF("CLOSE OK" AT_NL)));
   }
 
   int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
@@ -306,7 +305,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
 
-    if (waitResponse(GF(GSM_NL "DATA ACCEPT:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "DATA ACCEPT:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     return streamGetIntBefore('\n');
   }
@@ -391,7 +390,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+    if (data.endsWith(GF(AT_NL "+CIPRXGET:"))) {
       int8_t mode = streamGetIntBefore(',');
       if (mode == 1) {
         int8_t mux = streamGetIntBefore('\n');
@@ -405,7 +404,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
         data += mode;
         return false;
       }
-    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+    } else if (data.endsWith(GF(AT_NL "+RECEIVE:"))) {
       int8_t  mux = streamGetIntBefore(',');
       int16_t len = streamGetIntBefore('\n');
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
@@ -415,8 +414,8 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
       data = "";
       // DBG("### Got Data:", len, "on", mux);
       return true;
-    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+    } else if (data.endsWith(GF("CLOSED" AT_NL))) {
+      int8_t nl   = data.lastIndexOf(AT_NL, data.length() - 8);
       int8_t coma = data.indexOf(',', nl + 2);
       int8_t mux  = data.substring(nl + 2, coma).toInt();
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
@@ -445,7 +444,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
       data = "";
       DBG("### Daylight savings time state updated.");
       return true;
-    } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
+    } else if (data.endsWith(GF(AT_NL "SMS Ready" AT_NL))) {
       data = "";
       DBG("### Unexpected module reset!");
       init();
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index f9499a3..e6c8c92 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -194,7 +194,7 @@ class TinyGsmSim7000SSL
  protected:
   String getLocalIPImpl() {
     sendAT(GF("+CNACT?"));
-    if (waitResponse(GF(GSM_NL "+CNACT:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+CNACT:")) != 1) { return ""; }
     streamSkipUntil('\"');
     String res = stream.readStringUntil('\"');
     waitResponse();
@@ -265,8 +265,8 @@ class TinyGsmSim7000SSL
     int  ntries = 0;
     while (!res && ntries < 5) {
       sendAT(GF("+CNACT=1,\""), apn, GF("\""));
-      res = waitResponse(60000L, GF(GSM_NL "+APP PDP: ACTIVE"),
-                         GF(GSM_NL "+APP PDP: DEACTIVE")) == 1;
+      res = waitResponse(60000L, GF(AT_NL "+APP PDP: ACTIVE"),
+                         GF(AT_NL "+APP PDP: DEACTIVE")) == 1;
       waitResponse();
       ntries++;
     }
@@ -393,7 +393,7 @@ class TinyGsmSim7000SSL
     // <conn_type> "TCP" or "UDP"
     // NOTE:  the "TCP" can't be included
     sendAT(GF("+CAOPEN="), mux, GF(",\""), host, GF("\","), port);
-    if (waitResponse(timeout_ms, GF(GSM_NL "+CAOPEN:")) != 1) { return 0; }
+    if (waitResponse(timeout_ms, GF(AT_NL "+CAOPEN:")) != 1) { return 0; }
     // returns OK/r/n/r/n+CAOPEN: <cid>,<result>
     // <result> 0: Success
     //          1: Socket error
@@ -430,7 +430,7 @@ class TinyGsmSim7000SSL
 
     // after posting data, module responds with:
     //+CASEND: <cid>,<result>,<sendlen>
-    if (waitResponse(GF(GSM_NL "+CASEND:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CASEND:")) != 1) { return 0; }
     streamSkipUntil(',');                            // Skip mux
     if (streamGetIntBefore(',') != 0) { return 0; }  // If result != success
     return streamGetIntBefore('\n');
@@ -496,7 +496,7 @@ class TinyGsmSim7000SSL
     sendAT(GF("+CARECV?"));
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CARECV:"), GFP(GSM_OK), GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CARECV:"), GFP(AT_OK), GFP(GSM_ERROR));
       // if we get the +CARECV: response, read the mux number and the number of
       // characters available
       if (res == 1) {
@@ -543,8 +543,7 @@ class TinyGsmSim7000SSL
 
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CASTATE:"), GFP(GSM_OK),
-                             GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CASTATE:"), GFP(AT_OK), GFP(GSM_ERROR));
       // if we get the +CASTATE: response, read the mux number and the status
       if (res == 1) {
         int    ret_mux = streamGetIntBefore(',');
@@ -638,7 +637,7 @@ class TinyGsmSim7000SSL
       data = "";
       DBG("### Daylight savings time state updated.");
       return true;
-    } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
+    } else if (data.endsWith(GF(AT_NL "SMS Ready" AT_NL))) {
       data = "";
       DBG("### Unexpected module reset!");
       init();
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index a0638ad..128d70b 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -192,7 +192,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
  protected:
   String getLocalIPImpl() {
     sendAT(GF("+CNACT?"));
-    if (waitResponse(GF(GSM_NL "+CNACT:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+CNACT:")) != 1) { return ""; }
     streamSkipUntil('\"');
     String res = stream.readStringUntil('\"');
     waitResponse();
@@ -270,8 +270,8 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     int  ntries = 0;
     while (!res && ntries < 5) {
       sendAT(GF("+CNACT=0,1"));
-      res = waitResponse(60000L, GF(GSM_NL "+APP PDP: 0,ACTIVE"),
-                         GF(GSM_NL "+APP PDP: 0,DEACTIVE"));
+      res = waitResponse(60000L, GF(AT_NL "+APP PDP: 0,ACTIVE"),
+                         GF(AT_NL "+APP PDP: 0,DEACTIVE"));
       waitResponse();
       ntries++;
     }
@@ -401,7 +401,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     //                "recv",<id>,<length>,<remoteIP>,<remote_port><CR><LF><data>
     // NOTE:  including the <recv_mode> fails
     sendAT(GF("+CAOPEN="), mux, GF(",0,\"TCP\",\""), host, GF("\","), port);
-    if (waitResponse(timeout_ms, GF(GSM_NL "+CAOPEN:")) != 1) { return 0; }
+    if (waitResponse(timeout_ms, GF(AT_NL "+CAOPEN:")) != 1) { return 0; }
     // returns OK/r/n/r/n+CAOPEN: <cid>,<result>
     // <result> 0: Success
     //          1: Socket error
@@ -495,7 +495,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     sendAT(GF("+CARECV?"));
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CARECV:"), GFP(GSM_OK), GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CARECV:"), GFP(AT_OK), GFP(GSM_ERROR));
       // if we get the +CARECV: response, read the mux number and the number of
       // characters available
       if (res == 1) {
@@ -542,8 +542,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
 
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CASTATE:"), GFP(GSM_OK),
-                             GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CASTATE:"), GFP(AT_OK), GFP(GSM_ERROR));
       // if we get the +CASTATE: response, read the mux number and the status
       if (res == 1) {
         int    ret_mux = streamGetIntBefore(',');
@@ -637,7 +636,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
       data = "";
       DBG("### Daylight savings time state updated.");
       return true;
-    } else if (data.endsWith(GF(GSM_NL "SMS Ready" GSM_NL))) {
+    } else if (data.endsWith(GF(AT_NL "SMS Ready" AT_NL))) {
       data = "";
       DBG("### Unexpected module reset!");
       init();
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 7d69df9..3852467 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -11,9 +11,9 @@
 
 // #define TINY_GSM_DEBUG Serial
 // #define TINY_GSM_USE_HEX
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -84,7 +84,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
     thisModem().sendAT(GF("+GMM"));
     String res2;
     if (thisModem().waitResponse(5000L, res2) != 1) { return name; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.replace("_", " ");
     res2.trim();
 
@@ -166,7 +166,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   String getNetworkModes() {
     // Get the help string, not the setting value
     thisModem().sendAT(GF("+CNMP=?"));
-    if (thisModem().waitResponse(GF(GSM_NL "+CNMP:")) != 1) { return ""; }
+    if (thisModem().waitResponse(GF(AT_NL "+CNMP:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     thisModem().waitResponse();
     return res;
@@ -174,7 +174,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
 
   int16_t getNetworkMode() {
     thisModem().sendAT(GF("+CNMP?"));
-    if (thisModem().waitResponse(GF(GSM_NL "+CNMP:")) != 1) { return false; }
+    if (thisModem().waitResponse(GF(AT_NL "+CNMP:")) != 1) { return false; }
     int16_t mode = thisModem().streamGetIntBefore('\n');
     thisModem().waitResponse();
     return mode;
@@ -192,7 +192,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   String getPreferredModes() {
     // Get the help string, not the setting value
     thisModem().sendAT(GF("+CMNB=?"));
-    if (thisModem().waitResponse(GF(GSM_NL "+CMNB:")) != 1) { return ""; }
+    if (thisModem().waitResponse(GF(AT_NL "+CMNB:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     thisModem().waitResponse();
     return res;
@@ -200,7 +200,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
 
   int16_t getPreferredMode() {
     thisModem().sendAT(GF("+CMNB?"));
-    if (thisModem().waitResponse(GF(GSM_NL "+CMNB:")) != 1) { return false; }
+    if (thisModem().waitResponse(GF(AT_NL "+CMNB:")) != 1) { return false; }
     int16_t mode = thisModem().streamGetIntBefore('\n');
     thisModem().waitResponse();
     return mode;
@@ -218,7 +218,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
     // n: whether to automatically report the system mode info
     // stat: the current service. 0 if it not connected
     thisModem().sendAT(GF("+CNSMOD?"));
-    if (thisModem().waitResponse(GF(GSM_NL "+CNSMOD:")) != 1) { return false; }
+    if (thisModem().waitResponse(GF(AT_NL "+CNSMOD:")) != 1) { return false; }
     n    = thisModem().streamGetIntBefore(',') != 0;
     stat = thisModem().streamGetIntBefore('\n');
     thisModem().waitResponse();
@@ -256,7 +256,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   // Doesn't return the "+CCID" before the number
   String getSimCCIDImpl() {
     thisModem().sendAT(GF("+CCID"));
-    if (thisModem().waitResponse(GF(GSM_NL)) != 1) { return ""; }
+    if (thisModem().waitResponse(GF(AT_NL)) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     thisModem().waitResponse();
     res.trim();
@@ -289,7 +289,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   // get the RAW GPS output
   String getGPSrawImpl() {
     thisModem().sendAT(GF("+CGNSINF"));
-    if (thisModem().waitResponse(10000L, GF(GSM_NL "+CGNSINF:")) != 1) {
+    if (thisModem().waitResponse(10000L, GF(AT_NL "+CGNSINF:")) != 1) {
       return "";
     }
     String res = stream.readStringUntil('\n');
@@ -304,7 +304,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
                   int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
                   int* minute = 0, int* second = 0) {
     thisModem().sendAT(GF("+CGNSINF"));
-    if (thisModem().waitResponse(10000L, GF(GSM_NL "+CGNSINF:")) != 1) {
+    if (thisModem().waitResponse(10000L, GF(AT_NL "+CGNSINF:")) != 1) {
       return false;
     }
 
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 558e8ce..5ead4ed 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -205,7 +205,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     sendAT(GF("+CGMM"));
     String res2;
     if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.replace("_", " ");
     res2.trim();
 
@@ -268,7 +268,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
  public:
   String getNetworkModes() {
     sendAT(GF("+CNMP=?"));
-    if (waitResponse(GF(GSM_NL "+CNMP:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+CNMP:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     return res;
@@ -276,7 +276,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
 
   int16_t getNetworkMode() {
     sendAT(GF("+CNMP?"));
-    if (waitResponse(GF(GSM_NL "+CNMP:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CNMP:")) != 1) { return false; }
     int16_t mode = streamGetIntBefore('\n');
     waitResponse();
     return mode;
@@ -292,8 +292,8 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     // sendAT(GF("+CGPADDR=1"));  // Show PDP address
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, "");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, "");
     res.trim();
     return res;
   }
@@ -360,7 +360,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     // We to ignore any immediate response and wait for the
     // URC to show it's really connected.
     sendAT(GF("+NETOPEN"));
-    if (waitResponse(75000L, GF(GSM_NL "+NETOPEN: 0")) != 1) { return false; }
+    if (waitResponse(75000L, GF(AT_NL "+NETOPEN: 0")) != 1) { return false; }
 
     return true;
   }
@@ -370,7 +370,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     // Note: On the LTE models, this single command closes all sockets and the
     // service
     sendAT(GF("+NETCLOSE"));
-    if (waitResponse(60000L, GF(GSM_NL "+NETCLOSE: 0")) != 1) { return false; }
+    if (waitResponse(60000L, GF(AT_NL "+NETCLOSE: 0")) != 1) { return false; }
 
     return true;
   }
@@ -378,7 +378,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   bool isGprsConnectedImpl() {
     sendAT(GF("+NETOPEN?"));
     // May return +NETOPEN: 1, 0.  We just confirm that the first number is 1
-    if (waitResponse(GF(GSM_NL "+NETOPEN: 1")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+NETOPEN: 1")) != 1) { return false; }
     waitResponse();
 
     sendAT(GF("+IPADDR"));  // Inquire Socket PDP address
@@ -395,7 +395,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   // Gets the CCID of a sim card via AT+CCID
   String getSimCCIDImpl() {
     sendAT(GF("+CICCID"));
-    if (waitResponse(GF(GSM_NL "+ICCID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+ICCID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -443,7 +443,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   // get the RAW GPS output
   String getGPSrawImpl() {
     sendAT(GF("+CGNSSINFO"));
-    if (waitResponse(GF(GSM_NL "+CGNSSINFO:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+CGNSSINFO:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -456,7 +456,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
                   int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
                   int* minute = 0, int* second = 0) {
     sendAT(GF("+CGNSSINFO"));
-    if (waitResponse(GF(GSM_NL "+CGNSSINFO:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CGNSSINFO:")) != 1) { return false; }
 
     uint8_t fixMode = streamGetIntBefore(',');  // mode 2=2D Fix or 3=3DFix
                                                 // TODO(?) Can 1 be returned
@@ -547,14 +547,14 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     String res;
     sendAT(GF("+CGNSSMODE="), mode, ",", dpo);
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(GSM_NL, "");
+    res.replace(AT_NL, "");
     res.trim();
     return res;
   }
 
   uint8_t getGNSSModeImpl() {
     sendAT(GF("+CGNSSMODE?"));
-    if (waitResponse(GF(GSM_NL "+CGNSSMODE:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CGNSSMODE:")) != 1) { return 0; }
     return stream.readStringUntil(',').toInt();
   }
 
@@ -577,7 +577,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   // returns volts, multiply by 1000 to get mV
   uint16_t getBattVoltageImpl() {
     sendAT(GF("+CBC"));
-    if (waitResponse(GF(GSM_NL "+CBC:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return 0; }
 
     // get voltage in VOLTS
     float voltage = streamGetFloatBefore('\n');
@@ -607,7 +607,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   // get temperature in degree celsius
   uint16_t getTemperatureImpl() {
     sendAT(GF("+CPMUTEMP"));
-    if (waitResponse(GF(GSM_NL "+CPMUTEMP:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CPMUTEMP:")) != 1) { return 0; }
     // return temperature in C
     uint16_t res = streamGetIntBefore('\n');
     // Wait for final OK
@@ -632,7 +632,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
            port);
     // The reply is OK followed by +CIPOPEN: <link_num>,<err> where <link_num>
     // is the mux number and <err> should be 0 if there's no error
-    if (waitResponse(timeout_ms, GF(GSM_NL "+CIPOPEN:")) != 1) { return false; }
+    if (waitResponse(timeout_ms, GF(AT_NL "+CIPOPEN:")) != 1) { return false; }
     uint8_t opened_mux    = streamGetIntBefore(',');
     uint8_t opened_result = streamGetIntBefore('\n');
     if (opened_mux != mux || opened_result != 0) return false;
@@ -644,7 +644,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "+CIPSEND:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CIPSEND:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     streamSkipUntil(',');  // Skip requested bytes to send
     // TODO(?):  make sure requested and confirmed bytes match
@@ -731,7 +731,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+    if (data.endsWith(GF(AT_NL "+CIPRXGET:"))) {
       int8_t mode = streamGetIntBefore(',');
       if (mode == 1) {
         int8_t mux = streamGetIntBefore('\n');
@@ -745,7 +745,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
         data += mode;
         return false;
       }
-    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+    } else if (data.endsWith(GF(AT_NL "+RECEIVE:"))) {
       int8_t  mux = streamGetIntBefore(',');
       int16_t len = streamGetIntBefore('\n');
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 6727209..6ff76a7 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -15,9 +15,9 @@
 
 #define TINY_GSM_MUX_COUNT 5
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -209,7 +209,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     sendAT(GF("+GMM"));
     String res2;
     if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.replace("_", " ");
     res2.trim();
 
@@ -239,7 +239,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
       return false;
   #else
       sendAT(GF("+CIPSSL=?"));
-      if (waitResponse(GF(GSM_NL "+CIPSSL:")) != 1) { return false; }
+      if (waitResponse(GF(AT_NL "+CIPSSL:")) != 1) { return false; }
       return waitResponse() == 1;
   #endif
     }
@@ -300,8 +300,8 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     sendAT(GF("+CIFSR;E0"));
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, "");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, "");
     res.trim();
     return res;
   }
@@ -403,7 +403,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
   // May not return the "+CCID" before the number
   String getSimCCIDImpl() {
     sendAT(GF("+CCID"));
-    if (waitResponse(GF(GSM_NL)) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL)) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     // Trim out the CCID header in case it is there
@@ -454,7 +454,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
   uint8_t getVolume() {
     // Get speaker volume
     sendAT(GF("+CLVL?"));
-    if (waitResponse(GF(GSM_NL)) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL)) != 1) { return 0; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.replace("+CLVL:", "");
@@ -530,9 +530,9 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     sendAT(GF("+CIPSTART="), mux, ',', GF("\"TCP"), GF("\",\""), host,
            GF("\","), port);
     rsp = waitResponse(
-        timeout_ms, GF("CONNECT OK" GSM_NL), GF("CONNECT FAIL" GSM_NL),
-        GF("ALREADY CONNECT" GSM_NL), GF("ERROR" GSM_NL),
-        GF("CLOSE OK" GSM_NL));  // Happens when HTTPS handshake fails
+        timeout_ms, GF("CONNECT OK" AT_NL), GF("CONNECT FAIL" AT_NL),
+        GF("ALREADY CONNECT" AT_NL), GF("ERROR" AT_NL),
+        GF("CLOSE OK" AT_NL));  // Happens when HTTPS handshake fails
     return (1 == rsp);
   }
 
@@ -541,7 +541,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "DATA ACCEPT:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "DATA ACCEPT:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     return streamGetIntBefore('\n');
   }
@@ -624,7 +624,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
+    if (data.endsWith(GF(AT_NL "+CIPRXGET:"))) {
       int8_t mode = streamGetIntBefore(',');
       if (mode == 1) {
         int8_t mux = streamGetIntBefore('\n');
@@ -638,7 +638,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
         data += mode;
         return false;
       }
-    } else if (data.endsWith(GF(GSM_NL "+RECEIVE:"))) {
+    } else if (data.endsWith(GF(AT_NL "+RECEIVE:"))) {
       int8_t  mux = streamGetIntBefore(',');
       int16_t len = streamGetIntBefore('\n');
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
@@ -648,8 +648,8 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
       data = "";
       // DBG("### Got Data:", len, "on", mux);
       return true;
-    } else if (data.endsWith(GF("CLOSED" GSM_NL))) {
-      int8_t nl   = data.lastIndexOf(GSM_NL, data.length() - 8);
+    } else if (data.endsWith(GF("CLOSED" AT_NL))) {
+      int8_t nl   = data.lastIndexOf(AT_NL, data.length() - 8);
       int8_t coma = data.indexOf(',', nl + 2);
       int8_t mux  = data.substring(nl + 2, coma).toInt();
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
diff --git a/src/TinyGsmClientSIM808.h b/src/TinyGsmClientSIM808.h
index 7398bfa..67de0b6 100644
--- a/src/TinyGsmClientSIM808.h
+++ b/src/TinyGsmClientSIM808.h
@@ -14,7 +14,9 @@
 #include "TinyGsmGPS.tpp"
 #include "TinyGsmBluetooth.tpp"
 
-class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, public TinyGsmBluetooth<TinyGsmSim808> {
+class TinyGsmSim808 : public TinyGsmSim800,
+                      public TinyGsmGPS<TinyGsmSim808>,
+                      public TinyGsmBluetooth<TinyGsmSim808> {
   friend class TinyGsmGPS<TinyGsmSim808>;
   friend class TinyGsmBluetooth<TinyGsmSim808>;
 
@@ -43,7 +45,7 @@ class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, pu
   // works only with ans SIM808 V2
   String getGPSrawImpl() {
     sendAT(GF("+CGNSINF"));
-    if (waitResponse(10000L, GF(GSM_NL "+CGNSINF:")) != 1) { return ""; }
+    if (waitResponse(10000L, GF(AT_NL "+CGNSINF:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -57,7 +59,7 @@ class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, pu
                   int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
                   int* minute = 0, int* second = 0) {
     sendAT(GF("+CGNSINF"));
-    if (waitResponse(10000L, GF(GSM_NL "+CGNSINF:")) != 1) { return false; }
+    if (waitResponse(10000L, GF(AT_NL "+CGNSINF:")) != 1) { return false; }
 
     streamSkipUntil(',');                // GNSS run status
     if (streamGetIntBefore(',') == 1) {  // fix status
@@ -129,11 +131,11 @@ class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, pu
     waitResponse();
     return false;
   }
-  
-    /*
+
+  /*
    * Bluetooth functions
    */
-   
+
   bool enableBluetoothImpl() {
     sendAT(GF("+BTPOWER=1"));
     if (waitResponse() != 1) { return false; }
@@ -145,22 +147,18 @@ class TinyGsmSim808 : public TinyGsmSim800, public TinyGsmGPS<TinyGsmSim808>, pu
     if (waitResponse() != 1) { return false; }
     return true;
   }
-  
+
   bool setBluetoothVisibilityImpl(bool visible) {
     sendAT(GF("+BTVIS="), visible);
-    if (waitResponse() != 1) {
-      return false;
-    }
-    
+    if (waitResponse() != 1) { return false; }
+
     return true;
   }
 
   bool setBluetoothHostNameImpl(const char* name) {
     sendAT(GF("+BTHOST="), name);
-    if (waitResponse() != 1) {
-      return false;
-    }
-    
+    if (waitResponse() != 1) { return false; }
+
     return true;
   }
 };
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 3d3b28d..664f2f5 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 7
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -264,13 +264,13 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     sendAT(GF("+CGMI"));
     String res1;
     if (waitResponse(1000L, res1) != 1) { return "u-blox Cellular Modem"; }
-    res1.replace(GSM_NL "OK" GSM_NL, "");
+    res1.replace(AT_NL "OK" AT_NL, "");
     res1.trim();
 
     sendAT(GF("+GMM"));
     String res2;
     if (waitResponse(1000L, res2) != 1) { return "u-blox Cellular Modem"; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.trim();
 
     String name = res1 + String(' ') + res2;
@@ -406,7 +406,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
   // This uses "CGSN" instead of "GSN"
   String getIMEIImpl() {
     sendAT(GF("+CGSN"));
-    if (waitResponse(GF(GSM_NL)) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL)) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -436,12 +436,12 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     // <aid_mode> - 0: no aiding (default)
     // <GNSS_systems> - 3: GPS + SBAS (default)
     sendAT(GF("+UGPS=1,0,3"));
-    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
+    if (waitResponse(10000L, GF(AT_NL "+UGPS:")) != 1) { return false; }
     return waitResponse(10000L) == 1;
   }
   bool disableGPSImpl() {
     sendAT(GF("+UGPS=0"));
-    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
+    if (waitResponse(10000L, GF(AT_NL "+UGPS:")) != 1) { return false; }
     return waitResponse(10000L) == 1;
   }
   String inline getUbloxLocationRaw(int8_t sensor) {
@@ -461,7 +461,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     // wait for first "OK"
     if (waitResponse(10000L) != 1) { return ""; }
     // wait for the final result - wait full timeout time
-    if (waitResponse(120000L, GF(GSM_NL "+UULOC:")) != 1) { return ""; }
+    if (waitResponse(120000L, GF(AT_NL "+UULOC:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -496,7 +496,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     // wait for first "OK"
     if (waitResponse(10000L) != 1) { return false; }
     // wait for the final result - wait full timeout time
-    if (waitResponse(120000L, GF(GSM_NL "+UULOC: ")) != 1) { return false; }
+    if (waitResponse(120000L, GF(AT_NL "+UULOC: ")) != 1) { return false; }
 
     // +UULOC: <date>, <time>, <lat>, <long>, <alt>, <uncertainty>, <speed>,
     // <direction>, <vertical_acc>, <sensor_used>, <SV_used>, <antenna_status>,
@@ -592,7 +592,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
 
   int8_t getBattPercentImpl() {
     sendAT(GF("+CIND?"));
-    if (waitResponse(GF(GSM_NL "+CIND:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CIND:")) != 1) { return 0; }
 
     int8_t res     = streamGetIntBefore(',');
     int8_t percent = res * 20;  // return is 0-5
@@ -620,7 +620,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     sendAT(GF("+UTEMP=0"));  // Would use 1 for Fahrenheit
     if (waitResponse() != 1) { return static_cast<float>(-9999); }
     sendAT(GF("+UTEMP?"));
-    if (waitResponse(GF(GSM_NL "+UTEMP:")) != 1) {
+    if (waitResponse(GF(AT_NL "+UTEMP:")) != 1) {
       return static_cast<float>(-9999);
     }
     int16_t res  = streamGetIntBefore('\n');
@@ -641,7 +641,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     // create a socket
     sendAT(GF("+USOCR=6"));
     // reply is +USOCR: ## of socket created
-    if (waitResponse(GF(GSM_NL "+USOCR:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+USOCR:")) != 1) { return false; }
     *mux = streamGetIntBefore('\n');
     waitResponse();
 
@@ -675,7 +675,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
           "the URC '+UUSOCO' appears.");
       sendAT(GF("+USOCO="), *mux, ",\"", host, "\",", port, ",1");
       if (waitResponse(timeout_ms - (millis() - startMillis),
-                       GF(GSM_NL "+UUSOCO:")) == 1) {
+                       GF(AT_NL "+UUSOCO:")) == 1) {
         streamGetIntBefore(',');  // skip repeated mux
         int8_t connection_status = streamGetIntBefore('\n');
         DBG("### Waited", millis() - startMillis, "ms for socket to open");
@@ -700,7 +700,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     delay(50);
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "+USOWR:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+USOWR:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     int16_t sent = streamGetIntBefore('\n');
     waitResponse();  // sends back OK after the confirmation of number sent
@@ -710,7 +710,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
   size_t modemRead(size_t size, uint8_t mux) {
     if (!sockets[mux]) return 0;
     sendAT(GF("+USORD="), mux, ',', (uint16_t)size);
-    if (waitResponse(GF(GSM_NL "+USORD:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+USORD:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     int16_t len = streamGetIntBefore(',');
     streamSkipUntil('\"');
@@ -728,7 +728,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     // NOTE:  Querying a closed socket gives an error "operation not allowed"
     sendAT(GF("+USORD="), mux, ",0");
     size_t  result = 0;
-    uint8_t res    = waitResponse(GF(GSM_NL "+USORD:"));
+    uint8_t res    = waitResponse(GF(AT_NL "+USORD:"));
     // Will give error "operation not allowed" when attempting to read a socket
     // that you have already told to close
     if (res == 1) {
@@ -745,7 +745,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
   bool modemGetConnected(uint8_t mux) {
     // NOTE:  Querying a closed socket gives an error "operation not allowed"
     sendAT(GF("+USOCTL="), mux, ",10");
-    uint8_t res = waitResponse(GF(GSM_NL "+USOCTL:"));
+    uint8_t res = waitResponse(GF(AT_NL "+USOCTL:"));
     if (res != 1) { return false; }
 
     streamSkipUntil(',');  // Skip mux
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 7cf196b..73e6a70 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -13,9 +13,9 @@
 
 #define TINY_GSM_MUX_COUNT 6
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmCalling.tpp"
@@ -283,7 +283,7 @@ class TinyGsmSequansMonarch
     if (!testAT()) { return false; }
 
     sendAT(GF("+CFUN=0"));
-    int8_t res = waitResponse(20000L, GFP(GSM_OK), GFP(GSM_ERROR),
+    int8_t res = waitResponse(20000L, GFP(AT_OK), GFP(GSM_ERROR),
                               GF("+SYSSTART"));
     if (res != 1 && res != 3) { return false; }
 
@@ -382,7 +382,7 @@ class TinyGsmSequansMonarch
  protected:
   String getSimCCIDImpl() {
     sendAT(GF("+SQNCCID"));
-    if (waitResponse(GF(GSM_NL "+SQNCCID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+SQNCCID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -481,8 +481,8 @@ class TinyGsmSequansMonarch
     // <acceptAnyRemote> = Applies to UDP only
     sendAT(GF("+SQNSD="), mux, ",0,", port, ',', GF("\""), host, GF("\""),
            ",0,0,1");
-    rsp = waitResponse((timeout_ms - (millis() - startMillis)), GFP(GSM_OK),
-                       GFP(GSM_ERROR), GF("NO CARRIER" GSM_NL));
+    rsp = waitResponse((timeout_ms - (millis() - startMillis)), GFP(AT_OK),
+                       GFP(GSM_ERROR), GF("NO CARRIER" AT_NL));
 
     // creation of socket failed immediately.
     if (rsp != 1) { return false; }
@@ -503,7 +503,7 @@ class TinyGsmSequansMonarch
     }
 
     sendAT(GF("+SQNSSENDEXT="), mux, ',', (uint16_t)len);
-    waitResponse(10000L, GF(GSM_NL "> "));
+    waitResponse(10000L, GF(AT_NL "> "));
     // Translate bytes into char to be able to send them as an hex string
     char char_command[2];
     for (size_t i = 0; i < len; i++) {
@@ -523,7 +523,7 @@ class TinyGsmSequansMonarch
     // bool gotPrompt = false;
     // while (nAttempts > 0 && !gotPrompt) {
     //   sendAT(GF("+SQNSSEND="), mux);
-    //   if (waitResponse(5000, GF(GSM_NL "> ")) == 1) {
+    //   if (waitResponse(5000, GF(AT_NL "> ")) == 1) {
     //     gotPrompt = true;
     //   }
     //   nAttempts--;
@@ -582,7 +582,7 @@ class TinyGsmSequansMonarch
     // six possible sockets.
     sendAT(GF("+SQNSS"));
     for (int muxNo = 1; muxNo <= TINY_GSM_MUX_COUNT; muxNo++) {
-      if (waitResponse(GFP(GSM_OK), GF(GSM_NL "+SQNSS: ")) != 2) { break; }
+      if (waitResponse(GFP(AT_OK), GF(AT_NL "+SQNSS: ")) != 2) { break; }
       uint8_t status = 0;
       // if (streamGetIntBefore(',') != muxNo) { // check the mux no
       //   DBG("### Warning: misaligned mux numbers!");
@@ -615,7 +615,7 @@ class TinyGsmSequansMonarch
    */
  public:
   bool handleURCs(String& data) {
-    if (data.endsWith(GF(GSM_NL "+SQNSRING:"))) {
+    if (data.endsWith(GF(AT_NL "+SQNSRING:"))) {
       int8_t  mux = streamGetIntBefore(',');
       int16_t len = streamGetIntBefore('\n');
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT &&
@@ -644,7 +644,7 @@ class TinyGsmSequansMonarch
 
  protected:
   GsmClientSequansMonarch* sockets[TINY_GSM_MUX_COUNT];
-  // GSM_NL (\r\n) is not accepted with SQNSSENDEXT in data mode so use \n
+  // AT_NL (\r\n) is not accepted with SQNSSENDEXT in data mode so use \n
   const char* gsmNL = "\n";
 };
 
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index f729981..36f27bf 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -14,9 +14,9 @@
 
 #define TINY_GSM_MUX_COUNT 7
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -210,13 +210,13 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     sendAT(GF("+CGMI"));
     String res1;
     if (waitResponse(1000L, res1) != 1) { return "u-blox Cellular Modem"; }
-    res1.replace(GSM_NL "OK" GSM_NL, "");
+    res1.replace(AT_NL "OK" AT_NL, "");
     res1.trim();
 
     sendAT(GF("+GMM"));
     String res2;
     if (waitResponse(1000L, res2) != 1) { return "u-blox Cellular Modem"; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.trim();
 
     String name = res1 + String(' ') + res2;
@@ -303,7 +303,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
 
   String getLocalIPImpl() {
     sendAT(GF("+UPSND=0,0"));
-    if (waitResponse(GF(GSM_NL "+UPSND:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+UPSND:")) != 1) { return ""; }
     streamSkipUntil(',');   // Skip PSD profile
     streamSkipUntil('\"');  // Skip request type
     String res = stream.readStringUntil('\"');
@@ -402,7 +402,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
   // This uses "CGSN" instead of "GSN"
   String getIMEIImpl() {
     sendAT(GF("+CGSN"));
-    if (waitResponse(GF(GSM_NL)) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL)) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -436,12 +436,12 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     // <aid_mode> - 0: no aiding (default)
     // <GNSS_systems> - 3: GPS + SBAS (default)
     sendAT(GF("+UGPS=1,0,3"));
-    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
+    if (waitResponse(10000L, GF(AT_NL "+UGPS:")) != 1) { return false; }
     return waitResponse(10000L) == 1;
   }
   bool disableGPSImpl() {
     sendAT(GF("+UGPS=0"));
-    if (waitResponse(10000L, GF(GSM_NL "+UGPS:")) != 1) { return false; }
+    if (waitResponse(10000L, GF(AT_NL "+UGPS:")) != 1) { return false; }
     return waitResponse(10000L) == 1;
   }
   String inline getUbloxLocationRaw(int8_t sensor) {
@@ -461,7 +461,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     // wait for first "OK"
     if (waitResponse(10000L) != 1) { return ""; }
     // wait for the final result - wait full timeout time
-    if (waitResponse(120000L, GF(GSM_NL "+UULOC:")) != 1) { return ""; }
+    if (waitResponse(120000L, GF(AT_NL "+UULOC:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -496,7 +496,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     // wait for first "OK"
     if (waitResponse(10000L) != 1) { return false; }
     // wait for the final result - wait full timeout time
-    if (waitResponse(120000L, GF(GSM_NL "+UULOC: ")) != 1) { return false; }
+    if (waitResponse(120000L, GF(AT_NL "+UULOC: ")) != 1) { return false; }
 
     // +UULOC: <date>, <time>, <lat>, <long>, <alt>, <uncertainty>, <speed>,
     // <direction>, <vertical_acc>, <sensor_used>, <SV_used>, <antenna_status>,
@@ -592,7 +592,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
 
   int8_t getBattPercentImpl() {
     sendAT(GF("+CIND?"));
-    if (waitResponse(GF(GSM_NL "+CIND:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CIND:")) != 1) { return 0; }
 
     int8_t res     = streamGetIntBefore(',');
     int8_t percent = res * 20;  // return is 0-5
@@ -631,7 +631,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     // create a socket
     sendAT(GF("+USOCR=6"));
     // reply is +USOCR: ## of socket created
-    if (waitResponse(GF(GSM_NL "+USOCR:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+USOCR:")) != 1) { return false; }
     *mux = streamGetIntBefore('\n');
     waitResponse();
 
@@ -665,7 +665,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     delay(50);
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "+USOWR:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+USOWR:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     int16_t sent = streamGetIntBefore('\n');
     waitResponse();  // sends back OK after the confirmation of number sent
@@ -675,7 +675,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
   size_t modemRead(size_t size, uint8_t mux) {
     if (!sockets[mux]) return 0;
     sendAT(GF("+USORD="), mux, ',', (uint16_t)size);
-    if (waitResponse(GF(GSM_NL "+USORD:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+USORD:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     int16_t len = streamGetIntBefore(',');
     streamSkipUntil('\"');
@@ -693,7 +693,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     // NOTE:  Querying a closed socket gives an error "operation not allowed"
     sendAT(GF("+USORD="), mux, ",0");
     size_t  result = 0;
-    uint8_t res    = waitResponse(GF(GSM_NL "+USORD:"));
+    uint8_t res    = waitResponse(GF(AT_NL "+USORD:"));
     // Will give error "operation not allowed" when attempting to read a socket
     // that you have already told to close
     if (res == 1) {
@@ -710,7 +710,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
   bool modemGetConnected(uint8_t mux) {
     // NOTE:  Querying a closed socket gives an error "operation not allowed"
     sendAT(GF("+USOCTL="), mux, ",10");
-    uint8_t res = waitResponse(GF(GSM_NL "+USOCTL:"));
+    uint8_t res = waitResponse(GF(AT_NL "+USOCTL:"));
     if (res != 1) { return false; }
 
     streamSkipUntil(',');  // Skip mux
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 4a28763..faf62a9 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -20,9 +20,9 @@
 // XBee's have a default guard time of 1 second (1000ms, 10 extra for safety
 // here)
 #define TINY_GSM_XBEE_GUARD_TIME 1010
-#ifdef GSM_NL
-#undef GSM_NL
-#define GSM_NL "\r"  // NOTE:  define before including TinyGsmModem!
+#ifdef AT_NL
+#undef AT_NL
+#define AT_NL "\r"  // NOTE:  define before including TinyGsmModem!
 #endif
 
 #include "TinyGsmBattery.tpp"
@@ -1322,7 +1322,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
             // // Ask for information about any open sockets
             // sendAT(GF("SI"));
             // String open_socks = stream.readStringUntil('\r');
-            // open_socks.replace(GSM_NL, "");
+            // open_socks.replace(AT_NL, "");
             // open_socks.trim();
             // if (open_socks != "") {
             //   // In transparent mode, only socket 0 should be possible
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index b0a06f7..75b5c09 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -11,34 +11,34 @@
 
 #include "TinyGsmCommon.h"
 
-#ifndef GSM_NL
-#define GSM_NL "\r\n"
+#ifndef AT_NL
+#define AT_NL "\r\n"
 #endif
 
-#ifndef GSM_OK
-#define GSM_OK "OK"
+#ifndef AT_OK
+#define AT_OK "OK"
 #endif
 
-#ifndef GSM_ERROR
-#define GSM_ERROR "ERROR"
+#ifndef AT_ERROR
+#define AT_ERROR "ERROR"
 #endif
 
 #if defined TINY_GSM_DEBUG
-#ifndef GSM_VERBOSE
-#define GSM_VERBOSE "+CME ERROR:"
+#ifndef AT_VERBOSE
+#define AT_VERBOSE "+CME ERROR:"
 #endif
 
-#ifndef GSM_VERBOSE_2
-#define GSM_VERBOSE_2 "+CMS ERROR:"
+#ifndef AT_VERBOSE_2
+#define AT_VERBOSE_2 "+CMS ERROR:"
 #endif
 #endif
 
-static const char GSM_OK[] TINY_GSM_PROGMEM    = GSM_OK GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = GSM_ERROR GSM_NL;
+static const char GSM_OK[] TINY_GSM_PROGMEM    = AT_OK AT_NL;
+static const char GSM_ERROR[] TINY_GSM_PROGMEM = AT_ERROR AT_NL;
 
 #if defined       TINY_GSM_DEBUG
-static const char GSM_VERBOSE[] TINY_GSM_PROGMEM   = GSM_VERBOSE;
-static const char GSM_VERBOSE_2[] TINY_GSM_PROGMEM = GSM_VERBOSE_2;
+static const char GSM_VERBOSE[] TINY_GSM_PROGMEM   = AT_VERBOSE;
+static const char GSM_VERBOSE_2[] TINY_GSM_PROGMEM = AT_VERBOSE_2;
 #endif
 
 template <class modemType>
@@ -55,7 +55,7 @@ class TinyGsmModem {
   }
   template <typename... Args>
   inline void sendAT(Args... cmd) {
-    thisModem().streamWrite("AT", cmd..., GSM_NL);
+    thisModem().streamWrite("AT", cmd..., AT_NL);
     thisModem().stream.flush();
     TINY_GSM_YIELD(); /* DBG("### AT:", cmd...); */
   }
@@ -219,8 +219,8 @@ class TinyGsmModem {
           goto finish;
         }
 #if defined TINY_GSM_DEBUG
-        else if (data.endsWith(GFP(GSM_VERBOSE)) ||
-                 data.endsWith(GFP(GSM_VERBOSE_2))) {
+        else if (data.endsWith(GFP(AT_VERBOSE)) ||
+                 data.endsWith(GFP(AT_VERBOSE_2))) {
           // DBG(GF("Verbose details <<<"));
           // Read out the verbose message, until whichever type of new line
           // comes first
@@ -241,7 +241,7 @@ class TinyGsmModem {
       if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
     }
-    // data.replace(GSM_NL, "/");
+    // data.replace(AT_NL, "/");
     // DBG('<', index, '>', data);
     return index;
   }

From 3b0fc287841fd36ee6e91e3d12fbcd67f0211219 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 13 May 2024 14:14:55 -0400
Subject: [PATCH 043/100] Small debug change

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmModem.tpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 75b5c09..a2dee46 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -236,12 +236,13 @@ class TinyGsmModem {
       }
     } while (millis() - startMillis < timeout_ms);
   finish:
+    // data.replace("\r", "←");
+    // data.replace("\n", "↓");
     if (!index) {
       data.trim();
       if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
     }
-    // data.replace(AT_NL, "/");
     // DBG('<', index, '>', data);
     return index;
   }

From 3463e94e589a70e582296276079c6dbae110a7b6 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 13 May 2024 14:44:28 -0400
Subject: [PATCH 044/100] Another debug fix

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmModem.tpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index a2dee46..03786ae 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -219,8 +219,8 @@ class TinyGsmModem {
           goto finish;
         }
 #if defined TINY_GSM_DEBUG
-        else if (data.endsWith(GFP(AT_VERBOSE)) ||
-                 data.endsWith(GFP(AT_VERBOSE_2))) {
+        else if (data.endsWith(GFP(GSM_VERBOSE)) ||
+                 data.endsWith(GFP(GSM_VERBOSE_2))) {
           // DBG(GF("Verbose details <<<"));
           // Read out the verbose message, until whichever type of new line
           // comes first
@@ -242,8 +242,9 @@ class TinyGsmModem {
       data.trim();
       if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+    } else {
+      // DBG('<', index, '>', data);
     }
-    // DBG('<', index, '>', data);
     return index;
   }
 

From 86bb0f7cae263ab56818960293a0bb0b0e6aa314 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 14 May 2024 13:48:08 -0400
Subject: [PATCH 045/100] Replace NULL with nullptr

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h             | 12 ++++----
 src/TinyGsmClientBG96.h           | 50 +++++++++++++++----------------
 src/TinyGsmClientESP8266.h        |  4 +--
 src/TinyGsmClientM590.h           | 10 +++----
 src/TinyGsmClientM95.h            | 10 +++----
 src/TinyGsmClientMC60.h           | 10 +++----
 src/TinyGsmClientSIM5360.h        | 12 ++++----
 src/TinyGsmClientSIM7000.h        | 10 +++----
 src/TinyGsmClientSIM7000SSL.h     | 10 +++----
 src/TinyGsmClientSIM7080.h        | 10 +++----
 src/TinyGsmClientSIM70xx.h        | 34 ++++++++++-----------
 src/TinyGsmClientSIM7600.h        | 38 +++++++++++------------
 src/TinyGsmClientSIM800.h         | 12 ++++----
 src/TinyGsmClientSIM808.h         | 26 ++++++++--------
 src/TinyGsmClientSaraR4.h         | 41 ++++++++++++-------------
 src/TinyGsmClientSequansMonarch.h | 12 ++++----
 src/TinyGsmClientUBLOX.h          | 41 ++++++++++++-------------
 src/TinyGsmClientXBee.h           | 14 ++++-----
 src/TinyGsmGPRS.tpp               |  4 +--
 src/TinyGsmGSMLocation.tpp        | 18 +++++------
 src/TinyGsmModem.tpp              | 32 ++++++++++----------
 src/TinyGsmSMS.tpp                | 16 +++++-----
 src/TinyGsmTCP.tpp                |  6 ++--
 src/TinyGsmTime.tpp               | 14 ++++-----
 24 files changed, 224 insertions(+), 222 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index 4763ecb..875694b 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -125,7 +125,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientA6"));
 
@@ -151,7 +151,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -172,7 +172,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     sendAT(GF("+RST=1"));
     delay(3000);
@@ -218,8 +218,8 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     sendAT(GF("+CGATT=1"));
@@ -438,7 +438,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     if (waitResponse(2000L, GF(AT_NL ">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(10000L, GFP(GSM_OK), GF(AT_NL "FAIL")) != 1) { return 0; }
+    if (waitResponse(10000L, GFP(AT_OK), GF(AT_NL "FAIL")) != 1) { return 0; }
     return len;
   }
 
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 70f6a2e..c80b540 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -159,7 +159,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientBG96"));
 
@@ -187,7 +187,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -201,7 +201,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(1, true)) { return false; }
     waitResponse(10000L, GF("APP RDY"));
@@ -256,8 +256,8 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Configure the TCPIP Context
@@ -392,20 +392,20 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
                             // 0, it is the type of error.
 
     // Set pointers
-    if (lat != NULL) *lat = ilat;
-    if (lon != NULL) *lon = ilon;
-    if (speed != NULL) *speed = ispeed;
-    if (alt != NULL) *alt = ialt;
-    if (vsat != NULL) *vsat = 0;
-    if (usat != NULL) *usat = iusat;
-    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (lat != nullptr) *lat = ilat;
+    if (lon != nullptr) *lon = ilon;
+    if (speed != nullptr) *speed = ispeed;
+    if (alt != nullptr) *alt = ialt;
+    if (vsat != nullptr) *vsat = 0;
+    if (usat != nullptr) *usat = iusat;
+    if (accuracy != nullptr) *accuracy = iaccuracy;
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = static_cast<int>(secondWithSS);
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
     waitResponse();  // Final OK
     return true;
@@ -463,13 +463,13 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
 
     // Set pointers
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = isec;
-    if (timezone != NULL) *timezone = static_cast<float>(itimezone) / 4.0;
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = isec;
+    if (timezone != nullptr) *timezone = static_cast<float>(itimezone) / 4.0;
 
     // Final OK
     waitResponse();  // Ends with OK
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 8f8ab52..b947378 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -142,7 +142,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientESP8266"));
 
@@ -200,7 +200,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     sendAT(GF("+RST"));
     if (waitResponse(10000L) != 1) { return false; }
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index 558f71b..a6aff41 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -114,7 +114,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientM590"));
 
@@ -134,7 +134,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -167,7 +167,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(15)) { return false; }
     // MODEM:STARTUP
@@ -218,8 +218,8 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     sendAT(GF("+XISP=0"));
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index fa3212f..465dbd7 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -153,7 +153,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientM95"));
 
@@ -180,7 +180,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -194,7 +194,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     sendAT(GF("+CFUN=0"));
     if (waitResponse(10000L, GF("NORMAL POWER DOWN"), GF("OK"), GF("FAIL")) ==
@@ -261,8 +261,8 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // select foreground context 0 = VIRTUAL_UART_1
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index a5400f7..7602013 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -152,7 +152,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientMC60"));
 
@@ -179,7 +179,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -193,7 +193,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(0)) { return false; }
     if (!setPhoneFunctionality(1, true)) { return false; }
@@ -247,8 +247,8 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // select foreground context 0 = VIRTUAL_UART_1
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 4a4b54e..dc3abd6 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -153,7 +153,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSIM5360"));
 
@@ -181,7 +181,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -214,7 +214,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     sendAT(GF("+REBOOT"));
     // Should return an 'OK' after reboot command is sent
@@ -297,8 +297,8 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();  // Make sure we're not connected first
 
     // Define the PDP context
@@ -555,7 +555,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
       };
       buf[0] = stream.read();
       buf[1] = stream.read();
-      char c = strtol(buf, NULL, 16);
+      char c = strtol(buf, nullptr, 16);
 #else
       while (!stream.available() &&
              (millis() - startMillis < sockets[mux]->_timeout)) {
diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index 721a366..0f821af 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -100,7 +100,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSIM7000"));
 
@@ -128,7 +128,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -162,8 +162,8 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Bearer settings for applications based on IP
@@ -342,7 +342,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
       };
       buf[0] = stream.read();
       buf[1] = stream.read();
-      char c = strtol(buf, NULL, 16);
+      char c = strtol(buf, nullptr, 16);
 #else
       while (!stream.available() &&
              (millis() - startMillis < sockets[mux]->_timeout)) {
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index e6c8c92..10d5951 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -127,7 +127,7 @@ class TinyGsmSim7000SSL
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSIM7000SSL"));
 
@@ -155,7 +155,7 @@ class TinyGsmSim7000SSL
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -179,7 +179,7 @@ class TinyGsmSim7000SSL
     // modemGetAvailable checks all socks, so we only want to do it once
     // modemGetAvailable calls modemGetConnected(), which also checks allf
     if (check_socks) { modemGetAvailable(0); }
-    while (stream.available()) { waitResponse(15, NULL, NULL); }
+    while (stream.available()) { waitResponse(15, nullptr, nullptr); }
   }
 
   /*
@@ -215,8 +215,8 @@ class TinyGsmSim7000SSL
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Define the PDP context
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index 128d70b..cec1c13 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -125,7 +125,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSIM7080"));
 
@@ -153,7 +153,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -177,7 +177,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     // modemGetAvailable checks all socks, so we only want to do it once
     // modemGetAvailable calls modemGetConnected(), which also checks allf
     if (check_socks) { modemGetAvailable(0); }
-    while (stream.available()) { waitResponse(15, NULL, NULL); }
+    while (stream.available()) { waitResponse(15, nullptr, nullptr); }
   }
 
   /*
@@ -213,8 +213,8 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Define the PDP context
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 3852467..a39c6cf 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -74,7 +74,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     return thisModem().initImpl(pin);
   }
 
@@ -111,7 +111,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     thisModem().sendAT(GF("E0"));  // Echo Off
     thisModem().waitResponse();
     if (!thisModem().setPhoneFunctionality(0)) { return false; }
@@ -240,8 +240,8 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
    */
  protected:
   // should implement in sub-classes
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     return thisModem().gprsConnectImpl(apn, user, pwd);
   }
 
@@ -357,20 +357,20 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
       thisModem().streamSkipUntil('\n');            // VPA
 
       // Set pointers
-      if (lat != NULL) *lat = ilat;
-      if (lon != NULL) *lon = ilon;
-      if (speed != NULL) *speed = ispeed;
-      if (alt != NULL) *alt = ialt;
-      if (vsat != NULL) *vsat = ivsat;
-      if (usat != NULL) *usat = iusat;
-      if (accuracy != NULL) *accuracy = iaccuracy;
+      if (lat != nullptr) *lat = ilat;
+      if (lon != nullptr) *lon = ilon;
+      if (speed != nullptr) *speed = ispeed;
+      if (alt != nullptr) *alt = ialt;
+      if (vsat != nullptr) *vsat = ivsat;
+      if (usat != nullptr) *usat = iusat;
+      if (accuracy != nullptr) *accuracy = iaccuracy;
       if (iyear < 2000) iyear += 2000;
-      if (year != NULL) *year = iyear;
-      if (month != NULL) *month = imonth;
-      if (day != NULL) *day = iday;
-      if (hour != NULL) *hour = ihour;
-      if (minute != NULL) *minute = imin;
-      if (second != NULL) *second = static_cast<int>(secondWithSS);
+      if (year != nullptr) *year = iyear;
+      if (month != nullptr) *month = imonth;
+      if (day != nullptr) *day = iday;
+      if (hour != nullptr) *hour = ihour;
+      if (minute != nullptr) *minute = imin;
+      if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
       thisModem().waitResponse();
       return true;
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 5ead4ed..db590d9 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -161,7 +161,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSIM7600"));
 
@@ -189,7 +189,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -222,7 +222,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     sendAT(GF("+CRESET"));
     if (waitResponse(10000L) != 1) { return false; }
@@ -302,8 +302,8 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();  // Make sure we're not connected first
 
     // Define the PDP context
@@ -509,24 +509,24 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
       streamSkipUntil('\n');  // TODO(?) is one more field reported??
 
       // Set pointers
-      if (lat != NULL)
+      if (lat != nullptr)
         *lat = (floor(ilat / 100) + fmod(ilat, 100.) / 60) *
             (north == 'N' ? 1 : -1);
-      if (lon != NULL)
+      if (lon != nullptr)
         *lon = (floor(ilon / 100) + fmod(ilon, 100.) / 60) *
             (east == 'E' ? 1 : -1);
-      if (speed != NULL) *speed = ispeed;
-      if (alt != NULL) *alt = ialt;
-      if (vsat != NULL) *vsat = ivsat;
-      if (usat != NULL) *usat = iusat;
-      if (accuracy != NULL) *accuracy = iaccuracy;
+      if (speed != nullptr) *speed = ispeed;
+      if (alt != nullptr) *alt = ialt;
+      if (vsat != nullptr) *vsat = ivsat;
+      if (usat != nullptr) *usat = iusat;
+      if (accuracy != nullptr) *accuracy = iaccuracy;
       if (iyear < 2000) iyear += 2000;
-      if (year != NULL) *year = iyear;
-      if (month != NULL) *month = imonth;
-      if (day != NULL) *day = iday;
-      if (hour != NULL) *hour = ihour;
-      if (minute != NULL) *minute = imin;
-      if (second != NULL) *second = static_cast<int>(secondWithSS);
+      if (year != nullptr) *year = iyear;
+      if (month != nullptr) *month = imonth;
+      if (day != nullptr) *day = iday;
+      if (hour != nullptr) *hour = ihour;
+      if (minute != nullptr) *minute = imin;
+      if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
       waitResponse();
       return true;
@@ -678,7 +678,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
       };
       buf[0] = stream.read();
       buf[1] = stream.read();
-      char c = strtol(buf, NULL, 16);
+      char c = strtol(buf, nullptr, 16);
 #else
       while (!stream.available() &&
              (millis() - startMillis < sockets[mux]->_timeout)) {
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 6ff76a7..ac67769 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -153,7 +153,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSIM800"));
 
@@ -184,7 +184,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -249,7 +249,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     sendAT(GF("&W"));
     waitResponse();
@@ -310,8 +310,8 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Bearer settings for applications based on IP
@@ -577,7 +577,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
       };
       buf[0] = stream.read();
       buf[1] = stream.read();
-      char c = strtol(buf, NULL, 16);
+      char c = strtol(buf, nullptr, 16);
 #else
       while (!stream.available() &&
              (millis() - startMillis < sockets[mux]->_timeout)) {
diff --git a/src/TinyGsmClientSIM808.h b/src/TinyGsmClientSIM808.h
index 67de0b6..f9ce54e 100644
--- a/src/TinyGsmClientSIM808.h
+++ b/src/TinyGsmClientSIM808.h
@@ -108,20 +108,20 @@ class TinyGsmSim808 : public TinyGsmSim800,
       streamSkipUntil('\n');            // VPA
 
       // Set pointers
-      if (lat != NULL) *lat = ilat;
-      if (lon != NULL) *lon = ilon;
-      if (speed != NULL) *speed = ispeed;
-      if (alt != NULL) *alt = ialt;
-      if (vsat != NULL) *vsat = ivsat;
-      if (usat != NULL) *usat = iusat;
-      if (accuracy != NULL) *accuracy = iaccuracy;
+      if (lat != nullptr) *lat = ilat;
+      if (lon != nullptr) *lon = ilon;
+      if (speed != nullptr) *speed = ispeed;
+      if (alt != nullptr) *alt = ialt;
+      if (vsat != nullptr) *vsat = ivsat;
+      if (usat != nullptr) *usat = iusat;
+      if (accuracy != nullptr) *accuracy = iaccuracy;
       if (iyear < 2000) iyear += 2000;
-      if (year != NULL) *year = iyear;
-      if (month != NULL) *month = imonth;
-      if (day != NULL) *day = iday;
-      if (hour != NULL) *hour = ihour;
-      if (minute != NULL) *minute = imin;
-      if (second != NULL) *second = static_cast<int>(secondWithSS);
+      if (year != nullptr) *year = iyear;
+      if (month != nullptr) *month = imonth;
+      if (day != nullptr) *day = iday;
+      if (hour != nullptr) *hour = ihour;
+      if (minute != nullptr) *minute = imin;
+      if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
       waitResponse();
       return true;
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 664f2f5..9570e51 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -102,7 +102,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
       sock_connected = at->modemConnect(host, port, &mux, false, timeout_s);
       if (mux != oldMux) {
         DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
-        at->sockets[oldMux] = NULL;
+        at->sockets[oldMux] = nullptr;
       }
       at->sockets[mux] = this;
       at->maintain();
@@ -181,7 +181,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
       sock_connected = at->modemConnect(host, port, &mux, true, timeout_s);
       if (mux != oldMux) {
         DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
-        at->sockets[oldMux] = NULL;
+        at->sockets[oldMux] = nullptr;
       }
       at->sockets[mux] = this;
       at->maintain();
@@ -213,7 +213,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSaraR4"));
 
@@ -249,7 +249,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -293,7 +293,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
    */
  protected:
   // using +CFUN=15 instead of the more common CFUN=1,1
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(15)) { return false; }
     delay(3000);  // TODO(?):  Verify delay timing here
@@ -352,8 +352,8 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     // gprsDisconnect();
 
     sendAT(GF("+CGATT=1"));  // attach to GPRS
@@ -545,20 +545,21 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     }
 
     // Set pointers
-    if (lat != NULL) *lat = ilat;
-    if (lon != NULL) *lon = ilon;
-    if (speed != NULL) *speed = ispeed;
-    if (alt != NULL) *alt = ialt;
-    if (vsat != NULL) *vsat = 0;  // Number of satellites viewed not reported;
-    if (usat != NULL) *usat = iusat;
-    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (lat != nullptr) *lat = ilat;
+    if (lon != nullptr) *lon = ilon;
+    if (speed != nullptr) *speed = ispeed;
+    if (alt != nullptr) *alt = ialt;
+    if (vsat != nullptr)
+      *vsat = 0;  // Number of satellites viewed not reported;
+    if (usat != nullptr) *usat = iusat;
+    if (accuracy != nullptr) *accuracy = iaccuracy;
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = static_cast<int>(secondWithSS);
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
     // final ok
     waitResponse();
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 73e6a70..c537e6b 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -187,7 +187,7 @@ class TinyGsmSequansMonarch
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSequansMonarch"));
 
@@ -223,7 +223,7 @@ class TinyGsmSequansMonarch
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -272,14 +272,14 @@ class TinyGsmSequansMonarch
         modemGetConnected();
       }
     }
-    while (stream.available()) { waitResponse(15, NULL, NULL); }
+    while (stream.available()) { waitResponse(15, nullptr, nullptr); }
   }
 
   /*
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
 
     sendAT(GF("+CFUN=0"));
@@ -340,8 +340,8 @@ class TinyGsmSequansMonarch
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Define the PDP context (This uses context #3!)
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index 36f27bf..eaf2d1c 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -102,7 +102,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
       sock_connected = at->modemConnect(host, port, &mux, false, timeout_s);
       if (mux != oldMux) {
         DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
-        at->sockets[oldMux] = NULL;
+        at->sockets[oldMux] = nullptr;
       }
       at->sockets[mux] = this;
       at->maintain();
@@ -148,7 +148,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
       sock_connected = at->modemConnect(host, port, &mux, true, timeout_s);
       if (mux != oldMux) {
         DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
-        at->sockets[oldMux] = NULL;
+        at->sockets[oldMux] = nullptr;
       }
       at->sockets[mux] = this;
       at->maintain();
@@ -169,7 +169,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientUBLOX"));
 
@@ -195,7 +195,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -240,7 +240,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(16)) { return false; }
     delay(3000);  // TODO(?):  Verify delay timing here
@@ -315,8 +315,8 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     // gprsDisconnect();
 
     sendAT(GF("+CGATT=1"));  // attach to GPRS
@@ -545,20 +545,21 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     }
 
     // Set pointers
-    if (lat != NULL) *lat = ilat;
-    if (lon != NULL) *lon = ilon;
-    if (speed != NULL) *speed = ispeed;
-    if (alt != NULL) *alt = ialt;
-    if (vsat != NULL) *vsat = 0;  // Number of satellites viewed not reported;
-    if (usat != NULL) *usat = iusat;
-    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (lat != nullptr) *lat = ilat;
+    if (lon != nullptr) *lon = ilon;
+    if (speed != nullptr) *speed = ispeed;
+    if (alt != nullptr) *alt = ialt;
+    if (vsat != nullptr)
+      *vsat = 0;  // Number of satellites viewed not reported;
+    if (usat != nullptr) *usat = iusat;
+    if (accuracy != nullptr) *accuracy = iaccuracy;
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = static_cast<int>(secondWithSS);
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
     // final ok
     waitResponse();
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index faf62a9..d570d9a 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -164,7 +164,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     }
 
     size_t write(const char* str) {
-      if (str == NULL) return 0;
+      if (str == nullptr) return 0;
       return write((const uint8_t*)str, strlen(str));
     }
 
@@ -323,7 +323,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
    * Basic functions
    */
 
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientXBee"));
 
@@ -512,7 +512,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     }
   }
 
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!commandMode()) {
       DBG("### XBee not in command mode for restart; Exit");
       return false;
@@ -649,7 +649,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
           case 0x23:  // 0x23 SSID not configured.
             stat = REG_UNREGISTERED;
             break;
-          case 0x24:  // 0x24 Encryption key invalid (either NULL or invalid
+          case 0x24:  // 0x24 Encryption key invalid (either nullptr or invalid
                       // length for WEP).
           case 0x27:  // 0x27 SSID was found, but join failed.
             stat = REG_DENIED;
@@ -813,7 +813,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
 
     XBEE_COMMAND_START_DECORATOR(5, false)
 
-    if (ssid == NULL) retVal = false;
+    if (ssid == nullptr) retVal = false;
 
     changesMade |= changeSettingIfNeeded(GF("ID"), ssid);
 
@@ -857,8 +857,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     bool success     = true;
     bool changesMade = false;
     XBEE_COMMAND_START_DECORATOR(5, false)
diff --git a/src/TinyGsmGPRS.tpp b/src/TinyGsmGPRS.tpp
index c3ad5e0..ac66aa2 100644
--- a/src/TinyGsmGPRS.tpp
+++ b/src/TinyGsmGPRS.tpp
@@ -49,8 +49,8 @@ class TinyGsmGPRS {
   /*
    * GPRS functions
    */
-  bool gprsConnect(const char* apn, const char* user = NULL,
-                   const char* pwd = NULL) {
+  bool gprsConnect(const char* apn, const char* user = nullptr,
+                   const char* pwd = nullptr) {
     return thisModem().gprsConnectImpl(apn, user, pwd);
   }
   bool gprsDisconnect() {
diff --git a/src/TinyGsmGSMLocation.tpp b/src/TinyGsmGSMLocation.tpp
index 01a6e73..b05a65d 100644
--- a/src/TinyGsmGSMLocation.tpp
+++ b/src/TinyGsmGSMLocation.tpp
@@ -129,16 +129,16 @@ class TinyGsmGSMLocation {
     isec   = thisModem().streamGetIntBefore('\n');
 
     // Set pointers
-    if (lat != NULL) *lat = ilat;
-    if (lon != NULL) *lon = ilon;
-    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (lat != nullptr) *lat = ilat;
+    if (lon != nullptr) *lon = ilon;
+    if (accuracy != nullptr) *accuracy = iaccuracy;
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = isec;
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = isec;
 
     // Final OK
     thisModem().waitResponse();
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 03786ae..b9579ce 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -47,10 +47,10 @@ class TinyGsmModem {
   /*
    * Basic functions
    */
-  bool begin(const char* pin = NULL) {
+  bool begin(const char* pin = nullptr) {
     return thisModem().initImpl(pin);
   }
-  bool init(const char* pin = NULL) {
+  bool init(const char* pin = nullptr) {
     return thisModem().initImpl(pin);
   }
   template <typename... Args>
@@ -69,25 +69,25 @@ class TinyGsmModem {
   // Listen for responses to commands and handle URCs
   int8_t waitResponse(uint32_t timeout_ms, String& data,
                       GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL,
-                      GsmConstStr r6 = NULL, GsmConstStr r7 = NULL) {
+                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = nullptr,
+                      GsmConstStr r4 = nullptr, GsmConstStr r5 = nullptr,
+                      GsmConstStr r6 = nullptr, GsmConstStr r7 = nullptr) {
     return thisModem().waitResponseImpl(timeout_ms, data, r1, r2, r3, r4, r5,
                                         r6, r7);
   }
 
   int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL,
-                      GsmConstStr r6 = NULL, GsmConstStr r7 = NULL) {
+                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = nullptr,
+                      GsmConstStr r4 = nullptr, GsmConstStr r5 = nullptr,
+                      GsmConstStr r6 = nullptr, GsmConstStr r7 = nullptr) {
     String data;
     return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5, r6, r7);
   }
 
   int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = NULL,
-                      GsmConstStr r4 = NULL, GsmConstStr r5 = NULL,
-                      GsmConstStr r6 = NULL, GsmConstStr r7 = NULL) {
+                      GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = nullptr,
+                      GsmConstStr r4 = nullptr, GsmConstStr r5 = nullptr,
+                      GsmConstStr r6 = nullptr, GsmConstStr r7 = nullptr) {
     return waitResponse(1000L, r1, r2, r3, r4, r5, r6, r7);
   }
 
@@ -107,7 +107,7 @@ class TinyGsmModem {
   /*
    * Power functions
    */
-  bool restart(const char* pin = NULL) {
+  bool restart(const char* pin = nullptr) {
     return thisModem().restartImpl(pin);
   }
   bool poweroff() {
@@ -179,9 +179,9 @@ class TinyGsmModem {
   int8_t waitResponseImpl(uint32_t timeout_ms, String& data,
                           GsmConstStr r1 = GFP(GSM_OK),
                           GsmConstStr r2 = GFP(GSM_ERROR),
-                          GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-                          GsmConstStr r5 = NULL, GsmConstStr r6 = NULL,
-                          GsmConstStr r7 = NULL) {
+                          GsmConstStr r3 = nullptr, GsmConstStr r4 = nullptr,
+                          GsmConstStr r5 = nullptr, GsmConstStr r6 = nullptr,
+                          GsmConstStr r7 = nullptr) {
     data.reserve(64);
     // DBG(GF("r1 <"), r1 ? r1 : GF("NULL"), GF("> r2 <"), r2 ? r2 : GF("NULL"),
     //     GF("> r3 <"), r3 ? r3 : GF("NULL"), GF("> r4 <"), r4 ? r4 :
@@ -393,7 +393,7 @@ class TinyGsmModem {
 
   inline void streamClear() {
     while (thisModem().stream.available()) {
-      thisModem().waitResponse(50, NULL, NULL);
+      thisModem().waitResponse(50, nullptr, nullptr);
     }
   }
 
diff --git a/src/TinyGsmSMS.tpp b/src/TinyGsmSMS.tpp
index fb74949..10e3ce8 100644
--- a/src/TinyGsmSMS.tpp
+++ b/src/TinyGsmSMS.tpp
@@ -54,7 +54,7 @@ class TinyGsmSMS {
       };
       buf[0] = instr[i];
       buf[1] = instr[i + 1];
-      byte b = strtol(buf, NULL, 16);
+      byte b = strtol(buf, nullptr, 16);
 
       byte bb = b << (7 - bitstate);
       char c  = (bb + reminder) & 0x7F;
@@ -79,7 +79,7 @@ class TinyGsmSMS {
       };
       buf[0] = instr[i];
       buf[1] = instr[i + 1];
-      char b = strtol(buf, NULL, 16);
+      char b = strtol(buf, nullptr, 16);
       result += b;
     }
     return result;
@@ -93,7 +93,7 @@ class TinyGsmSMS {
       };
       buf[0] = instr[i];
       buf[1] = instr[i + 1];
-      char b = strtol(buf, NULL, 16);
+      char b = strtol(buf, nullptr, 16);
       if (b) {  // If high byte is non-zero, we can't handle it ;(
 #if defined(TINY_GSM_UNICODE_TO_HEX)
         result += "\\x";
@@ -104,7 +104,7 @@ class TinyGsmSMS {
       } else {
         buf[0] = instr[i + 2];
         buf[1] = instr[i + 3];
-        b      = strtol(buf, NULL, 16);
+        b      = strtol(buf, nullptr, 16);
         result += b;
       }
     }
@@ -173,11 +173,11 @@ class TinyGsmSMS {
     Print&  p;
     uint8_t prv = 0;
     void    printHex(const uint16_t v) {
-      uint8_t c = v >> 8;
-      if (c < 0x10) p.print('0');
+         uint8_t c = v >> 8;
+         if (c < 0x10) p.print('0');
       p.print(c, HEX);
-      c = v & 0xFF;
-      if (c < 0x10) p.print('0');
+         c = v & 0xFF;
+         if (c < 0x10) p.print('0');
       p.print(c, HEX);
     }
   };
diff --git a/src/TinyGsmTCP.tpp b/src/TinyGsmTCP.tpp
index 23e7fac..7487e72 100644
--- a/src/TinyGsmTCP.tpp
+++ b/src/TinyGsmTCP.tpp
@@ -118,7 +118,7 @@ class TinyGsmTCP {
     }
 
     size_t write(const char* str) {
-      if (str == NULL) return 0;
+      if (str == nullptr) return 0;
       return write((const uint8_t*)str, strlen(str));
     }
 
@@ -331,12 +331,12 @@ class TinyGsmTCP {
       }
     }
     while (thisModem().stream.available()) {
-      thisModem().waitResponse(15, NULL, NULL);
+      thisModem().waitResponse(15, nullptr, nullptr);
     }
 
 #elif defined TINY_GSM_NO_MODEM_BUFFER || defined TINY_GSM_BUFFER_READ_NO_CHECK
     // Just listen for any URC's
-    thisModem().waitResponse(100, NULL, NULL);
+    thisModem().waitResponse(100, nullptr, nullptr);
 
 #else
 #error Modem client has been incorrectly created
diff --git a/src/TinyGsmTime.tpp b/src/TinyGsmTime.tpp
index fb58c7d..37b9e84 100644
--- a/src/TinyGsmTime.tpp
+++ b/src/TinyGsmTime.tpp
@@ -89,13 +89,13 @@ class TinyGsmTime {
 
     // Set pointers
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = isec;
-    if (timezone != NULL) *timezone = static_cast<float>(itimezone) / 4.0;
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = isec;
+    if (timezone != nullptr) *timezone = static_cast<float>(itimezone) / 4.0;
 
     // Final OK
     thisModem().waitResponse();

From bc1e2b2b3ee188fe23fa7bdffc4912c84b208625 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 14 May 2024 13:49:53 -0400
Subject: [PATCH 046/100] Fix undef order

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h             | 2 +-
 src/TinyGsmClientBG96.h           | 2 +-
 src/TinyGsmClientESP8266.h        | 2 +-
 src/TinyGsmClientM590.h           | 2 +-
 src/TinyGsmClientM95.h            | 2 +-
 src/TinyGsmClientMC60.h           | 2 +-
 src/TinyGsmClientSIM5360.h        | 2 +-
 src/TinyGsmClientSIM70xx.h        | 2 +-
 src/TinyGsmClientSIM7600.h        | 2 +-
 src/TinyGsmClientSIM800.h         | 2 +-
 src/TinyGsmClientSaraR4.h         | 2 +-
 src/TinyGsmClientSequansMonarch.h | 2 +-
 src/TinyGsmClientUBLOX.h          | 2 +-
 src/TinyGsmClientXBee.h           | 3 ++-
 14 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index 875694b..c0fdb67 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_NO_MODEM_BUFFER
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index c80b540..a58fdcd 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index b947378..ecd99c8 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_NO_MODEM_BUFFER
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmSSL.tpp"
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index a6aff41..39e8c43 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_NO_MODEM_BUFFER
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 465dbd7..77ce5b2 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -17,8 +17,8 @@
 #define TINY_GSM_BUFFER_READ_NO_CHECK
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index 7602013..be63186 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -19,8 +19,8 @@
 #define TINY_GSM_BUFFER_READ_NO_CHECK
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index dc3abd6..89a6f2d 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index a39c6cf..4a8f9f2 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -13,8 +13,8 @@
 // #define TINY_GSM_USE_HEX
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index db590d9..62a9d43 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index ac67769..2720ff9 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -17,8 +17,8 @@
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 9570e51..566ae8a 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index c537e6b..970d8c0 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -15,8 +15,8 @@
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmCalling.tpp"
 #include "TinyGsmGPRS.tpp"
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index eaf2d1c..01f3da2 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -16,8 +16,8 @@
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index d570d9a..29e4eda 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -20,10 +20,11 @@
 // XBee's have a default guard time of 1 second (1000ms, 10 extra for safety
 // here)
 #define TINY_GSM_XBEE_GUARD_TIME 1010
+
 #ifdef AT_NL
 #undef AT_NL
-#define AT_NL "\r"  // NOTE:  define before including TinyGsmModem!
 #endif
+#define AT_NL "\r"
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmGPRS.tpp"

From 1c097cbdef284c6351e8b5809f4f8a29d1af7876 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 15 May 2024 11:07:38 -0400
Subject: [PATCH 047/100] Esp fix, deep debug

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .gitignore                 |  1 +
 src/TinyGsmClientESP8266.h |  1 +
 src/TinyGsmModem.tpp       | 29 ++++++++++++++++++++---------
 3 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/.gitignore b/.gitignore
index fb559b6..6ed8089 100644
--- a/.gitignore
+++ b/.gitignore
@@ -48,3 +48,4 @@ filters/*
 platformio_extra_envs.ini
 *.tar.gz
 pioScripts/generate_compile_commands.py
+compile_commands.json
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index ecd99c8..100dd12 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -422,6 +422,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
       if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
         sockets[mux]->sock_connected = false;
       }
+      streamSkipUntil('\n');  // throw away the new line
       data = "";
       DBG("### Closed: ", mux);
       return true;
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index b9579ce..3789704 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -183,10 +183,13 @@ class TinyGsmModem {
                           GsmConstStr r5 = nullptr, GsmConstStr r6 = nullptr,
                           GsmConstStr r7 = nullptr) {
     data.reserve(64);
-    // DBG(GF("r1 <"), r1 ? r1 : GF("NULL"), GF("> r2 <"), r2 ? r2 : GF("NULL"),
-    //     GF("> r3 <"), r3 ? r3 : GF("NULL"), GF("> r4 <"), r4 ? r4 :
-    //     GF("NULL"), GF("> r5 <"), r5 ? r5 : GF("NULL"), GF("> r6 <"), r6 ? r6
-    //     : GF("NULL"), GF("> r7 <"), r7 ? r7 : GF("NULL"), '>');
+
+#ifdef TINY_GSM_DEBUG_DEEP
+    DBG(GF("r1 <"), r1 ? r1 : GF("NULL"), GF("> r2 <"), r2 ? r2 : GF("NULL"),
+        GF("> r3 <"), r3 ? r3 : GF("NULL"), GF("> r4 <"), r4 ? r4 : GF("NULL"),
+        GF("> r5 <"), r5 ? r5 : GF("NULL"), GF("> r6 <"), r6 ? r6 : GF("NULL"),
+        GF("> r7 <"), r7 ? r7 : GF("NULL"), '>');
+#endif
     uint8_t  index       = 0;
     uint32_t startMillis = millis();
     do {
@@ -221,12 +224,16 @@ class TinyGsmModem {
 #if defined TINY_GSM_DEBUG
         else if (data.endsWith(GFP(GSM_VERBOSE)) ||
                  data.endsWith(GFP(GSM_VERBOSE_2))) {
-          // DBG(GF("Verbose details <<<"));
+#ifdef TINY_GSM_DEBUG_DEEP
+          DBG(GF("Verbose details <<<"));
+#endif
           // Read out the verbose message, until whichever type of new line
           // comes first
           thisModem().stream.findUntil(const_cast<char*>("\r"),
                                        const_cast<char*>("\n"));
-          // DBG(GF(">>>"));
+#ifdef TINY_GSM_DEBUG_DEEP
+          DBG(GF(">>>"));
+#endif
           data = "";
         }
 #endif
@@ -236,14 +243,18 @@ class TinyGsmModem {
       }
     } while (millis() - startMillis < timeout_ms);
   finish:
-    // data.replace("\r", "←");
-    // data.replace("\n", "↓");
+#ifdef TINY_GSM_DEBUG_DEEP
+    data.replace("\r", "←");
+    data.replace("\n", "↓");
+#endif
     if (!index) {
       data.trim();
       if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
     } else {
-      // DBG('<', index, '>', data);
+#ifdef TINY_GSM_DEBUG_DEEP
+      DBG('<', index, '>', data);
+#endif
     }
     return index;
   }

From 07dfcf2c5c2452addd8307e24c685713491af58d Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 15 May 2024 11:10:43 -0400
Subject: [PATCH 048/100] Re-Fix GSM_OK

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h             |  2 +-
 src/TinyGsmClientESP8266.h        | 10 +++++-----
 src/TinyGsmClientM95.h            |  2 +-
 src/TinyGsmClientMC60.h           |  2 +-
 src/TinyGsmClientSIM7000SSL.h     |  5 +++--
 src/TinyGsmClientSIM7080.h        |  5 +++--
 src/TinyGsmClientSequansMonarch.h |  6 +++---
 7 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index c0fdb67..0c06a34 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -438,7 +438,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     if (waitResponse(2000L, GF(AT_NL ">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(10000L, GFP(AT_OK), GF(AT_NL "FAIL")) != 1) { return 0; }
+    if (waitResponse(10000L, GFP(GSM_OK), GF(AT_NL "FAIL")) != 1) { return 0; }
     return len;
   }
 
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 100dd12..2a8bd5f 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -303,9 +303,9 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     // attempt first without than with the 'current' flag used in some firmware
     // versions
     sendAT(GF("+CWJAP=\""), ssid, GF("\",\""), pwd, GF("\""));
-    if (waitResponse(30000L, GFP(AT_OK), GF(AT_NL "FAIL" AT_NL)) != 1) {
+    if (waitResponse(30000L, GFP(GSM_OK), GF(AT_NL "FAIL" AT_NL)) != 1) {
       sendAT(GF("+CWJAP_CUR=\""), ssid, GF("\",\""), pwd, GF("\""));
-      if (waitResponse(30000L, GFP(AT_OK), GF(AT_NL "FAIL" AT_NL)) != 1) {
+      if (waitResponse(30000L, GFP(GSM_OK), GF(AT_NL "FAIL" AT_NL)) != 1) {
         return false;
       }
     }
@@ -335,7 +335,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
            GF("\",\""), host, GF("\","), port, GF(","),
            TINY_GSM_TCP_KEEP_ALIVE);
     // TODO(?): Check mux
-    int8_t rsp = waitResponse(timeout_ms, GFP(AT_OK), GFP(GSM_ERROR),
+    int8_t rsp = waitResponse(timeout_ms, GFP(GSM_OK), GFP(GSM_ERROR),
                               GF("ALREADY CONNECT"));
     // if (rsp == 3) waitResponse();
     // May return "ERROR" after the "ALREADY CONNECT"
@@ -357,7 +357,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     // after "STATUS:" it should return the status number (0,1,2,3,4,5),
     // followed by an OK
     // Hopefully we'll catch the "3" here, but fall back to the OK or Error
-    int8_t status = waitResponse(GF("3"), GFP(AT_OK), GFP(GSM_ERROR));
+    int8_t status = waitResponse(GF("3"), GFP(GSM_OK), GFP(GSM_ERROR));
     // if the status is anything but 3, there are no connections open
     if (status != 1) {
       for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
@@ -367,7 +367,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     }
     bool verified_connections[TINY_GSM_MUX_COUNT] = {0, 0, 0, 0, 0};
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
-      uint8_t has_status = waitResponse(GF("+CIPSTATUS:"), GFP(AT_OK),
+      uint8_t has_status = waitResponse(GF("+CIPSTATUS:"), GFP(GSM_OK),
                                         GFP(GSM_ERROR));
       if (has_status == 1) {
         int8_t returned_mux = streamGetIntBefore(',');
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 77ce5b2..deea4bf 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -455,7 +455,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
     sendAT(GF("+QIRD=0,1,"), mux, ',', (uint16_t)size);
     // If it replies only OK for the write command, it means there is no
     // received data in the buffer of the connection.
-    int8_t res = waitResponse(GF("+QIRD:"), GFP(AT_OK), GFP(GSM_ERROR));
+    int8_t res = waitResponse(GF("+QIRD:"), GFP(GSM_OK), GFP(GSM_ERROR));
     if (res == 1) {
       streamSkipUntil(':');  // skip IP address
       streamSkipUntil(',');  // skip port
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index be63186..8603971 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -429,7 +429,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
     sendAT(GF("+QIRD=0,1,"), mux, ',', (uint16_t)size);
     // If it replies only OK for the write command, it means there is no
     // received data in the buffer of the connection.
-    int8_t res = waitResponse(GF("+QIRD:"), GFP(AT_OK), GFP(GSM_ERROR));
+    int8_t res = waitResponse(GF("+QIRD:"), GFP(GSM_OK), GFP(GSM_ERROR));
     if (res == 1) {
       streamSkipUntil(':');  // skip IP address
       streamSkipUntil(',');  // skip port
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index 10d5951..5eabeeb 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -496,7 +496,7 @@ class TinyGsmSim7000SSL
     sendAT(GF("+CARECV?"));
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CARECV:"), GFP(AT_OK), GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CARECV:"), GFP(GSM_OK), GFP(GSM_ERROR));
       // if we get the +CARECV: response, read the mux number and the number of
       // characters available
       if (res == 1) {
@@ -543,7 +543,8 @@ class TinyGsmSim7000SSL
 
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CASTATE:"), GFP(AT_OK), GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CASTATE:"), GFP(GSM_OK),
+                             GFP(GSM_ERROR));
       // if we get the +CASTATE: response, read the mux number and the status
       if (res == 1) {
         int    ret_mux = streamGetIntBefore(',');
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index cec1c13..0165216 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -495,7 +495,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     sendAT(GF("+CARECV?"));
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CARECV:"), GFP(AT_OK), GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CARECV:"), GFP(GSM_OK), GFP(GSM_ERROR));
       // if we get the +CARECV: response, read the mux number and the number of
       // characters available
       if (res == 1) {
@@ -542,7 +542,8 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
 
     for (int muxNo = 0; muxNo < TINY_GSM_MUX_COUNT; muxNo++) {
       // after the last connection, there's an ok, so we catch it right away
-      int res = waitResponse(3000, GF("+CASTATE:"), GFP(AT_OK), GFP(GSM_ERROR));
+      int res = waitResponse(3000, GF("+CASTATE:"), GFP(GSM_OK),
+                             GFP(GSM_ERROR));
       // if we get the +CASTATE: response, read the mux number and the status
       if (res == 1) {
         int    ret_mux = streamGetIntBefore(',');
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 970d8c0..35d1529 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -283,7 +283,7 @@ class TinyGsmSequansMonarch
     if (!testAT()) { return false; }
 
     sendAT(GF("+CFUN=0"));
-    int8_t res = waitResponse(20000L, GFP(AT_OK), GFP(GSM_ERROR),
+    int8_t res = waitResponse(20000L, GFP(GSM_OK), GFP(GSM_ERROR),
                               GF("+SYSSTART"));
     if (res != 1 && res != 3) { return false; }
 
@@ -481,7 +481,7 @@ class TinyGsmSequansMonarch
     // <acceptAnyRemote> = Applies to UDP only
     sendAT(GF("+SQNSD="), mux, ",0,", port, ',', GF("\""), host, GF("\""),
            ",0,0,1");
-    rsp = waitResponse((timeout_ms - (millis() - startMillis)), GFP(AT_OK),
+    rsp = waitResponse((timeout_ms - (millis() - startMillis)), GFP(GSM_OK),
                        GFP(GSM_ERROR), GF("NO CARRIER" AT_NL));
 
     // creation of socket failed immediately.
@@ -582,7 +582,7 @@ class TinyGsmSequansMonarch
     // six possible sockets.
     sendAT(GF("+SQNSS"));
     for (int muxNo = 1; muxNo <= TINY_GSM_MUX_COUNT; muxNo++) {
-      if (waitResponse(GFP(AT_OK), GF(AT_NL "+SQNSS: ")) != 2) { break; }
+      if (waitResponse(GFP(GSM_OK), GF(AT_NL "+SQNSS: ")) != 2) { break; }
       uint8_t status = 0;
       // if (streamGetIntBefore(',') != muxNo) { // check the mux no
       //   DBG("### Warning: misaligned mux numbers!");

From 85ed4301214f196f22d65741c5693024ebe1444c Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 16 May 2024 16:00:00 -0400
Subject: [PATCH 049/100] Make regstatus enum names unique

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .gitignore                        |  1 +
 src/TinyGsmClientA6.h             |  8 ++++----
 src/TinyGsmClientBG96.h           | 10 +++++-----
 src/TinyGsmClientESP8266.h        |  8 ++++----
 src/TinyGsmClientM590.h           |  8 ++++----
 src/TinyGsmClientM95.h            |  8 ++++----
 src/TinyGsmClientMC60.h           |  8 ++++----
 src/TinyGsmClientSIM5360.h        |  8 ++++----
 src/TinyGsmClientSIM70xx.h        | 12 ++++++------
 src/TinyGsmClientSIM7600.h        |  8 ++++----
 src/TinyGsmClientSIM800.h         |  8 ++++----
 src/TinyGsmClientSaraR4.h         | 11 ++++++-----
 src/TinyGsmClientSequansMonarch.h |  8 ++++----
 src/TinyGsmClientUBLOX.h          |  8 ++++----
 src/TinyGsmClientXBee.h           | 12 ++++++------
 15 files changed, 64 insertions(+), 62 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6ed8089..c6417ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -49,3 +49,4 @@ platformio_extra_envs.ini
 *.tar.gz
 pioScripts/generate_compile_commands.py
 compile_commands.json
+src/TinyGsmATDefines.h
diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index 0c06a34..07fd635 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -27,7 +27,7 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-enum RegStatus {
+enum A6RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -194,13 +194,13 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+  A6RegStatus getRegistrationStatus() {
+    return (A6RegStatus)getRegistrationStatusXREG("CREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    A6RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index a58fdcd..8308e37 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -30,7 +30,7 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
 
-enum RegStatus {
+enum BG96RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -233,22 +233,22 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
+  BG96RegStatus getRegistrationStatus() {
     // Check first for EPS registration
-    RegStatus epsStatus = (RegStatus)getRegistrationStatusXREG("CEREG");
+    BG96RegStatus epsStatus = (BG96RegStatus)getRegistrationStatusXREG("CEREG");
 
     // If we're connected on EPS, great!
     if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
       return epsStatus;
     } else {
       // Otherwise, check generic network status
-      return (RegStatus)getRegistrationStatusXREG("CREG");
+      return (BG96RegStatus)getRegistrationStatusXREG("CREG");
     }
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    BG96RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 2a8bd5f..77b878b 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -33,7 +33,7 @@ static uint8_t TINY_GSM_TCP_KEEP_ALIVE = 120;
 // 3 : ESP8266 station created a TCP or UDP transmission
 // 4 : the TCP or UDP transmission of ESP8266 station disconnected
 // 5 : ESP8266 station did NOT connect to an AP
-enum RegStatus {
+enum ESP8266RegStatus {
   REG_UNINITIALIZED = 0,
   REG_UNREGISTERED  = 1,
   REG_OK_IP         = 2,
@@ -225,7 +225,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
+  ESP8266RegStatus getRegistrationStatus() {
     sendAT(GF("+CIPSTATUS"));
     if (waitResponse(3000, GF("STATUS:")) != 1) return REG_UNKNOWN;
     // after "STATUS:" it should return the status number (0,1,2,3,4,5),
@@ -236,7 +236,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     if (waitResponse(3000L, res) != 1) { return REG_UNKNOWN; }
     res.trim();
     int8_t status = res.toInt();
-    return (RegStatus)status;
+    return (ESP8266RegStatus)status;
   }
 
  protected:
@@ -262,7 +262,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
   }
 
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    ESP8266RegStatus s = getRegistrationStatus();
     if (s == REG_OK_IP || s == REG_OK_TCP) {
       // with these, we're definitely connected
       return true;
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index 39e8c43..71c222c 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -25,7 +25,7 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-enum RegStatus {
+enum M590RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 3,
@@ -194,13 +194,13 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+  M590RegStatus getRegistrationStatus() {
+    return (M590RegStatus)getRegistrationStatusXREG("CREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    M590RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index deea4bf..9713af4 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -29,7 +29,7 @@
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 
-enum RegStatus {
+enum M95RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -230,13 +230,13 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+  M95RegStatus getRegistrationStatus() {
+    return (M95RegStatus)getRegistrationStatusXREG("CREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    M95RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index 8603971..792027c 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -30,7 +30,7 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-enum RegStatus {
+enum MC60RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -225,13 +225,13 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+  MC60RegStatus getRegistrationStatus() {
+    return (MC60RegStatus)getRegistrationStatusXREG("CREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    MC60RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 89a6f2d..1c3e032 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -29,7 +29,7 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
 
-enum RegStatus {
+enum SIM5360RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -250,13 +250,13 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CGREG");
+  SIM5360RegStatus getRegistrationStatus() {
+    return (SIM5360RegStatus)getRegistrationStatusXREG("CGREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    SIM5360RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 4a8f9f2..be561d6 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -25,7 +25,7 @@
 #include "TinyGsmNTP.tpp"
 #include "TinyGsmGSMLocation.tpp"
 
-enum RegStatus {
+enum SIM70xxRegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -143,22 +143,22 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    RegStatus epsStatus =
-        (RegStatus)thisModem().getRegistrationStatusXREG("CEREG");
+  SIM70xxRegStatus getRegistrationStatus() {
+    SIM70xxRegStatus epsStatus =
+        (SIM70xxRegStatus)thisModem().getRegistrationStatusXREG("CEREG");
     // If we're connected on EPS, great!
     if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
       return epsStatus;
     } else {
       // Otherwise, check GPRS network status
       // We could be using GPRS fall-back or the board could be being moody
-      return (RegStatus)thisModem().getRegistrationStatusXREG("CGREG");
+      return (SIM70xxRegStatus)thisModem().getRegistrationStatusXREG("CGREG");
     }
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    SIM70xxRegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 62a9d43..4f014fb 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -32,7 +32,7 @@
 #include "TinyGsmNTP.tpp"
 
 
-enum RegStatus {
+enum SIM7600RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -255,13 +255,13 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CGREG");
+  SIM7600RegStatus getRegistrationStatus() {
+    return (SIM7600RegStatus)getRegistrationStatusXREG("CGREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    SIM7600RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 2720ff9..710008f 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -31,7 +31,7 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
 
-enum RegStatus {
+enum SIM800RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -286,13 +286,13 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+  SIM800RegStatus getRegistrationStatus() {
+    return (SIM800RegStatus)getRegistrationStatusXREG("CREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    SIM800RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 566ae8a..603f862 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -30,7 +30,7 @@
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 
-enum RegStatus {
+enum SaraR4RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -316,22 +316,23 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
+  SaraR4RegStatus getRegistrationStatus() {
     // Check first for EPS registration
-    RegStatus epsStatus = (RegStatus)getRegistrationStatusXREG("CEREG");
+    SaraR4RegStatus epsStatus =
+        (SaraR4RegStatus)getRegistrationStatusXREG("CEREG");
 
     // If we're connected on EPS, great!
     if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
       return epsStatus;
     } else {
       // Otherwise, check generic network status
-      return (RegStatus)getRegistrationStatusXREG("CREG");
+      return (SaraR4RegStatus)getRegistrationStatusXREG("CREG");
     }
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    SaraR4RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 35d1529..5d0fdd9 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -27,7 +27,7 @@
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 
-enum RegStatus {
+enum MonarchRegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -319,13 +319,13 @@ class TinyGsmSequansMonarch
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CEREG");
+  MonarchRegStatus getRegistrationStatus() {
+    return (MonarchRegStatus)getRegistrationStatusXREG("CEREG");
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    MonarchRegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
   String getLocalIPImpl() {
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index 01f3da2..5ae3853 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -30,7 +30,7 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmTime.tpp"
 
-enum RegStatus {
+enum UBLOXRegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -263,8 +263,8 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CGREG");
+  UBLOXRegStatus getRegistrationStatus() {
+    return (UBLOXRegStatus)getRegistrationStatusXREG("CGREG");
   }
 
   bool setRadioAccessTecnology(int selected, int preferred) {
@@ -292,7 +292,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    UBLOXRegStatus s = getRegistrationStatus();
     if (s == REG_OK_HOME || s == REG_OK_ROAMING)
       return true;
     else if (s == REG_UNKNOWN)  // for some reason, it can hang at unknown..
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 29e4eda..e5935c9 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -49,7 +49,7 @@
     exitCommand();                                                       \
   }
 
-enum RegStatus {
+enum XBeeRegStatus {
   REG_OK           = 0,
   REG_UNREGISTERED = 1,
   REG_SEARCHING    = 2,
@@ -611,7 +611,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
+  XBeeRegStatus getRegistrationStatus() {
     XBEE_COMMAND_START_DECORATOR(5, REG_UNKNOWN)
 
     if (!inCommandMode) return REG_UNKNOWN;  // Return immediately
@@ -620,8 +620,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
       getSeries();  // Need to know the bee type to interpret response
 
     sendAT(GF("AI"));
-    int16_t   intRes = readResponseInt(10000L);
-    RegStatus stat   = REG_UNKNOWN;
+    int16_t       intRes = readResponseInt(10000L);
+    XBeeRegStatus stat   = REG_UNKNOWN;
 
     switch (beeType) {
       case XBEE_S6B_WIFI: {
@@ -731,7 +731,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
 
   bool isNetworkConnectedImpl() {
     // first check for association indicator
-    RegStatus s = getRegistrationStatus();
+    XBeeRegStatus s = getRegistrationStatus();
     if (s == REG_OK) {
       if (beeType == XBEE_S6B_WIFI) {
         // For wifi bees, if the association indicator is ok, check that a both
@@ -1263,7 +1263,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     switch (beeType) {
       // The wifi be can only say if it's connected to the netowrk
       case XBEE_S6B_WIFI: {
-        RegStatus s = getRegistrationStatus();
+        XBeeRegStatus s = getRegistrationStatus();
         XBEE_COMMAND_END_DECORATOR
         if (s != REG_OK) {
           sockets[0]->sock_connected = false;  // no multiplex

From b5379f975e6991334afa0eca8004e3d46e660d87 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 11:38:55 -0400
Subject: [PATCH 050/100] Hex fix for Monarch

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSequansMonarch.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 5d0fdd9..9343b52 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -505,7 +505,7 @@ class TinyGsmSequansMonarch
     sendAT(GF("+SQNSSENDEXT="), mux, ',', (uint16_t)len);
     waitResponse(10000L, GF(AT_NL "> "));
     // Translate bytes into char to be able to send them as an hex string
-    char char_command[2];
+    char char_command[3];
     for (size_t i = 0; i < len; i++) {
       memset(&char_command, 0, sizeof(char_command));
       sprintf(&char_command[0], "%02X",

From d92eb56f4b648e0eec644525a3ed22a10390ee0c Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 13:45:00 -0400
Subject: [PATCH 051/100] Support fetching hardware and firmware version and
 serial number

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h      | 14 ++++++++++
 src/TinyGsmClientESP8266.h | 19 ++++++++++++++
 src/TinyGsmClientM590.h    | 23 ++++++++++++++--
 src/TinyGsmClientXBee.h    | 19 ++++++++++++++
 src/TinyGsmModem.tpp       | 54 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 127 insertions(+), 2 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index 07fd635..d05f02f 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -161,6 +161,20 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     }
   }
 
+  // Gets the modem serial number
+  String getModemSerialNumberImpl() {
+    sendAT(GF("GSN"));  // Not CGSN
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    // Do the replaces twice so we cover both \r and \r\n type endings
+    res.replace("\r\nOK\r\n", "");
+    res.replace("\rOK\r", "");
+    res.replace("\r\n", " ");
+    res.replace("\r", " ");
+    res.trim();
+    return res;
+  }
+
   bool factoryDefaultImpl() {
     sendAT(GF("&FZE0&W"));  // Factory + Reset + Echo Off + Write
     waitResponse();
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 77b878b..b0f5f4d 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -168,6 +168,25 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     return "ESP8266";
   }
 
+  // Gets the modem serial number
+  String getModemSerialNumberImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  // Gets the modem hardware version
+  String getModemHardwareVersionImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+
+  // Gets the modem firmware version
+  String getModemFirmwareVersionImpl() {
+    sendAT(GF("GMR"));  // GMR instead of CGMR
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    // Do the replaces twice so we cover both \r and \r\n type endings
+    res.replace("\r\nOK\r\n", "");
+    res.replace("\rOK\r", "");
+    res.replace("\r\n", " ");
+    res.replace("\r", " ");
+    res.trim();
+    return res;
+  }
+
   void setBaudImpl(uint32_t baud) {
     sendAT(GF("+UART_CUR="), baud, "8,1,0,0");
     if (waitResponse() != 1) {
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index 71c222c..273621d 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -144,9 +144,28 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
     }
   }
 
-  // Doesn't support CGMI
+  // This is extracted from the modem info
   String getModemNameImpl() {
-    return "Neoway M590";
+    sendAT(GF("I"));
+    String factory = stream.readStringUntil('\n');  // read the factory
+    factory.trim();
+    String model = stream.readStringUntil('\n');  // read the model
+    model.trim();
+    streamSkipUntil('\n');  // skip the revision
+    waitResponse();         // wait for the OK
+    return factory + String(" ") + model;
+  }
+
+  // Gets the modem firmware version
+  // This is extracted from the modem info
+  String getModemFirmwareVersionImpl() {
+    sendAT(GF("I"));
+    streamSkipUntil('\n');                      // skip the factory
+    streamSkipUntil('\n');                      // skip the model
+    String res = stream.readStringUntil('\n');  // read the revision
+    res.trim();
+    waitResponse();  // wait for the OK
+    return res;
   }
 
   // Extra stuff here - pwr save, internal stack
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index e5935c9..a8b7088 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -382,6 +382,25 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return getBeeName();
   }
 
+  // Gets the modem serial number
+  String getModemSerialNumberImpl() {
+    String xbeeSnLow =
+        sendATGetString(GF("SL"));  // Request Module MAC/Serial Number Low
+    String xbeeSnHigh =
+        sendATGetString(GF("SH"));  // Request Module MAC/Serial Number High
+    return xbeeSnLow + String(" ") + xbeeSnHigh;
+  }
+
+  // Gets the modem hardware version
+  String getModemHardwareVersionImpl() {
+    return sendATGetString(GF("HV"));
+  }
+
+  // Gets the modem firmware version
+  String getModemFirmwareVersionImpl() {
+    return sendATGetString(GF("VR"));
+  }
+
   void setBaudImpl(uint32_t baud) {
     XBEE_COMMAND_START_DECORATOR(5, )
     bool changesMade = false;
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 3789704..f73f82d 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -100,6 +100,18 @@ class TinyGsmModem {
   String getModemName() {
     return thisModem().getModemNameImpl();
   }
+  // Gets the modem serial number
+  String getModemSerialNumber() {
+    return thisModem().getModemSerialNumberImpl();
+  }
+  // Gets the modem hardware version
+  String getModemHardwareVersion() {
+    return thisModem().getModemHardwareVersionImpl();
+  }
+  // Gets the modem firmware version
+  String getModemFirmwareVersion() {
+    return thisModem().getModemFirmwareVersionImpl();
+  }
   bool factoryDefault() {
     return thisModem().factoryDefaultImpl();
   }
@@ -293,6 +305,48 @@ class TinyGsmModem {
     return name;
   }
 
+  // Gets the modem serial number
+  String getModemSerialNumberImpl() {
+    thisModem().sendAT(GF("CGSN"));
+    String res;
+    if (thisModem().waitResponse(1000L, res) != 1) { return ""; }
+    // Do the replaces twice so we cover both \r and \r\n type endings
+    res.replace("\r\nOK\r\n", "");
+    res.replace("\rOK\r", "");
+    res.replace("\r\n", " ");
+    res.replace("\r", " ");
+    res.trim();
+    return res;
+  }
+
+  // Gets the modem hardware version
+  String getModemHardwareVersionImpl() {
+    thisModem().sendAT(GF("CGMM"));
+    String res;
+    if (thisModem().waitResponse(1000L, res) != 1) { return ""; }
+    // Do the replaces twice so we cover both \r and \r\n type endings
+    res.replace("\r\nOK\r\n", "");
+    res.replace("\rOK\r", "");
+    res.replace("\r\n", " ");
+    res.replace("\r", " ");
+    res.trim();
+    return res;
+  }
+
+  // Gets the modem firmware version
+  String getModemFirmwareVersionImpl() {
+    thisModem().sendAT(GF("CGMR"));
+    String res;
+    if (thisModem().waitResponse(1000L, res) != 1) { return ""; }
+    // Do the replaces twice so we cover both \r and \r\n type endings
+    res.replace("\r\nOK\r\n", "");
+    res.replace("\rOK\r", "");
+    res.replace("\r\n", " ");
+    res.replace("\r", " ");
+    res.trim();
+    return res;
+  }
+
   bool factoryDefaultImpl() {
     thisModem().sendAT(GF("&FZE0&W"));  // Factory + Reset + Echo Off + Write
     thisModem().waitResponse();

From 7f71dec63fbf8dddaf8c6773e763b7606bd220fe Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 14:19:14 -0400
Subject: [PATCH 052/100] Update BG95 to current URC handler

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientBG96.h       |  43 +++
 src/TinyGsmClientSecureBG95.h | 524 ++++++++++++++--------------------
 2 files changed, 250 insertions(+), 317 deletions(-)

diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 8308e37..5bda905 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -433,6 +433,49 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
     return res;
   }
 
+  // The BG96 returns UTC time instead of local time as other modules do in
+  // response to CCLK, so we're using QLTS where we can specifically request
+  // local time.
+  bool getNetworkUTCTimeImpl(int* year, int* month, int* day, int* hour,
+                             int* minute, int* second, float* timezone) {
+    sendAT(GF("+QLTS=1"));
+    if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return false; }
+
+    int iyear     = 0;
+    int imonth    = 0;
+    int iday      = 0;
+    int ihour     = 0;
+    int imin      = 0;
+    int isec      = 0;
+    int itimezone = 0;
+
+    // Date & Time
+    iyear       = streamGetIntBefore('/');
+    imonth      = streamGetIntBefore('/');
+    iday        = streamGetIntBefore(',');
+    ihour       = streamGetIntBefore(':');
+    imin        = streamGetIntBefore(':');
+    isec        = streamGetIntLength(2);
+    char tzSign = stream.read();
+    itimezone   = streamGetIntBefore(',');
+    if (tzSign == '-') { itimezone = itimezone * -1; }
+    streamSkipUntil('\n');  // DST flag
+
+    // Set pointers
+    if (iyear < 2000) iyear += 2000;
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = isec;
+    if (timezone != nullptr) *timezone = static_cast<float>(itimezone) / 4.0;
+
+    // Final OK
+    waitResponse();  // Ends with OK
+    return true;
+  }
+
   // The BG96 returns UTC time instead of local time as other modules do in
   // response to CCLK, so we're using QLTS where we can specifically request
   // local time.
diff --git a/src/TinyGsmClientSecureBG95.h b/src/TinyGsmClientSecureBG95.h
index fd36139..721644b 100644
--- a/src/TinyGsmClientSecureBG95.h
+++ b/src/TinyGsmClientSecureBG95.h
@@ -14,6 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 12
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef AT_NL
+#undef AT_NL
+#endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -26,15 +30,7 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
-enum RegStatus {
+enum BG95RegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -128,17 +124,15 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * Inner Secure Client
    */
 
-  class GsmClientSecureBG95 : public GsmClientBG95
-  {
-  public:
+  class GsmClientSecureBG95 : public GsmClientBG95 {
+   public:
     GsmClientSecureBG95() {}
 
     GsmClientSecureBG95(TinyGsmBG95& modem, uint8_t mux = 0)
-     : GsmClientBG95(modem, mux)
-    {}
+        : GsmClientBG95(modem, mux) {}
 
 
-  public:
+   public:
     int connect(const char* host, uint16_t port, int timeout_s) override {
       stop();
       TINY_GSM_YIELD();
@@ -161,7 +155,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientBG95"));
 
@@ -186,24 +180,13 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     // Enable automatic time zone update
     sendAT(GF("+CTZU=1"));
     if (waitResponse(10000L) != 1) { return false; }
-#if 1
-    SimStatus ret = getSimStatus();
-    // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
-      simUnlock(pin);
-      return (getSimStatus() == SIM_READY);
-    } else {
-      // if the sim is ready, or it's locked but no pin has been provided,
-      // return true
-      return (ret == SIM_READY || ret == SIM_LOCKED);
-    }
-#endif
   }
+
   /*
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(1, true)) { return false; }
     waitResponse(10000L, GF("APP RDY"));
@@ -226,7 +209,8 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     return waitResponse() == 1;
   }
 
-  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false, uint32_t timeout_ms = 15500L) {
+  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false,
+                                 uint32_t timeout_ms = 15500L) {
     sendAT(GF("+CFUN="), fun, reset ? ",1" : "");
     return waitResponse(timeout_ms, GF("OK")) == 1;
   }
@@ -235,24 +219,24 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
+  BG95RegStatus getRegistrationStatus() {
     // Check first for EPS registration
-    RegStatus epsStatus = (RegStatus)getRegistrationStatusXREG("CEREG");
+    BG95RegStatus epsStatus = (BG95RegStatus)getRegistrationStatusXREG("CEREG");
 
-    //if REG_UNKNOWN
+    // if REG_UNKNOWN
 
     // If we're connected on EPS, great!
     if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
       return epsStatus;
     } else {
       // Otherwise, check generic network status
-      return (RegStatus)getRegistrationStatusXREG("CREG");
+      return (BG95RegStatus)getRegistrationStatusXREG("CREG");
     }
   }
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    BG95RegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
@@ -260,8 +244,8 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Configure the TCPIP Context
@@ -293,7 +277,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
  protected:
   String getSimCCIDImpl() {
     sendAT(GF("+QCCID"));
-    if (waitResponse(GF(GSM_NL "+QCCID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+QCCID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -322,85 +306,71 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
   // to, I am not implementing it here.
 
 
-
   /*
    * Testing functions
    */
 
  public:
-  String getModemManufacturerIdentification(){
+  String getModemManufacturer() {
     sendAT(GF("+GMI"));
     String res;
     if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, " ");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, " ");
     res.trim();
     return res;
   }
-  String getModemModelIdentification(){
-    sendAT(GF("+GMM"));
-    String res;
-    if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, " ");
-    res.trim();
-    return res;
-  }
-  String getModemFirmwareVersionIdentification(){
-    sendAT(GF("+GMR"));
-    String res;
-    if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, " ");
-    res.trim();
-    return res;
-  }
-  String getModemFirmwareFullVersionIdentification(){
+  String getModemFirmwareFullVersion() {
     sendAT(GF("+QGMR"));
     String res;
     if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, " ");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, " ");
     res.trim();
     return res;
   }
-  String getModemFirmwareApplicationVersionIdentification(){
+  String getModemFirmwareApplicationVersionn() {
     sendAT(GF("+QAPPVER"));
     String res;
     if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(GSM_NL "OK" GSM_NL, "");
-    res.replace(GSM_NL, " ");
-    res.replace("+QAPPVER: ","");
+    res.replace(AT_NL "OK" AT_NL, "");
+    res.replace(AT_NL, " ");
+    res.replace("+QAPPVER: ", "");
     res.trim();
     return res;
   }
   bool configureGPS(void) {
-    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));//Based on Mobile Country Code (europe : galileo)
+    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));  // Based on Mobile Country Code
+                                              // (europe : galileo)
     if (waitResponse() != 1) { return false; }
     return true;
   }
   bool configureGPSPriority(void) {
-    sendAT(GF("+QGPSCFG=\"priority\""));//Priority GNSS instead of WWAN
+    sendAT(GF("+QGPSCFG=\"priority\""));  // Priority GNSS instead of WWAN
     if (waitResponse() != 1) { return false; }
     return true;
   }
   bool test(void) {
-    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));//Based on Mobile Country Code (europe : galileo)
+    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));  // Based on Mobile Country Code
+                                              // (europe : galileo)
     waitResponse();
-    sendAT(GF("+QGPSCFG=\"priority\",0,0"));//Priority GNSS, not saved
+    sendAT(GF("+QGPSCFG=\"priority\",0,0"));  // Priority GNSS, not saved
     waitResponse();
-    sendAT(GF("+QGPS=1,1,0,1"));//Low Accuracy, Continuous positionning, Rate : 1 sec
+    sendAT(GF("+QGPS=1,1,0,1"));  // Low Accuracy, Continuous positionning, Rate
+                                  // : 1 sec
     waitResponse();
-    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));//Based on Mobile Country Code (europe : galileo)
+    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));  // Based on Mobile Country Code
+                                              // (europe : galileo)
     waitResponse();
-    sendAT(GF("+QGPSCFG=\"priority\",0,0"));//Priority GNSS, not saved
+    sendAT(GF("+QGPSCFG=\"priority\",0,0"));  // Priority GNSS, not saved
     waitResponse();
     return true;
   }
   bool test_ask(void) {
-    sendAT(GF("+QGPSCFG=\"gnssconfig\""));//Based on Mobile Country Code (europe : galileo)
+    sendAT(GF("+QGPSCFG=\"gnssconfig\""));  // Based on Mobile Country Code
+                                            // (europe : galileo)
     waitResponse();
-    //if (waitResponse() != 1) { return false; }
+    // if (waitResponse() != 1) { return false; }
     sendAT(GF("+QGPSCFG=?"));
     waitResponse();
     sendAT(GF("+QGPSEND=?"));
@@ -409,11 +379,11 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     waitResponse();
     return true;
   }
-#define MODEM_RAT_SEARCHED_AUTOMATIC    (0)
-#define MODEM_RAT_SEARCHED_GSM_ONLY     (1)
-#define MODEM_RAT_SEARCHED_LTE_ONLY     (3)
-#define MODEM_RAT_SEARCHED_ERROR        (255)
-  uint8_t query_modem_rat_searched(void){
+#define MODEM_RAT_SEARCHED_AUTOMATIC (0)
+#define MODEM_RAT_SEARCHED_GSM_ONLY (1)
+#define MODEM_RAT_SEARCHED_LTE_ONLY (3)
+#define MODEM_RAT_SEARCHED_ERROR (255)
+  uint8_t query_modem_rat_searched(void) {
     uint8_t returned;
     sendAT(GF("+QCFG=\"nwscanmode\""));
     if (waitResponse(GF("+QCFG:")) != 1) { return MODEM_RAT_SEARCHED_ERROR; }
@@ -429,14 +399,16 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
      3 : LTE only
      */
   }
-#define MODEM_NETWORK_CATEGORY_SEARCHED_EMTC     (0)
-#define MODEM_NETWORK_CATEGORY_SEARCHED_NBIOT    (1)
-#define MODEM_NETWORK_CATEGORY_SEARCHED_ALL      (2)
-#define MODEM_NETWORK_CATEGORY_SEARCHED_ERROR    (255)
-  uint8_t query_modem_network_category_searched(void){
+#define MODEM_NETWORK_CATEGORY_SEARCHED_EMTC (0)
+#define MODEM_NETWORK_CATEGORY_SEARCHED_NBIOT (1)
+#define MODEM_NETWORK_CATEGORY_SEARCHED_ALL (2)
+#define MODEM_NETWORK_CATEGORY_SEARCHED_ERROR (255)
+  uint8_t query_modem_network_category_searched(void) {
     uint8_t returned;
     sendAT(GF("+QCFG=\"iotopmode\""));
-    if (waitResponse(GF("+QCFG:")) != 1) { return MODEM_NETWORK_CATEGORY_SEARCHED_ERROR; }
+    if (waitResponse(GF("+QCFG:")) != 1) {
+      return MODEM_NETWORK_CATEGORY_SEARCHED_ERROR;
+    }
     streamSkipUntil('"');
     streamSkipUntil('"');
     streamSkipUntil(',');
@@ -449,7 +421,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
      2 : eMTC and NB-IoT
      */
   }
-  void query_modem_register_settings(void){
+  void query_modem_register_settings(void) {
     sendAT(GF("+QCFG=\"band\""));
     waitResponse(500);
     sendAT(GF("+QCFG=\"nwscanmode\""));
@@ -471,7 +443,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
 
     */
   }
-  void configure_europe_band(void){
+  void configure_europe_band(void) {
     /*
      * =>Speed-up auto detection
      * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
@@ -487,15 +459,15 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
      * B20 : 0x80000
      * =>80084
      */
-    //sendAT(GF("+QCFG=\"band\",F,80084,80084,1"));
+    // sendAT(GF("+QCFG=\"band\",F,80084,80084,1"));
     sendAT(GF("+QCFG=\"band\",3,80084,80084,1"));
     waitResponse(500);
   }
   bool automatic_register(bool restart_modem = false) {
     //// NB-IOT Band Configuration
     //// 1NCE: 80 for Band 8
-    //sendAT(GF("+QCFG=\"band\",0,0,80,1"));
-    //waitResponse(500);
+    // sendAT(GF("+QCFG=\"band\",0,0,80,1"));
+    // waitResponse(500);
 
     // Configure RAT(s) to be Searched
     // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
@@ -506,31 +478,31 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
 
     // Configure RAT Searching Sequence
     //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
-    //sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
-    // 00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
+    // sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
+    //  00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
     sendAT(GF("+QCFG=\"nwscanseq\",00,1"));
     waitResponse(500);
 
-    // Configure Network Category to be Searched under 
+    // Configure Network Category to be Searched under
     // 0 : LTE Cat M1
     // 1 : LTE Cat NB1
     // 2 : LTE Cat M1 and Cat NB1(default)
-    //sendAT(GF("+QCFG=\"iotopmode\",1,1"));
+    // sendAT(GF("+QCFG=\"iotopmode\",1,1"));
     sendAT(GF("+QCFG=\"iotopmode\",2,1"));
     waitResponse(500);
 
     //// Configure Service Domain
     //// 1 : use PS domain service for data-service
     //// 2 : CS & PS (default)
-    //sendAT(GF("+QCFG=\"servicedomain\",2,1"));
-    //waitResponse(500);
+    // sendAT(GF("+QCFG=\"servicedomain\",2,1"));
+    // waitResponse(500);
 
     //// Configure Get the EMM cause value
     //// 0 : Numeric value (default)
     //// 1 : Verbose value
-    //sendAT(GF("+QCFG=\"emmcause\",0"));
-    //waitResponse(500);
-    if(restart_modem){
+    // sendAT(GF("+QCFG=\"emmcause\",0"));
+    // waitResponse(500);
+    if (restart_modem) {
       setPhoneFunctionalityImpl(0);
       setPhoneFunctionalityImpl(1);
     }
@@ -538,12 +510,12 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     return true;
   }
   bool force_ltem_register(bool restart_modem = false) {
-    /* Purpose speed up searching time since much longer searching time for NB-IoT than eMTC
-     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
-     * 6.2. Solutions to Speed up Network Searching : 
+    /* Purpose speed up searching time since much longer searching time for
+     * NB-IoT than eMTC Based on Quectel Series Network Searching Scheme
+     * Introduction 2.0-1.pdf 6.2. Solutions to Speed up Network Searching :
      * 6.2.1 Disable NB-IoT and Enable Required RAT(s)
      */
-    // Configure Network Category to be Searched under 
+    // Configure Network Category to be Searched under
     // 0 : LTE Cat M1
     // 1 : LTE Cat NB1
     // 2 : LTE Cat M1 and Cat NB1(default)
@@ -555,19 +527,19 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     // 3 LTE only
     sendAT(GF("+QCFG=\"nwscanmode\",3,1"));
     waitResponse(500);
-    if(restart_modem){
+    if (restart_modem) {
       setPhoneFunctionalityImpl(0);
       setPhoneFunctionalityImpl(1);
     }
     return true;
   }
   bool force_nbiot_register(bool restart_modem = false) {
-    /* Purpose speed up searching time since much longer searching time for NB-IoT than eMTC
-     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
-     * 6.2. Solutions to Speed up Network Searching : 
+    /* Purpose speed up searching time since much longer searching time for
+     * NB-IoT than eMTC Based on Quectel Series Network Searching Scheme
+     * Introduction 2.0-1.pdf 6.2. Solutions to Speed up Network Searching :
      * 6.2.2. Enable NB-IoT Bands Supported by Current Operator Only
      */
-    // Configure Network Category to be Searched under 
+    // Configure Network Category to be Searched under
     // 0 : LTE Cat M1
     // 1 : LTE Cat NB1
     // 2 : LTE Cat M1 and Cat NB1(default)
@@ -575,8 +547,8 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     waitResponse(500);
     // Configure RAT Searching Sequence
     //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
-    //sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
-    // 00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
+    // sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
+    //  00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
     sendAT(GF("+QCFG=\"nwscanseq\",020301,1"));
     waitResponse(500);
     // Configure RAT(s) to be Searched
@@ -585,16 +557,16 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     // 3 LTE only
     sendAT(GF("+QCFG=\"nwscanmode\",3,1"));
     waitResponse(500);
-    if(restart_modem){
+    if (restart_modem) {
       setPhoneFunctionalityImpl(0);
       setPhoneFunctionalityImpl(1);
     }
     return true;
   }
   bool force_gsm_register(bool restart_modem = false) {
-    /* Purpose speed up searching time since much longer searching time for NB-IoT than eMTC
-     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
-     * 6.2. Solutions to Speed up Network Searching : 
+    /* Purpose speed up searching time since much longer searching time for
+     * NB-IoT than eMTC Based on Quectel Series Network Searching Scheme
+     * Introduction 2.0-1.pdf 6.2. Solutions to Speed up Network Searching :
      * 6.2.1 Disable NB-IoT and Enable Required RAT(s)
      */
     // Configure RAT(s) to be Searched
@@ -603,19 +575,20 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     // 3 LTE only
     sendAT(GF("+QCFG=\"nwscanmode\",1,1"));
     waitResponse(500);
-    if(restart_modem){
+    if (restart_modem) {
       setPhoneFunctionalityImpl(0);
       setPhoneFunctionalityImpl(1);
     }
     return true;
   }
-  bool lte_and_falling_gsm_register(bool restore_band = false, bool restart_modem = false) {
-    if(restore_band){
+  bool lte_and_falling_gsm_register(bool restore_band  = false,
+                                    bool restart_modem = false) {
+    if (restore_band) {
       // Restore default Banc Configuration
       sendAT(GF("+QCFG=\"bandrestore\""));
       waitResponse(500);
     }
-    // Configure Network Category to be Searched under 
+    // Configure Network Category to be Searched under
     // 0 : LTE Cat M1
     // 1 : LTE Cat NB1
     // 2 : LTE Cat M1 and Cat NB1(default)
@@ -629,14 +602,14 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     waitResponse(500);
     // Configure RAT Searching Sequence
     //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
-    //sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
-    // 00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
-    // 01 : GSM
-    // 02 : LTE-M(eMTC)
-    // 03 : NB-IOT
+    // sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
+    //  00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
+    //  01 : GSM
+    //  02 : LTE-M(eMTC)
+    //  03 : NB-IOT
     sendAT(GF("+QCFG=\"nwscanseq\",020301,1"));
     waitResponse(500);
-    if(restart_modem){
+    if (restart_modem) {
       setPhoneFunctionalityImpl(0);
       setPhoneFunctionalityImpl(1);
     }
@@ -650,9 +623,9 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * 8 : eMTC/LTE-M
    * 9 : NB-IoT
    */
-#define MODEM_COP_GSM     (0)
-#define MODEM_COP_EMTC    (8)
-#define MODEM_COP_NBIOT   (9)
+#define MODEM_COP_GSM (0)
+#define MODEM_COP_EMTC (8)
+#define MODEM_COP_NBIOT (9)
   uint8_t get_access_technology(void) {
     uint8_t act_value;
     sendAT(GF("+COPS?"));
@@ -695,7 +668,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
   // get the RAW GPS output
   String getGPSrawImpl() {
     sendAT(GF("+QGPSLOC=2"));
-    if (waitResponse(10000L, GF(GSM_NL "+QGPSLOC:")) != 1) { return ""; }
+    if (waitResponse(10000L, GF(AT_NL "+QGPSLOC:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -708,7 +681,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
                   int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
                   int* minute = 0, int* second = 0) {
     sendAT(GF("+QGPSLOC=2"));
-    if (waitResponse(10000L, GF(GSM_NL "+QGPSLOC: ")) != 1) {
+    if (waitResponse(10000L, GF(AT_NL "+QGPSLOC:")) != 1) {
       // NOTE:  Will return an error if the position isn't fixed
       return false;
     }
@@ -750,20 +723,20 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
                             // 0, it is the type of error.
 
     // Set pointers
-    if (lat != NULL) *lat = ilat;
-    if (lon != NULL) *lon = ilon;
-    if (speed != NULL) *speed = ispeed;
-    if (alt != NULL) *alt = ialt;
-    if (vsat != NULL) *vsat = 0;
-    if (usat != NULL) *usat = iusat;
-    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (lat != nullptr) *lat = ilat;
+    if (lon != nullptr) *lon = ilon;
+    if (speed != nullptr) *speed = ispeed;
+    if (alt != nullptr) *alt = ialt;
+    if (vsat != nullptr) *vsat = 0;
+    if (usat != nullptr) *usat = iusat;
+    if (accuracy != nullptr) *accuracy = iaccuracy;
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = static_cast<int>(secondWithSS);
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
     waitResponse();  // Final OK
     return true;
@@ -795,7 +768,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
   // response to CCLK, so we're using QLTS where we can specifically request
   // local time.
   bool getNetworkUTCTimeImpl(int* year, int* month, int* day, int* hour,
-                          int* minute, int* second, float* timezone) {
+                             int* minute, int* second, float* timezone) {
     sendAT(GF("+QLTS=1"));
     if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return false; }
 
@@ -821,13 +794,13 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
 
     // Set pointers
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = isec;
-    if (timezone != NULL) *timezone = static_cast<float>(itimezone) / 4.0;
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = isec;
+    if (timezone != nullptr) *timezone = static_cast<float>(itimezone) / 4.0;
 
     // Final OK
     waitResponse();  // Ends with OK
@@ -864,13 +837,13 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
 
     // Set pointers
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = isec;
-    if (timezone != NULL) *timezone = static_cast<float>(itimezone) / 4.0;
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = isec;
+    if (timezone != nullptr) *timezone = static_cast<float>(itimezone) / 4.0;
 
     // Final OK
     waitResponse();  // Ends with OK
@@ -911,7 +884,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
   // get temperature in degree celsius
   uint16_t getTemperatureImpl() {
     sendAT(GF("+QTEMP"));
-    if (waitResponse(GF(GSM_NL "+QTEMP:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+QTEMP:")) != 1) { return 0; }
     // return temperature in C
     uint16_t res =
         streamGetIntBefore(',');  // read PMIC (primary ic) temperature
@@ -928,67 +901,67 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
  protected:
   bool modemConnect(const char* host, uint16_t port, uint8_t mux,
                     bool ssl = false, int timeout_s = 150) {
-
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
 
-      // set the ssl version
-      // AT+QSSLCFG="sslversion",<ctxindex>,<sslversion>
+    // set the ssl version
+    // AT+QSSLCFG="sslversion",<ctxindex>,<sslversion>
+    // <ctxindex> PDP context identifier
+    // <sslversion> 0: QAPI_NET_SSL_3.0
+    //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
+    //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
+    //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
+    //              4: ALL
+    // NOTE:  despite docs using caps, "sslversion" must be in lower case
+    sendAT(GF("+QSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
+    if (waitResponse(5000L) != 1) return false;
+    // set the ssl cipher_suite
+    // AT+QSSLCFG="ciphersuite",<ctxindex>,<cipher_suite>
+    // <ctxindex> PDP context identifier
+    // <cipher_suite> 0: TODO
+    //              1: TODO
+    //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+    //              0XFFFF: ALL
+    // NOTE:  despite docs using caps, "sslversion" must be in lower case
+    sendAT(GF(
+        "+QSSLCFG=\"ciphersuite\",0,0X0035"));  // TLS_RSA_WITH_AES_256_CBC_SHA
+    if (waitResponse(5000L) != 1) return false;
+    // set the ssl sec level
+    // AT+QSSLCFG="seclevel",<ctxindex>,<sec_level>
+    // <ctxindex> PDP context identifier
+    // <sec_level> 0: TODO
+    //              1: TODO
+    //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+    //              0XFFFF: ALL
+    // NOTE:  despite docs using caps, "sslversion" must be in lower case
+    sendAT(GF("+QSSLCFG=\"seclevel\",0,1"));
+    if (waitResponse(5000L) != 1) return false;
+
+
+    if (certificates[mux] != "") {
+      // apply the correct certificate to the connection
+      // AT+QSSLCFG="cacert",<ctxindex>,<caname>
       // <ctxindex> PDP context identifier
-      // <sslversion> 0: QAPI_NET_SSL_3.0
-      //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
-      //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
-      //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
-      //              4: ALL
-      // NOTE:  despite docs using caps, "sslversion" must be in lower case
-      sendAT(GF("+QSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
+      // <certname> certificate name
+
+      // sendAT(GF("+CASSLCFG="), mux, ",CACERT,\"", certificates[mux].c_str(),
+      //        "\"");
+      sendAT(GF("+QSSLCFG=\"cacert\",0,\""), certificates[mux].c_str(),
+             GF("\""));
       if (waitResponse(5000L) != 1) return false;
-      // set the ssl cipher_suite
-      // AT+QSSLCFG="ciphersuite",<ctxindex>,<cipher_suite>
-      // <ctxindex> PDP context identifier
-      // <cipher_suite> 0: TODO
-      //              1: TODO
-      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
-      //              0XFFFF: ALL
-      // NOTE:  despite docs using caps, "sslversion" must be in lower case
-      sendAT(GF("+QSSLCFG=\"ciphersuite\",0,0X0035"));  // TLS_RSA_WITH_AES_256_CBC_SHA
-      if (waitResponse(5000L) != 1) return false;
-      // set the ssl sec level
-      // AT+QSSLCFG="seclevel",<ctxindex>,<sec_level>
-      // <ctxindex> PDP context identifier
-      // <sec_level> 0: TODO
-      //              1: TODO
-      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
-      //              0XFFFF: ALL
-      // NOTE:  despite docs using caps, "sslversion" must be in lower case
-      sendAT(GF("+QSSLCFG=\"seclevel\",0,1"));
-      if (waitResponse(5000L) != 1) return false;
-
-
-      if (certificates[mux] != "") {
-        // apply the correct certificate to the connection
-        // AT+QSSLCFG="cacert",<ctxindex>,<caname>
-        // <ctxindex> PDP context identifier
-        // <certname> certificate name
-
-        //sendAT(GF("+CASSLCFG="), mux, ",CACERT,\"", certificates[mux].c_str(),
-        //       "\"");
-        sendAT(GF("+QSSLCFG=\"cacert\",0,\""), certificates[mux].c_str(), GF("\""));
-        if (waitResponse(5000L) != 1) return false;
-
-      }
+    }
 
     // <PDPcontextID>(1-16), <connectID>(0-11),
     // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
     // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
-    //may need previous AT+QSSLCFG
-    sendAT(GF("+QSSLOPEN=1,1,"), mux, GF(",\""), host,
-          GF("\","), port, GF(",0"));
+    // may need previous AT+QSSLCFG
+    sendAT(GF("+QSSLOPEN=1,1,"), mux, GF(",\""), host, GF("\","), port,
+           GF(",0"));
     waitResponse();
 
-    if (waitResponse(timeout_ms, GF(GSM_NL "+QSSLOPEN:")) != 1) { return false; }
-    //20230629 -> +QSSLOPEN: <clientID>,<err>
-    //clientID is mux
-    //err must be 0
+    if (waitResponse(timeout_ms, GF(AT_NL "+QSSLOPEN:")) != 1) { return false; }
+    // 20230629 -> +QSSLOPEN: <clientID>,<err>
+    // clientID is mux
+    // err must be 0
     if (streamGetIntBefore(',') != mux) { return false; }
     // Read status
     return (0 == streamGetIntBefore('\n'));
@@ -999,7 +972,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "SEND OK")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
     // TODO(?): Wait for ACK? AT+QSSLSEND=id,0
     return len;
   }
@@ -1013,9 +986,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     }
     int16_t len = streamGetIntBefore('\n');
 
-    for (int i = 0; i < len; i++) {
-      moveCharFromStreamToFifo(mux);
-      }
+    for (int i = 0; i < len; i++) { moveCharFromStreamToFifo(mux); }
     waitResponse();
     sockets[mux]->sock_available = modemGetAvailable(mux);
     return len;
@@ -1032,7 +1003,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
       if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
       waitResponse();
     }
-    //if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
+    // if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
     return result;
   }
 
@@ -1059,110 +1030,30 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+QIURC:"))) {
-          streamSkipUntil('\"');
-          String urc = stream.readStringUntil('\"');
-          streamSkipUntil(',');
-          if (urc == "recv") {
-            int8_t mux = streamGetIntBefore('\n');
-            DBG("### URC RECV:", mux);
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->got_data = true;
-            }
-          } else if (urc == "closed") {
-            int8_t mux = streamGetIntBefore('\n');
-            DBG("### URC CLOSE:", mux);
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->sock_connected = false;
-            }
-          } else {
-            streamSkipUntil('\n');
-          }
-          data = "";
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(AT_NL "+QIURC:"))) {
+      streamSkipUntil('\"');
+      String urc = stream.readStringUntil('\"');
+      streamSkipUntil(',');
+      if (urc == "recv") {
+        int8_t mux = streamGetIntBefore('\n');
+        DBG("### URC RECV:", mux);
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->got_data = true;
         }
+      } else if (urc == "closed") {
+        int8_t mux = streamGetIntBefore('\n');
+        DBG("### URC CLOSE:", mux);
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->sock_connected = false;
+        }
+      } else {
+        streamSkipUntil('\n');
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length() && data!="RDY") { DBG("### Unhandled:", data); }
       data = "";
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
@@ -1170,7 +1061,6 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
 
  protected:
   GsmClientBG95* sockets[TINY_GSM_MUX_COUNT];
-  const char*    gsmNL = GSM_NL;
   String         certificates[TINY_GSM_MUX_COUNT];
 };
 

From 6e76ba92e5338d1f0f0ae14375a1eb25f8962711 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 14:34:45 -0400
Subject: [PATCH 053/100] Rename for consistency

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .github/workflows/build_examples_platformio.yaml       |  1 +
 src/TinyGsmClient.h                                    | 10 +++++-----
 ...inyGsmClientSecureBG95.h => TinyGsmClientBG95SSL.h} |  2 ++
 3 files changed, 8 insertions(+), 5 deletions(-)
 rename src/{TinyGsmClientSecureBG95.h => TinyGsmClientBG95SSL.h} (99%)

diff --git a/.github/workflows/build_examples_platformio.yaml b/.github/workflows/build_examples_platformio.yaml
index b23069b..1f3bc19 100644
--- a/.github/workflows/build_examples_platformio.yaml
+++ b/.github/workflows/build_examples_platformio.yaml
@@ -23,6 +23,7 @@ jobs:
           [
             TINY_GSM_MODEM_A6,
             TINY_GSM_MODEM_BG96,
+            TINY_GSM_MODEM_BG95SSL,
             TINY_GSM_MODEM_ESP8266,
             TINY_GSM_MODEM_M95,
             TINY_GSM_MODEM_M590,
diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index 0c3c754..13407cf 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -75,13 +75,13 @@ typedef TinyGsmM95::GsmClientM95 TinyGsmClient;
 
 #elif defined(TINY_GSM_MODEM_BG96)
 #include "TinyGsmClientBG96.h"
-typedef TinyGsmBG96                TinyGsm;
-typedef TinyGsmBG96::GsmClientBG96 TinyGsmClient;
+typedef TinyGsmBG96                      TinyGsm;
+typedef TinyGsmBG96::GsmClientBG96       TinyGsmClient;
 typedef TinyGsmBG96::GsmClientSecureBG96 TinyGsmClientSecure;
 
-#elif defined(TINY_GSM_MODEM_SECURE_BG95)
-#include "TinyGsmClientSecureBG95.h"
-typedef TinyGsmBG95                TinyGsm;
+#elif defined(TINY_GSM_MODEM_BG95SSL)
+#include "TinyGsmClientBG95SSL.h"
+typedef TinyGsmBG95                      TinyGsm;
 typedef TinyGsmBG95::GsmClientSecureBG95 TinyGsmClientSecure;
 
 #elif defined(TINY_GSM_MODEM_A6) || defined(TINY_GSM_MODEM_A7)
diff --git a/src/TinyGsmClientSecureBG95.h b/src/TinyGsmClientBG95SSL.h
similarity index 99%
rename from src/TinyGsmClientSecureBG95.h
rename to src/TinyGsmClientBG95SSL.h
index 721644b..8f5bdf8 100644
--- a/src/TinyGsmClientSecureBG95.h
+++ b/src/TinyGsmClientBG95SSL.h
@@ -180,6 +180,8 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     // Enable automatic time zone update
     sendAT(GF("+CTZU=1"));
     if (waitResponse(10000L) != 1) { return false; }
+
+    return true;
   }
 
   /*

From 4858785469d28b804c1557feef97cdc8063b1ade Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 14:35:08 -0400
Subject: [PATCH 054/100] Fix unused argument

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientBG95SSL.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientBG95SSL.h b/src/TinyGsmClientBG95SSL.h
index 8f5bdf8..fdbbae9 100644
--- a/src/TinyGsmClientBG95SSL.h
+++ b/src/TinyGsmClientBG95SSL.h
@@ -155,7 +155,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = nullptr) {
+  bool initImpl(const char*) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientBG95"));
 

From 74734ef560bc9fd05d0ed536fdf1f5b4edfad851 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 14:49:29 -0400
Subject: [PATCH 055/100] Testing updates for BG95SSL

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .github/workflows/build_examples_platformio.yaml |  7 +++++++
 examples/AllFunctions/AllFunctions.ino           |  3 ++-
 examples/WebClient/WebClient.ino                 |  4 ++++
 src/TinyGsmClientBG95SSL.h                       |  1 +
 tools/Diagnostics/Diagnostics.ino                | 10 +++++++---
 tools/test_build/test_build.ino                  |  2 ++
 6 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/build_examples_platformio.yaml b/.github/workflows/build_examples_platformio.yaml
index 1f3bc19..5e390d4 100644
--- a/.github/workflows/build_examples_platformio.yaml
+++ b/.github/workflows/build_examples_platformio.yaml
@@ -40,6 +40,13 @@ jobs:
             TINY_GSM_MODEM_XBEE,
             TINY_GSM_MODEM_SEQUANS_MONARCH,
           ]
+        exclude:
+          - modem: TINY_GSM_MODEM_BG95SSL
+            example: examples/BlynkClient
+          - modem: TINY_GSM_MODEM_BG95SSL
+            example: examples/FileDownload
+          - modem: TINY_GSM_MODEM_BG95SSL
+            example: examples/MqttClient
 
     steps:
       - uses: actions/checkout@v3
diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index b3e6ff6..1cd3080 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -225,7 +225,8 @@ void loop() {
   DBG("Phone number (USSD):", ussd_phone_num);
 #endif
 
-#if TINY_GSM_TEST_TCP && defined TINY_GSM_MODEM_HAS_TCP
+#if TINY_GSM_TEST_TCP && defined TINY_GSM_MODEM_HAS_TCP && \
+    not defined(TINY_GSM_MODEM_BG95SSL)
   TinyGsmClient client(modem, 0);
   const int     port = 80;
   DBG("Connecting to", server);
diff --git a/examples/WebClient/WebClient.ino b/examples/WebClient/WebClient.ino
index 74ffa0a..59802f1 100644
--- a/examples/WebClient/WebClient.ino
+++ b/examples/WebClient/WebClient.ino
@@ -117,6 +117,10 @@ TinyGsm        modem(debugger);
 TinyGsm        modem(SerialAT);
 #endif
 
+#if defined(TINY_GSM_MODEM_HAS_SSL)
+#define USE_SSL
+#endif
+
 #ifdef USE_SSL
 TinyGsmClientSecure client(modem);
 const int           port = 443;
diff --git a/src/TinyGsmClientBG95SSL.h b/src/TinyGsmClientBG95SSL.h
index fdbbae9..eb7c661 100644
--- a/src/TinyGsmClientBG95SSL.h
+++ b/src/TinyGsmClientBG95SSL.h
@@ -26,6 +26,7 @@
 #include "TinyGsmModem.tpp"
 #include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
diff --git a/tools/Diagnostics/Diagnostics.ino b/tools/Diagnostics/Diagnostics.ino
index 198f9c4..152d6f5 100644
--- a/tools/Diagnostics/Diagnostics.ino
+++ b/tools/Diagnostics/Diagnostics.ino
@@ -115,9 +115,13 @@ TinyGsm        modem(debugger);
 TinyGsm        modem(SerialAT);
 #endif
 
-#ifdef USE_SSL&& defined TINY_GSM_MODEM_HAS_SSL
-TinyGsmClientSecure      client(modem);
-const int                port = 443;
+#if defined(TINY_GSM_MODEM_HAS_SSL)
+#define USE_SSL
+#endif
+
+#ifdef USE_SSL
+TinyGsmClientSecure client(modem);
+const int           port = 443;
 #else
 TinyGsmClient  client(modem);
 const int      port = 80;
diff --git a/tools/test_build/test_build.ino b/tools/test_build/test_build.ino
index 957c1ce..33ec12e 100644
--- a/tools/test_build/test_build.ino
+++ b/tools/test_build/test_build.ino
@@ -63,6 +63,7 @@ void loop() {
   modem.networkDisconnect();
 #endif
 
+#if not defined(TINY_GSM_MODEM_BG95SSL)  // no insecure client
   // Test TCP functions
   modem.maintain();
   TinyGsmClient client;
@@ -90,6 +91,7 @@ void loop() {
   }
 
   client.stop();
+#endif
 
 #if defined(TINY_GSM_MODEM_HAS_SSL)
   // modem.addCertificate();  // not yet impemented

From 4d9060fbd928fef456cfeb3178fa0d54ff13070d Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 15:02:36 -0400
Subject: [PATCH 056/100] Make set baud a bool return

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientESP8266.h |  5 +++--
 src/TinyGsmClientXBee.h    |  3 ++-
 src/TinyGsmModem.tpp       | 10 +++++-----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index b0f5f4d..0e66e92 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -187,7 +187,7 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     return res;
   }
 
-  void setBaudImpl(uint32_t baud) {
+  bool setBaudImpl(uint32_t baud) {
     sendAT(GF("+UART_CUR="), baud, "8,1,0,0");
     if (waitResponse() != 1) {
       sendAT(GF("+UART="), baud,
@@ -195,9 +195,10 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
       // if (waitResponse() != 1) {
       //   sendAT(GF("+IPR="), baud);  // First release firmwares might need
       //   this
-      waitResponse();
+      return waitResponse() == 1;
       // }
     }
+    return false;
   }
 
   bool factoryDefaultImpl() {
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index a8b7088..0a53a63 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -401,7 +401,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return sendATGetString(GF("VR"));
   }
 
-  void setBaudImpl(uint32_t baud) {
+  bool setBaudImpl(uint32_t baud) {
     XBEE_COMMAND_START_DECORATOR(5, )
     bool changesMade = false;
     switch (baud) {
@@ -424,6 +424,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     }
     if (changesMade) { writeChanges(); }
     XBEE_COMMAND_END_DECORATOR
+    return true;
   }
 
   bool testATImpl(uint32_t timeout_ms = 10000L) {
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index f73f82d..24d7b50 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -59,8 +59,8 @@ class TinyGsmModem {
     thisModem().stream.flush();
     TINY_GSM_YIELD(); /* DBG("### AT:", cmd...); */
   }
-  void setBaud(uint32_t baud) {
-    thisModem().setBaudImpl(baud);
+  bool setBaud(uint32_t baud) {
+    return thisModem().setBaudImpl(baud);
   }
   // Test response to AT commands
   bool testAT(uint32_t timeout_ms = 10000L) {
@@ -172,10 +172,10 @@ class TinyGsmModem {
    * Basic functions
    */
  protected:
-  void setBaudImpl(uint32_t baud) {
+  bool setBaudImpl(uint32_t baud) {
     thisModem().sendAT(GF("+IPR="), baud);
-    thisModem().waitResponse();
-  }
+    return thisModem().waitResponse() == 1;
+  } 
 
   bool testATImpl(uint32_t timeout_ms = 10000L) {
     for (uint32_t start = millis(); millis() - start < timeout_ms;) {

From ae81ee8b9d4ea22d49f1c6389d85a56bd43b917a Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 15:05:10 -0400
Subject: [PATCH 057/100] Remove mistaken BG96 secure

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClient.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index 13407cf..4474d09 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -75,9 +75,9 @@ typedef TinyGsmM95::GsmClientM95 TinyGsmClient;
 
 #elif defined(TINY_GSM_MODEM_BG96)
 #include "TinyGsmClientBG96.h"
-typedef TinyGsmBG96                      TinyGsm;
-typedef TinyGsmBG96::GsmClientBG96       TinyGsmClient;
-typedef TinyGsmBG96::GsmClientSecureBG96 TinyGsmClientSecure;
+typedef TinyGsmBG96                TinyGsm;
+typedef TinyGsmBG96::GsmClientBG96 TinyGsmClient;
+// typedef TinyGsmBG96::GsmClientSecureBG96 TinyGsmClientSecure;
 
 #elif defined(TINY_GSM_MODEM_BG95SSL)
 #include "TinyGsmClientBG95SSL.h"

From b189018747719ab6c7c571a59f3e5cb5411d70ee Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 15:26:11 -0400
Subject: [PATCH 058/100] Fix errant GSM_NL

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .github/workflows/build_examples_platformio.yaml | 4 ++++
 src/TinyGsmClientSIM7600.h                       | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/build_examples_platformio.yaml b/.github/workflows/build_examples_platformio.yaml
index 5e390d4..bd8745e 100644
--- a/.github/workflows/build_examples_platformio.yaml
+++ b/.github/workflows/build_examples_platformio.yaml
@@ -3,6 +3,10 @@ name: Build Examples with PlatformIO
 # Triggers the workflow on push or pull request events
 on: [push, pull_request]
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     runs-on: ubuntu-latest
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 3e2c689..d4498d2 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -291,7 +291,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     // n: whether to automatically report the system mode info
     // stat: the current service. 0 if it not connected
     sendAT(GF("+CNSMOD?"));
-    if (waitResponse(GF(GSM_NL "+CNSMOD:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+CNSMOD:")) != 1) { return false; }
     n    = streamGetIntBefore(',') != 0;
     stat = streamGetIntBefore('\n');
     waitResponse();

From 74a8eaddbe874fdc0b9bfea4f5e383536c14afb2 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 15:49:42 -0400
Subject: [PATCH 059/100] Update SARA-R5 to use URCs

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSaraR5.h | 213 +++++++++++---------------------------
 1 file changed, 63 insertions(+), 150 deletions(-)

diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index 7c59c85..492e0e1 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -14,6 +14,10 @@
 
 #define TINY_GSM_MUX_COUNT 7
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef AT_NL
+#undef AT_NL
+#endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -28,15 +32,7 @@
 
 #include <string.h>
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
-enum RegStatus {
+enum SaraR5RegStatus {
   REG_NO_RESULT        = -1,
   REG_UNREGISTERED     = 0,
   REG_SEARCHING        = 2,
@@ -123,7 +119,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
       sock_connected = at->modemConnect(host, port, &mux, false, timeout_s);
       if (mux != oldMux) {
         DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
-        at->sockets[oldMux] = NULL;
+        at->sockets[oldMux] = nullptr;
       }
       at->sockets[mux] = this;
       at->maintain();
@@ -169,7 +165,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
       sock_connected = at->modemConnect(host, port, &mux, true, timeout_s);
       if (mux != oldMux) {
         DBG("WARNING:  Mux number changed from", oldMux, "to", mux);
-        at->sockets[oldMux] = NULL;
+        at->sockets[oldMux] = nullptr;
       }
       at->sockets[mux] = this;
       at->maintain();
@@ -190,7 +186,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSaraR5"));
 
@@ -216,7 +212,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
 
     SimStatus ret = getSimStatus();
     // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -231,13 +227,13 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     sendAT(GF("+CGMI"));
     String res1;
     if (waitResponse(1000L, res1) != 1) { return "u-blox Cellular Modem"; }
-    res1.replace(GSM_NL "OK" GSM_NL, "");
+    res1.replace(AT_NL "OK" AT_NL, "");
     res1.trim();
 
     sendAT(GF("+GMM"));
     String res2;
     if (waitResponse(1000L, res2) != 1) { return "u-blox Cellular Modem"; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.trim();
 
     String name = res1 + String(' ') + res2;
@@ -261,7 +257,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     if (!setPhoneFunctionality(16)) { return false; }
     delay(3000);  // TODO(?):  Verify delay timing here
@@ -284,16 +280,17 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
+  SaraR5RegStatus getRegistrationStatus() {
     // Check first for EPS registration
-    RegStatus epsStatus = (RegStatus)getRegistrationStatusXREG("CEREG");
+    SaraR5RegStatus epsStatus =
+        (SaraR5RegStatus)getRegistrationStatusXREG("CEREG");
 
     // If we're connected on EPS, great!
     if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
       return epsStatus;
     } else {
       // Otherwise, check generic network status
-      return (RegStatus)getRegistrationStatusXREG("CREG");
+      return (SaraR5RegStatus)getRegistrationStatusXREG("CREG");
     }
   }
 
@@ -325,7 +322,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    SaraR5RegStatus s = getRegistrationStatus();
     if (s == REG_OK_HOME || s == REG_OK_ROAMING || s == REG_SMS_ONLY_ROAMING ||
         s == REG_SMS_ONLY_HOME)
       return true;
@@ -337,7 +334,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
 
   String getLocalIPImpl() {
     sendAT(GF("+UPSND=0,0"));
-    if (waitResponse(GF(GSM_NL "+UPSND:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+UPSND:")) != 1) { return ""; }
     streamSkipUntil(',');   // Skip PSD profile
     streamSkipUntil('\"');  // Skip request type
     String res = stream.readStringUntil('\"');
@@ -349,8 +346,8 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     sendAT(GF("+CGATT=1"));  // attach to GPRS
     if (waitResponse(360000L) != 1) { return false; }
 
@@ -453,7 +450,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
   // This uses "CGSN" instead of "GSN"
   String getIMEIImpl() {
     sendAT(GF("+CGSN"));
-    if (waitResponse(GF(GSM_NL)) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL)) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -499,7 +496,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     // waitResponse(10000L) ;
     if (waitResponse(10000L) != 1) { return ""; }
     // wait for the final result - wait full timeout time
-    if (waitResponse(120000L, GF(GSM_NL "+UULOC:")) != 1) { return ""; }
+    if (waitResponse(120000L, GF(AT_NL "+UULOC:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -513,7 +510,6 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     return getUbloxLocationRaw(1);
   }
 
-
   inline bool getUbloxLocation(int8_t sensor, float* lat, float* lon,
                                float* speed = 0, float* alt = 0, int* vsat = 0,
                                int* usat = 0, float* accuracy = 0,
@@ -539,7 +535,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     // wait for first "OK"
     if (waitResponse(10000L) != 1) { return false; }
     // wait for the final result - wait full timeout time
-    if (waitResponse(120000L, GF(GSM_NL "+UULOC: ")) != 1) { return false; }
+    if (waitResponse(120000L, GF(AT_NL "+UULOC: ")) != 1) { return false; }
 
     // +UULOC: <date>, <time>, <lat>, <long>, <alt>, <uncertainty>, <speed>,
     // <direction>, <vertical_acc>, <sensor_used>, <SV_used>, <antenna_status>,
@@ -588,27 +584,26 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     }
 
     // Set pointers
-    if (lat != NULL) *lat = ilat;
-    if (lon != NULL) *lon = ilon;
-    if (speed != NULL) *speed = ispeed;
-    if (alt != NULL) *alt = ialt;
-    if (vsat != NULL) *vsat = 0;  // Number of satellites viewed not reported;
-    if (usat != NULL) *usat = iusat;
-    if (accuracy != NULL) *accuracy = iaccuracy;
+    if (lat != nullptr) *lat = ilat;
+    if (lon != nullptr) *lon = ilon;
+    if (speed != nullptr) *speed = ispeed;
+    if (alt != nullptr) *alt = ialt;
+    if (vsat != nullptr)
+      *vsat = 0;  // Number of satellites viewed not reported;
+    if (usat != nullptr) *usat = iusat;
+    if (accuracy != nullptr) *accuracy = iaccuracy;
     if (iyear < 2000) iyear += 2000;
-    if (year != NULL) *year = iyear;
-    if (month != NULL) *month = imonth;
-    if (day != NULL) *day = iday;
-    if (hour != NULL) *hour = ihour;
-    if (minute != NULL) *minute = imin;
-    if (second != NULL) *second = static_cast<int>(secondWithSS);
+    if (year != nullptr) *year = iyear;
+    if (month != nullptr) *month = imonth;
+    if (day != nullptr) *day = iday;
+    if (hour != nullptr) *hour = ihour;
+    if (minute != nullptr) *minute = imin;
+    if (second != nullptr) *second = static_cast<int>(secondWithSS);
 
     // final ok
     waitResponse();
     return true;
   }
-
-
   bool getGsmLocationImpl(float* lat, float* lon, float* accuracy = 0,
                           int* year = 0, int* month = 0, int* day = 0,
                           int* hour = 0, int* minute = 0, int* second = 0) {
@@ -637,7 +632,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
 
   int8_t getBattPercentImpl() {
     sendAT(GF("+CIND?"));
-    if (waitResponse(GF(GSM_NL "+CIND:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+CIND:")) != 1) { return 0; }
 
     int8_t res     = streamGetIntBefore(',');
     int8_t percent = res * 20;  // return is 0-5
@@ -676,7 +671,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     // create a socket
     sendAT(GF("+USOCR=6"));
     // reply is +USOCR: ## of socket created
-    if (waitResponse(GF(GSM_NL "+USOCR:")) != 1) { return false; }
+    if (waitResponse(GF(AT_NL "+USOCR:")) != 1) { return false; }
     *mux = streamGetIntBefore('\n');
     waitResponse();
 
@@ -710,7 +705,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     delay(50);
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
-    if (waitResponse(GF(GSM_NL "+USOWR:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+USOWR:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     int16_t sent = streamGetIntBefore('\n');
     waitResponse();  // sends back OK after the confirmation of number sent
@@ -720,7 +715,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
   size_t modemRead(size_t size, uint8_t mux) {
     if (!sockets[mux]) return 0;
     sendAT(GF("+USORD="), mux, ',', (uint16_t)size);
-    if (waitResponse(GF(GSM_NL "+USORD:")) != 1) { return 0; }
+    if (waitResponse(GF(AT_NL "+USORD:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip mux
     int16_t len = streamGetIntBefore(',');
     streamSkipUntil('\"');
@@ -738,7 +733,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     // NOTE:  Querying a closed socket gives an error "operation not allowed"
     sendAT(GF("+USORD="), mux, ",0");
     size_t  result = 0;
-    uint8_t res    = waitResponse(GF(GSM_NL "+USORD:"));
+    uint8_t res    = waitResponse(GF(AT_NL "+USORD:"));
     // Will give error "operation not allowed" when attempting to read a socket
     // that you have already told to close
     if (res == 1) {
@@ -748,14 +743,14 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
       waitResponse();
     }
     if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
-    // DBG("### AvailablE:", result, "on", mux);
+    // DBG("### Available:", result, "on", mux);
     return result;
   }
 
   bool modemGetConnected(uint8_t mux) {
     // NOTE:  Querying a closed socket gives an error "operation not allowed"
     sendAT(GF("+USOCTL="), mux, ",10");
-    uint8_t res = waitResponse(GF(GSM_NL "+USOCTL:"));
+    uint8_t res = waitResponse(GF(AT_NL "+USOCTL:"));
     if (res != 1) { return false; }
 
     streamSkipUntil(',');  // Skip mux
@@ -781,108 +776,28 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF("+UUSORD:"))) {
-          int8_t  mux = streamGetIntBefore(',');
-          int16_t len = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            // max size is 1024
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          // DBG("### URC Data Received:", len, "on", mux);
-        } else if (data.endsWith(GF("+UUSOCL:"))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### URC Sock Closed: ", mux);
-        }
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF("+UUSORD:"))) {
+      int8_t  mux = streamGetIntBefore(',');
+      int16_t len = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        // max size is 1024
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      // DBG("### URC Data Received:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+UUSOCL:"))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### URC Sock Closed: ", mux);
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  private:  // basically the same as waitResponse but without preemptive exiting
@@ -910,8 +825,6 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
 
  protected:
   GsmClientSaraR5* sockets[TINY_GSM_MUX_COUNT];
-  const char*      gsmNL = GSM_NL;
 };
 
-
 #endif  // SRC_TINYGSMCLIENTSARAR5_H_

From d40d82b004ac0ef9776ea3d32e8a140f64f55781 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 15:54:16 -0400
Subject: [PATCH 060/100] Fix XBee return

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientXBee.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 0a53a63..7c4dcd8 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -402,7 +402,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
   }
 
   bool setBaudImpl(uint32_t baud) {
-    XBEE_COMMAND_START_DECORATOR(5, )
+    XBEE_COMMAND_START_DECORATOR(5, false)
     bool changesMade = false;
     switch (baud) {
       case 2400: changesMade |= changeSettingIfNeeded(GF("BD"), 0x1); break;

From 3733c3312f508c64af0c2e7d8fc26abfc8870f76 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 16:05:33 -0400
Subject: [PATCH 061/100] Bump action versions

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .github/workflows/build_examples_platformio.yaml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/build_examples_platformio.yaml b/.github/workflows/build_examples_platformio.yaml
index bd8745e..ef94986 100644
--- a/.github/workflows/build_examples_platformio.yaml
+++ b/.github/workflows/build_examples_platformio.yaml
@@ -53,7 +53,7 @@ jobs:
             example: examples/MqttClient
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Set variables
         run: |
@@ -66,7 +66,7 @@ jobs:
           fi
 
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.x'
 
@@ -77,7 +77,7 @@ jobs:
           pip install --upgrade platformio
 
       - name: Restore or Cache Platforms and Libraries
-        uses: actions/cache@v3.3.1
+        uses: actions/cache@v4
         id: cache_pio
         with:
           path: ~/.platformio

From 9bdea3af2b10c5bc286610a83511bcb425537f3b Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 17 May 2024 16:08:05 -0400
Subject: [PATCH 062/100] Fix test build

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 tools/test_build/test_build.ino | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/test_build/test_build.ino b/tools/test_build/test_build.ino
index 33ec12e..80c5aa0 100644
--- a/tools/test_build/test_build.ino
+++ b/tools/test_build/test_build.ino
@@ -63,6 +63,9 @@ void loop() {
   modem.networkDisconnect();
 #endif
 
+  char server[]   = "somewhere";
+  char resource[] = "something";
+
 #if not defined(TINY_GSM_MODEM_BG95SSL)  // no insecure client
   // Test TCP functions
   modem.maintain();
@@ -72,9 +75,6 @@ void loop() {
   client.init(&modem);
   client.init(&modem, 1);
 
-  char server[]   = "somewhere";
-  char resource[] = "something";
-
   client.connect(server, 80);
 
   // Make a HTTP GET request:

From e4fa39d6b088ab99011a8290234b4ba65ed396dc Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 20 May 2024 12:26:27 -0400
Subject: [PATCH 063/100] Removed BG95SSL test functions

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientBG95SSL.h | 343 -------------------------------------
 1 file changed, 343 deletions(-)

diff --git a/src/TinyGsmClientBG95SSL.h b/src/TinyGsmClientBG95SSL.h
index eb7c661..1437a78 100644
--- a/src/TinyGsmClientBG95SSL.h
+++ b/src/TinyGsmClientBG95SSL.h
@@ -308,349 +308,6 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
   // commands.  As this is a separate paid service which I do not have access
   // to, I am not implementing it here.
 
-
-  /*
-   * Testing functions
-   */
-
- public:
-  String getModemManufacturer() {
-    sendAT(GF("+GMI"));
-    String res;
-    if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, " ");
-    res.trim();
-    return res;
-  }
-  String getModemFirmwareFullVersion() {
-    sendAT(GF("+QGMR"));
-    String res;
-    if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, " ");
-    res.trim();
-    return res;
-  }
-  String getModemFirmwareApplicationVersionn() {
-    sendAT(GF("+QAPPVER"));
-    String res;
-    if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, " ");
-    res.replace("+QAPPVER: ", "");
-    res.trim();
-    return res;
-  }
-  bool configureGPS(void) {
-    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));  // Based on Mobile Country Code
-                                              // (europe : galileo)
-    if (waitResponse() != 1) { return false; }
-    return true;
-  }
-  bool configureGPSPriority(void) {
-    sendAT(GF("+QGPSCFG=\"priority\""));  // Priority GNSS instead of WWAN
-    if (waitResponse() != 1) { return false; }
-    return true;
-  }
-  bool test(void) {
-    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));  // Based on Mobile Country Code
-                                              // (europe : galileo)
-    waitResponse();
-    sendAT(GF("+QGPSCFG=\"priority\",0,0"));  // Priority GNSS, not saved
-    waitResponse();
-    sendAT(GF("+QGPS=1,1,0,1"));  // Low Accuracy, Continuous positionning, Rate
-                                  // : 1 sec
-    waitResponse();
-    sendAT(GF("+QGPSCFG=\"gnssconfig\",5"));  // Based on Mobile Country Code
-                                              // (europe : galileo)
-    waitResponse();
-    sendAT(GF("+QGPSCFG=\"priority\",0,0"));  // Priority GNSS, not saved
-    waitResponse();
-    return true;
-  }
-  bool test_ask(void) {
-    sendAT(GF("+QGPSCFG=\"gnssconfig\""));  // Based on Mobile Country Code
-                                            // (europe : galileo)
-    waitResponse();
-    // if (waitResponse() != 1) { return false; }
-    sendAT(GF("+QGPSCFG=?"));
-    waitResponse();
-    sendAT(GF("+QGPSEND=?"));
-    waitResponse();
-    sendAT(GF("+QGPSEND"));
-    waitResponse();
-    return true;
-  }
-#define MODEM_RAT_SEARCHED_AUTOMATIC (0)
-#define MODEM_RAT_SEARCHED_GSM_ONLY (1)
-#define MODEM_RAT_SEARCHED_LTE_ONLY (3)
-#define MODEM_RAT_SEARCHED_ERROR (255)
-  uint8_t query_modem_rat_searched(void) {
-    uint8_t returned;
-    sendAT(GF("+QCFG=\"nwscanmode\""));
-    if (waitResponse(GF("+QCFG:")) != 1) { return MODEM_RAT_SEARCHED_ERROR; }
-    streamSkipUntil('"');
-    streamSkipUntil('"');
-    streamSkipUntil(',');
-    returned = stream.parseInt();
-    waitResponse();
-    return returned;
-    /* Max Response Time : 300ms
-     0 : Automatic (GSM + LTE)
-     1 : GSM only
-     3 : LTE only
-     */
-  }
-#define MODEM_NETWORK_CATEGORY_SEARCHED_EMTC (0)
-#define MODEM_NETWORK_CATEGORY_SEARCHED_NBIOT (1)
-#define MODEM_NETWORK_CATEGORY_SEARCHED_ALL (2)
-#define MODEM_NETWORK_CATEGORY_SEARCHED_ERROR (255)
-  uint8_t query_modem_network_category_searched(void) {
-    uint8_t returned;
-    sendAT(GF("+QCFG=\"iotopmode\""));
-    if (waitResponse(GF("+QCFG:")) != 1) {
-      return MODEM_NETWORK_CATEGORY_SEARCHED_ERROR;
-    }
-    streamSkipUntil('"');
-    streamSkipUntil('"');
-    streamSkipUntil(',');
-    returned = stream.parseInt();
-    waitResponse();
-    return returned;
-    /* Max Response Time : 300ms
-     0 : eMTC
-     1 : NB-IoT
-     2 : eMTC and NB-IoT
-     */
-  }
-  void query_modem_register_settings(void) {
-    sendAT(GF("+QCFG=\"band\""));
-    waitResponse(500);
-    sendAT(GF("+QCFG=\"nwscanmode\""));
-    waitResponse(500);
-    sendAT(GF("+QCFG=\"nwscanseq\""));
-    waitResponse(500);
-    sendAT(GF("+QCFG=\"iotopmode\""));
-    waitResponse(500);
-    /* Without any modification it gives :
-    +QCFG: "band",0x3,0x80084,0x80084
-    +QCFG: "nwscanmode",3
-    +QCFG: "nwscanseq",020301
-    +QCFG: "iotopmode",0
-    When previously set automatic_register
-    +QCFG: "band",0x3,0x80084,0x80084
-    +QCFG: "nwscanmode",0
-    +QCFG: "nwscanseq",020301
-    +QCFG: "iotopmode",2
-
-    */
-  }
-  void configure_europe_band(void) {
-    /*
-     * =>Speed-up auto detection
-     * Based on Quectel Series Network Searching Scheme Introduction 2.0-1.pdf
-     * existing GSM band : GSM850, EGSM900, DCS1800, PCS1900
-     * Europe GSM : EGSM900/DCS1800
-     * EGSM900 : 0x1
-     * DCS1800 : 0x2
-     * =>3
-     * F for all bands
-     * Europe eMTC & NB-IOT bands : B3/B8/B20
-     * B3 : 0x4
-     * B8 : 0x80
-     * B20 : 0x80000
-     * =>80084
-     */
-    // sendAT(GF("+QCFG=\"band\",F,80084,80084,1"));
-    sendAT(GF("+QCFG=\"band\",3,80084,80084,1"));
-    waitResponse(500);
-  }
-  bool automatic_register(bool restart_modem = false) {
-    //// NB-IOT Band Configuration
-    //// 1NCE: 80 for Band 8
-    // sendAT(GF("+QCFG=\"band\",0,0,80,1"));
-    // waitResponse(500);
-
-    // Configure RAT(s) to be Searched
-    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
-    // 1 GSM only
-    // 3 LTE only
-    sendAT(GF("+QCFG=\"nwscanmode\",0,1"));
-    waitResponse(500);
-
-    // Configure RAT Searching Sequence
-    //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
-    // sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
-    //  00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
-    sendAT(GF("+QCFG=\"nwscanseq\",00,1"));
-    waitResponse(500);
-
-    // Configure Network Category to be Searched under
-    // 0 : LTE Cat M1
-    // 1 : LTE Cat NB1
-    // 2 : LTE Cat M1 and Cat NB1(default)
-    // sendAT(GF("+QCFG=\"iotopmode\",1,1"));
-    sendAT(GF("+QCFG=\"iotopmode\",2,1"));
-    waitResponse(500);
-
-    //// Configure Service Domain
-    //// 1 : use PS domain service for data-service
-    //// 2 : CS & PS (default)
-    // sendAT(GF("+QCFG=\"servicedomain\",2,1"));
-    // waitResponse(500);
-
-    //// Configure Get the EMM cause value
-    //// 0 : Numeric value (default)
-    //// 1 : Verbose value
-    // sendAT(GF("+QCFG=\"emmcause\",0"));
-    // waitResponse(500);
-    if (restart_modem) {
-      setPhoneFunctionalityImpl(0);
-      setPhoneFunctionalityImpl(1);
-    }
-
-    return true;
-  }
-  bool force_ltem_register(bool restart_modem = false) {
-    /* Purpose speed up searching time since much longer searching time for
-     * NB-IoT than eMTC Based on Quectel Series Network Searching Scheme
-     * Introduction 2.0-1.pdf 6.2. Solutions to Speed up Network Searching :
-     * 6.2.1 Disable NB-IoT and Enable Required RAT(s)
-     */
-    // Configure Network Category to be Searched under
-    // 0 : LTE Cat M1
-    // 1 : LTE Cat NB1
-    // 2 : LTE Cat M1 and Cat NB1(default)
-    sendAT(GF("+QCFG=\"iotopmode\",0,1"));
-    waitResponse(500);
-    // Configure RAT(s) to be Searched
-    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
-    // 1 GSM only
-    // 3 LTE only
-    sendAT(GF("+QCFG=\"nwscanmode\",3,1"));
-    waitResponse(500);
-    if (restart_modem) {
-      setPhoneFunctionalityImpl(0);
-      setPhoneFunctionalityImpl(1);
-    }
-    return true;
-  }
-  bool force_nbiot_register(bool restart_modem = false) {
-    /* Purpose speed up searching time since much longer searching time for
-     * NB-IoT than eMTC Based on Quectel Series Network Searching Scheme
-     * Introduction 2.0-1.pdf 6.2. Solutions to Speed up Network Searching :
-     * 6.2.2. Enable NB-IoT Bands Supported by Current Operator Only
-     */
-    // Configure Network Category to be Searched under
-    // 0 : LTE Cat M1
-    // 1 : LTE Cat NB1
-    // 2 : LTE Cat M1 and Cat NB1(default)
-    sendAT(GF("+QCFG=\"iotopmode\",2,1"));
-    waitResponse(500);
-    // Configure RAT Searching Sequence
-    //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
-    // sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
-    //  00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
-    sendAT(GF("+QCFG=\"nwscanseq\",020301,1"));
-    waitResponse(500);
-    // Configure RAT(s) to be Searched
-    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
-    // 1 GSM only
-    // 3 LTE only
-    sendAT(GF("+QCFG=\"nwscanmode\",3,1"));
-    waitResponse(500);
-    if (restart_modem) {
-      setPhoneFunctionalityImpl(0);
-      setPhoneFunctionalityImpl(1);
-    }
-    return true;
-  }
-  bool force_gsm_register(bool restart_modem = false) {
-    /* Purpose speed up searching time since much longer searching time for
-     * NB-IoT than eMTC Based on Quectel Series Network Searching Scheme
-     * Introduction 2.0-1.pdf 6.2. Solutions to Speed up Network Searching :
-     * 6.2.1 Disable NB-IoT and Enable Required RAT(s)
-     */
-    // Configure RAT(s) to be Searched
-    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
-    // 1 GSM only
-    // 3 LTE only
-    sendAT(GF("+QCFG=\"nwscanmode\",1,1"));
-    waitResponse(500);
-    if (restart_modem) {
-      setPhoneFunctionalityImpl(0);
-      setPhoneFunctionalityImpl(1);
-    }
-    return true;
-  }
-  bool lte_and_falling_gsm_register(bool restore_band  = false,
-                                    bool restart_modem = false) {
-    if (restore_band) {
-      // Restore default Banc Configuration
-      sendAT(GF("+QCFG=\"bandrestore\""));
-      waitResponse(500);
-    }
-    // Configure Network Category to be Searched under
-    // 0 : LTE Cat M1
-    // 1 : LTE Cat NB1
-    // 2 : LTE Cat M1 and Cat NB1(default)
-    sendAT(GF("+QCFG=\"iotopmode\",2,1"));
-    waitResponse(500);
-    // Configure RAT(s) to be Searched
-    // 0 Automatic(GSM and LTE), 1 Take effect immediately(default)
-    // 1 GSM only
-    // 3 LTE only
-    sendAT(GF("+QCFG=\"nwscanmode\",0,1"));
-    waitResponse(500);
-    // Configure RAT Searching Sequence
-    //// (LTE Cat NB1 -> LTE Cat M1 -> GSM)
-    // sendAT(GF("+QCFG=\"nwscanseq\",030201,1"));
-    //  00 : (LTE Cat M1 -> LTE Cat NB1 -> GSM)(default)
-    //  01 : GSM
-    //  02 : LTE-M(eMTC)
-    //  03 : NB-IOT
-    sendAT(GF("+QCFG=\"nwscanseq\",020301,1"));
-    waitResponse(500);
-    if (restart_modem) {
-      setPhoneFunctionalityImpl(0);
-      setPhoneFunctionalityImpl(1);
-    }
-    return true;
-  }
-  /*
-   * parse AT+COPS :
-   * +COPS: <mode>[,<format>[,<oper>][,<Act>]]
-   * where <Act>:
-   * 0 : GSM
-   * 8 : eMTC/LTE-M
-   * 9 : NB-IoT
-   */
-#define MODEM_COP_GSM (0)
-#define MODEM_COP_EMTC (8)
-#define MODEM_COP_NBIOT (9)
-  uint8_t get_access_technology(void) {
-    uint8_t act_value;
-    sendAT(GF("+COPS?"));
-    if (waitResponse(GF("+COPS:")) != 1) { return 10; }
-    streamSkipUntil('"'); /* Skip mode and format */
-    streamSkipUntil('"'); /* Skip mode and format */
-    streamSkipUntil(','); /* Skip mode and format */
-    act_value = stream.parseInt();
-    waitResponse();
-    return act_value;
-  }
-  void get_emmcause(void) {
-    uint8_t act_value;
-    sendAT(GF("+QCFG=\"emmcause\",1"));
-    waitResponse();
-  }
-  bool ask_to_automatically_register(void) {
-    sendAT(GF("+COPS=0"));  // Auto-register to the network
-    if (waitResponse() != 1) { return false; }
-    return true;
-  }
-
   /*
    * GPS/GNSS/GLONASS location functions
    */

From df47b431a67b8e0211652326247a76ce22c6bc2c Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 20 May 2024 12:32:50 -0400
Subject: [PATCH 064/100] Merge BG95 and BG96

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientBG95SSL.h | 295 +++++++++++++++++++++------------
 src/TinyGsmClientBG96.h    | 331 ++++++++++++++++++-------------------
 2 files changed, 352 insertions(+), 274 deletions(-)

diff --git a/src/TinyGsmClientBG95SSL.h b/src/TinyGsmClientBG95SSL.h
index 1437a78..38629a8 100644
--- a/src/TinyGsmClientBG95SSL.h
+++ b/src/TinyGsmClientBG95SSL.h
@@ -73,6 +73,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     GsmClientBG95() {}
 
     explicit GsmClientBG95(TinyGsmBG95& modem, uint8_t mux = 0) {
+      ssl_sock = false;
       init(&modem, mux);
     }
 
@@ -93,20 +94,19 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
       return true;
     }
 
-   public:
     virtual int connect(const char* host, uint16_t port, int timeout_s) {
       stop();
       TINY_GSM_YIELD();
       rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, false, timeout_s);
+      sock_connected = at->modemConnect(host, port, mux, timeout_s);
       return sock_connected;
     }
     TINY_GSM_CLIENT_CONNECT_OVERRIDES
 
-    void stop(uint32_t maxWaitMs) {
+    virtual void stop(uint32_t maxWaitMs) {
       uint32_t startMillis = millis();
       dumpModemBuffer(maxWaitMs);
-      at->sendAT(GF("+QSSLCLOSE="), mux);
+      at->sendAT(GF("+QICLOSE="), mux);
       sock_connected = false;
       at->waitResponse((maxWaitMs - (millis() - startMillis)));
     }
@@ -119,6 +119,9 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
      */
 
     String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+
+   protected:
+    bool ssl_sock;
   };
 
   /*
@@ -129,19 +132,22 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    public:
     GsmClientSecureBG95() {}
 
-    GsmClientSecureBG95(TinyGsmBG95& modem, uint8_t mux = 0)
-        : GsmClientBG95(modem, mux) {}
-
-
-   public:
-    int connect(const char* host, uint16_t port, int timeout_s) override {
-      stop();
-      TINY_GSM_YIELD();
-      rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
-      return sock_connected;
+    explicit GsmClientSecureBG95(TinyGsmBG95& modem, uint8_t mux = 0)
+        : GsmClientBG95(modem, mux) {
+      ssl_sock = true;
+    }
+
+    bool setCertificate(const String& certificateName) {
+      return at->setCertificate(certificateName, mux);
+    }
+
+    void stop(uint32_t maxWaitMs) override {
+      uint32_t startMillis = millis();
+      dumpModemBuffer(maxWaitMs);
+      at->sendAT(GF("+QSSLCLOSE="), mux);
+      sock_connected = false;
+      at->waitResponse((maxWaitMs - (millis() - startMillis)));
     }
-    TINY_GSM_CLIENT_CONNECT_OVERRIDES
   };
 
   /*
@@ -156,7 +162,7 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char*) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientBG95"));
 
@@ -182,7 +188,16 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     sendAT(GF("+CTZU=1"));
     if (waitResponse(10000L) != 1) { return false; }
 
-    return true;
+    SimStatus ret = getSimStatus();
+    // if the sim isn't ready and a pin has been provided, try to unlock the sim
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
+      simUnlock(pin);
+      return (getSimStatus() == SIM_READY);
+    } else {
+      // if the sim is ready, or it's locked but no pin has been provided,
+      // return true
+      return (ret == SIM_READY || ret == SIM_LOCKED);
+    }
   }
 
   /*
@@ -226,8 +241,6 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     // Check first for EPS registration
     BG95RegStatus epsStatus = (BG95RegStatus)getRegistrationStatusXREG("CEREG");
 
-    // if REG_UNKNOWN
-
     // If we're connected on EPS, great!
     if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
       return epsStatus;
@@ -243,6 +256,16 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
+  /*
+   * Secure socket layer functions
+   */
+ protected:
+  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
+    if (mux >= TINY_GSM_MUX_COUNT) return false;
+    certificates[mux] = certificateName;
+    return true;
+  }
+
   /*
    * GPRS functions
    */
@@ -560,130 +583,194 @@ class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
    */
  protected:
   bool modemConnect(const char* host, uint16_t port, uint8_t mux,
-                    bool ssl = false, int timeout_s = 150) {
+                    int timeout_s = 150) {
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
+    bool     ssl        = sockets[mux]->ssl_sock;
 
-    // set the ssl version
-    // AT+QSSLCFG="sslversion",<ctxindex>,<sslversion>
-    // <ctxindex> PDP context identifier
-    // <sslversion> 0: QAPI_NET_SSL_3.0
-    //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
-    //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
-    //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
-    //              4: ALL
-    // NOTE:  despite docs using caps, "sslversion" must be in lower case
-    sendAT(GF("+QSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
-    if (waitResponse(5000L) != 1) return false;
-    // set the ssl cipher_suite
-    // AT+QSSLCFG="ciphersuite",<ctxindex>,<cipher_suite>
-    // <ctxindex> PDP context identifier
-    // <cipher_suite> 0: TODO
-    //              1: TODO
-    //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
-    //              0XFFFF: ALL
-    // NOTE:  despite docs using caps, "sslversion" must be in lower case
-    sendAT(GF(
-        "+QSSLCFG=\"ciphersuite\",0,0X0035"));  // TLS_RSA_WITH_AES_256_CBC_SHA
-    if (waitResponse(5000L) != 1) return false;
-    // set the ssl sec level
-    // AT+QSSLCFG="seclevel",<ctxindex>,<sec_level>
-    // <ctxindex> PDP context identifier
-    // <sec_level> 0: TODO
-    //              1: TODO
-    //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
-    //              0XFFFF: ALL
-    // NOTE:  despite docs using caps, "sslversion" must be in lower case
-    sendAT(GF("+QSSLCFG=\"seclevel\",0,1"));
-    if (waitResponse(5000L) != 1) return false;
-
-
-    if (certificates[mux] != "") {
-      // apply the correct certificate to the connection
-      // AT+QSSLCFG="cacert",<ctxindex>,<caname>
+    if (ssl) {
+      // set the ssl version
+      // AT+QSSLCFG="sslversion",<ctxindex>,<sslversion>
       // <ctxindex> PDP context identifier
-      // <certname> certificate name
-
-      // sendAT(GF("+CASSLCFG="), mux, ",CACERT,\"", certificates[mux].c_str(),
-      //        "\"");
-      sendAT(GF("+QSSLCFG=\"cacert\",0,\""), certificates[mux].c_str(),
-             GF("\""));
+      // <sslversion> 0: QAPI_NET_SSL_3.0
+      //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
+      //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
+      //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
+      //              4: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+QSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
       if (waitResponse(5000L) != 1) return false;
+      // set the ssl cipher_suite
+      // AT+QSSLCFG="ciphersuite",<ctxindex>,<cipher_suite>
+      // <ctxindex> PDP context identifier
+      // <cipher_suite> 0: TODO
+      //              1: TODO
+      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+      //              0XFFFF: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF(
+          "+QSSLCFG=\"ciphersuite\",0,0X0035"));  // TLS_RSA_WITH_AES_256_CBC_SHA
+      if (waitResponse(5000L) != 1) return false;
+      // set the ssl sec level
+      // AT+QSSLCFG="seclevel",<ctxindex>,<sec_level>
+      // <ctxindex> PDP context identifier
+      // <sec_level> 0: TODO
+      //              1: TODO
+      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+      //              0XFFFF: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+QSSLCFG=\"seclevel\",0,1"));
+      if (waitResponse(5000L) != 1) return false;
+
+
+      if (certificates[mux] != "") {
+        // apply the correct certificate to the connection
+        // AT+QSSLCFG="cacert",<ctxindex>,<caname>
+        // <ctxindex> PDP context identifier
+        // <certname> certificate name
+
+        // sendAT(GF("+CASSLCFG="), mux, ",CACERT,\"",
+        // certificates[mux].c_str(),
+        //        "\"");
+        sendAT(GF("+QSSLCFG=\"cacert\",0,\""), certificates[mux].c_str(),
+               GF("\""));
+        if (waitResponse(5000L) != 1) return false;
+      }
+
+      // <PDPcontextID>(1-16), <connectID>(0-11),
+      // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
+      // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
+      // may need previous AT+QSSLCFG
+      sendAT(GF("+QSSLOPEN=1,1,"), mux, GF(",\""), host, GF("\","), port,
+             GF(",0"));
+      waitResponse();
+
+      if (waitResponse(timeout_ms, GF(AT_NL "+QSSLOPEN:")) != 1) {
+        return false;
+      }
+      // 20230629 -> +QSSLOPEN: <clientID>,<err>
+      // clientID is mux
+      // err must be 0
+      if (streamGetIntBefore(',') != mux) { return false; }
+      // Read status
+      return (0 == streamGetIntBefore('\n'));
+    } else {
+      // AT+QIOPEN=1,0,"TCP","220.180.239.212",8009,0,0
+      // <PDPcontextID>(1-16), <connectID>(0-11),
+      // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
+      // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
+      sendAT(GF("+QIOPEN=1,"), mux, GF(",\""), GF("TCP"), GF("\",\""), host,
+             GF("\","), port, GF(",0,0"));
+      waitResponse();
+
+      if (waitResponse(timeout_ms, GF(AT_NL "+QIOPEN:")) != 1) { return false; }
+
+      if (streamGetIntBefore(',') != mux) { return false; }
     }
-
-    // <PDPcontextID>(1-16), <connectID>(0-11),
-    // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
-    // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
-    // may need previous AT+QSSLCFG
-    sendAT(GF("+QSSLOPEN=1,1,"), mux, GF(",\""), host, GF("\","), port,
-           GF(",0"));
-    waitResponse();
-
-    if (waitResponse(timeout_ms, GF(AT_NL "+QSSLOPEN:")) != 1) { return false; }
-    // 20230629 -> +QSSLOPEN: <clientID>,<err>
-    // clientID is mux
-    // err must be 0
-    if (streamGetIntBefore(',') != mux) { return false; }
     // Read status
     return (0 == streamGetIntBefore('\n'));
   }
 
   int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
-    sendAT(GF("+QSSLSEND="), mux, ',', (uint16_t)len);
+    bool ssl = sockets[mux]->ssl_sock;
+    if (ssl) {
+      sendAT(GF("+QSSLSEND="), mux, ',', (uint16_t)len);
+    } else {
+      sendAT(GF("+QISEND="), mux, ',', (uint16_t)len);
+    }
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
     if (waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
-    // TODO(?): Wait for ACK? AT+QSSLSEND=id,0
+    // TODO(?): Wait for ACK? (AT+QISEND=id,0 or AT+QSSLSEND=id,0)
     return len;
   }
 
   size_t modemRead(size_t size, uint8_t mux) {
     if (!sockets[mux]) return 0;
-    sendAT(GF("+QSSLRECV="), mux, ',', (uint16_t)size);
-    if (waitResponse(GF("+QSSLRECV:")) != 1) {
-      DBG("### READ: For unknown reason close");
-      return 0;
+    bool ssl = sockets[mux]->ssl_sock;
+    if (ssl) {
+      sendAT(GF("+QSSLRECV="), mux, ',', (uint16_t)size);
+      if (waitResponse(GF("+QSSLRECV:")) != 1) {
+        DBG("### READ: For unknown reason close");
+        return 0;
+      }
+    } else {
+      sendAT(GF("+QIRD="), mux, ',', (uint16_t)size);
+      if (waitResponse(GF("+QIRD:")) != 1) { return 0; }
     }
     int16_t len = streamGetIntBefore('\n');
 
     for (int i = 0; i < len; i++) { moveCharFromStreamToFifo(mux); }
     waitResponse();
+    // DBG("### READ:", len, "from", mux);
     sockets[mux]->sock_available = modemGetAvailable(mux);
     return len;
   }
 
   size_t modemGetAvailable(uint8_t mux) {
     if (!sockets[mux]) return 0;
-    sendAT(GF("+QSSLRECV="), mux, GF(",0"));
+    bool   ssl    = sockets[mux]->ssl_sock;
     size_t result = 0;
-    if (waitResponse(GF("+QSSLRECV:")) == 1) {
-      streamSkipUntil(',');  // Skip total received
-      streamSkipUntil(',');  // Skip have read
-      result = streamGetIntBefore('\n');
-      if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
-      waitResponse();
+    if (ssl) {
+      sendAT(GF("+QSSLRECV="), mux, GF(",0"));
+      if (waitResponse(GF("+QSSLRECV:")) == 1) {
+        streamSkipUntil(',');  // Skip total received
+        streamSkipUntil(',');  // Skip have read
+        result = streamGetIntBefore('\n');
+        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
+        waitResponse();
+      }
+    } else {
+      sendAT(GF("+QIRD="), mux, GF(",0"));
+      if (waitResponse(GF("+QIRD:")) == 1) {
+        streamSkipUntil(',');  // Skip total received
+        streamSkipUntil(',');  // Skip have read
+        result = streamGetIntBefore('\n');
+        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
+        waitResponse();
+      }
     }
-    // if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
+    if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
     return result;
   }
 
   bool modemGetConnected(uint8_t mux) {
-    sendAT(GF("+QSSLSTATE=1,"), mux);
-    // +QSSLSTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
+    bool ssl = sockets[mux]->ssl_sock;
+    if (ssl) {
+      sendAT(GF("+QSSLSTATE=1,"), mux);
+      // +QSSLSTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
 
-    if (waitResponse(GF("+QSSLSTATE:")) != 1) { return false; }
+      if (waitResponse(GF("+QSSLSTATE:")) != 1) { return false; }
 
-    streamSkipUntil(',');                  // Skip mux
-    streamSkipUntil(',');                  // Skip socket type
-    streamSkipUntil(',');                  // Skip remote ip
-    streamSkipUntil(',');                  // Skip remote port
-    streamSkipUntil(',');                  // Skip local port
-    int8_t res = streamGetIntBefore(',');  // socket state
+      streamSkipUntil(',');                  // Skip clientID
+      streamSkipUntil(',');                  // Skip "SSLClient"
+      streamSkipUntil(',');                  // Skip remote ip
+      streamSkipUntil(',');                  // Skip remote port
+      streamSkipUntil(',');                  // Skip local port
+      int8_t res = streamGetIntBefore(',');  // socket state
 
-    waitResponse();
+      waitResponse();
 
-    // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
-    return 2 == res;
+      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
+      return 2 == res;
+    } else {
+      sendAT(GF("+QISTATE=1,"), mux);
+      // +QISTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
+
+      if (waitResponse(GF("+QISTATE:")) != 1) { return false; }
+
+      streamSkipUntil(',');                  // Skip mux
+      streamSkipUntil(',');                  // Skip socket type
+      streamSkipUntil(',');                  // Skip remote ip
+      streamSkipUntil(',');                  // Skip remote port
+      streamSkipUntil(',');                  // Skip local port
+      int8_t res = streamGetIntBefore(',');  // socket state
+
+      waitResponse();
+
+      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
+      return 2 == res;
+    }
   }
 
   /*
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 9107d8c..35080b7 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -1,9 +1,9 @@
 /**
  * @file       TinyGsmClientBG96.h
- * @author     Volodymyr Shymanskyy
+ * @author     Volodymyr Shymanskyy and Aurelien BOUIN (SSL)
  * @license    LGPL-3.0
  * @copyright  Copyright (c) 2016 Volodymyr Shymanskyy
- * @date       Apr 2018
+ * @date       Apr 2018, Aug 2023 (SSL)
  */
 
 #ifndef SRC_TINYGSMCLIENTBG96_H_
@@ -26,6 +26,7 @@
 #include "TinyGsmModem.tpp"
 #include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
 #include "TinyGsmTemperature.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
@@ -72,6 +73,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
     GsmClientBG96() {}
 
     explicit GsmClientBG96(TinyGsmBG96& modem, uint8_t mux = 0) {
+      ssl_sock = false;
       init(&modem, mux);
     }
 
@@ -92,32 +94,16 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
       return true;
     }
 
-    int8_t uploadFile(const char* fileName, const char* content) {
-      // AT+QFDEL="file_name.pem"
-      at->sendAT(GF("+QFDEL="), GF("\""), fileName, GF("\""));
-      at->waitResponse();
-
-      at->sendAT(GF("+QFUPL="), GF("\""), fileName, GF("\","), strlen(content),
-                 GF(","), 100);
-      if (at->waitResponse(GF("CONNECT")) != 1) return 0;
-      at->stream.write(content, strlen(content));
-      at->stream.flush();
-      if (at->waitResponse() != 1) return 0;
-      if (at->waitResponse(5000, GF(AT_NL "+QFUPL:")) != 1) return 0;
-      at->stream.readStringUntil('\n');
-      return at->waitResponse();
-    }
-
     virtual int connect(const char* host, uint16_t port, int timeout_s) {
       stop();
       TINY_GSM_YIELD();
       rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, false, timeout_s);
+      sock_connected = at->modemConnect(host, port, mux, timeout_s);
       return sock_connected;
     }
     TINY_GSM_CLIENT_CONNECT_OVERRIDES
 
-    void stop(uint32_t maxWaitMs) {
+    virtual void stop(uint32_t maxWaitMs) {
       uint32_t startMillis = millis();
       dumpModemBuffer(maxWaitMs);
       at->sendAT(GF("+QICLOSE="), mux);
@@ -128,16 +114,14 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
       stop(15000L);
     }
 
-    // we need to be able to access the inner secure client function definitions
-    // from inside TinyGsmTCP eg modemSend, modemRead, modemGetConnected and
-    // modemGetAvailable, how?
-
-
     /*
      * Extended API
      */
 
     String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+
+   protected:
+    bool ssl_sock;
   };
 
   /*
@@ -149,125 +133,21 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
     GsmClientSecureBG96() {}
 
     explicit GsmClientSecureBG96(TinyGsmBG96& modem, uint8_t mux = 0)
-        : GsmClientBG96(modem, mux) {}
-
-   public:
-    int connect(const char* host, uint16_t port, int timeout_s) override {
-      stop();
-      TINY_GSM_YIELD();
-      rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
-      return sock_connected;
+        : GsmClientBG96(modem, mux) {
+      ssl_sock = true;
     }
-    TINY_GSM_CLIENT_CONNECT_OVERRIDES
 
-    void stop(uint32_t maxWaitMs) {
+    bool setCertificate(const String& certificateName) {
+      return at->setCertificate(certificateName, mux);
+    }
+
+    void stop(uint32_t maxWaitMs) override {
       uint32_t startMillis = millis();
       dumpModemBuffer(maxWaitMs);
-      at->sendAT(GF("+QSSLCLOSE=0"));
+      at->sendAT(GF("+QSSLCLOSE="), mux);
       sock_connected = false;
       at->waitResponse((maxWaitMs - (millis() - startMillis)));
     }
-    void stop() {
-      stop(15000L);
-    }
-
-    int8_t sslSetcacert(uint8_t context, const char* fileName) {
-      at->sendAT(GF("+QSSLCFG="), GF("\""), GF("cacert"), GF("\","), context,
-                 GF(",\""), fileName, GF("\""));
-      at->waitResponse();
-
-      at->sendAT(GF("+QSSLCFG="), GF("\""), GF("negotiatetime"), GF("\","),
-                 context, GF(",300"));
-      at->waitResponse();
-      at->sendAT(GF("+QSSLCFG="), GF("\""), GF("ignorelocaltime"), GF("\","),
-                 context, GF(",0"));
-      return at->waitResponse();
-    }
-
-   protected:
-    int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
-      at->sendAT(GF("+QSSLSEND=0,"), (uint16_t)len);
-      if (at->waitResponse(GF(">")) != 1) { return 0; }
-      at->stream.write(reinterpret_cast<const uint8_t*>(buff), len);
-      at->stream.flush();
-      if (at->waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
-      return len;
-    }
-
-    size_t modemRead(size_t size, uint8_t mux) {
-      if (!at->sockets[mux]) return 0;
-      at->sendAT(GF("+QSSLRECV=0,"), (uint16_t)size);
-      if (at->waitResponse(GF("+QSSLRECV:")) != 1) { return 0; }
-      int16_t len = at->streamGetIntBefore('\n');
-
-      for (int i = 0; i < len; i++) { at->moveCharFromStreamToFifo(mux); }
-      at->waitResponse();
-      // DBG("### READ:", len, "from", mux);
-      // sockets[mux]->sock_available = modemGetAvailable(mux);
-      return len;
-    }
-
-    size_t modemGetAvailable(uint8_t mux) {
-      if (!at->sockets[mux]) return 0;
-      at->sendAT(GF("+QSSLRECV=0,1500"));
-      size_t result = 0;
-      if (at->waitResponse(GF("+QSSLRECV:")) == 1) {
-        result = at->streamGetIntBefore('\n');
-        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
-        at->waitResponse();
-      }
-      if (!result) {
-        at->sockets[mux]->sock_connected = modemGetConnected(mux);
-      }
-      return result;
-    }
-
-    bool modemGetConnected(uint8_t mux) {
-      at->sendAT(GF("+QSSLSTATE=0"));
-      // +QSSLSTATE:
-      // 4,"SSLClient","220.180.239.201",8010,65344,2,1,4,0,"usbmodem",1
-
-      if (at->waitResponse(GF("+QSSLSTATE:")) != 1) { return false; }
-
-      at->streamSkipUntil(',');                  // Skip clientID
-      at->streamSkipUntil(',');                  // Skip "SSLClient"
-      at->streamSkipUntil(',');                  // Skip remote ip
-      at->streamSkipUntil(',');                  // Skip remote port
-      at->streamSkipUntil(',');                  // Skip local port
-      int8_t res = at->streamGetIntBefore(',');  // socket state
-
-      at->waitResponse();
-
-      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
-      return 2 == res;
-    }
-
-    bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                         const char* pwd = NULL) {
-      at->gprsDisconnect();
-
-      // Configure the TCPIP Context
-      at->sendAT(GF("+QICSGP=1,1,\""), apn, GF("\",\""), user, GF("\",\""), pwd,
-                 GF("\""));
-      if (at->waitResponse() != 1) { return false; }
-
-      // Activate GPRS/CSD Context
-      at->sendAT(GF("+QIACT=1"));
-      if (at->waitResponse(150000L) != 1) { return false; }
-
-      at->sendAT(GF("+QSSLCFG="), GF("\"sslversion"), GF("\","), 0, GF(",4"));
-      if (!at->waitResponse()) return false;
-
-      at->sendAT(GF("+QSSLCFG="), GF("\"ciphersuite"), GF("\","), 0,
-                 GF(",0xffff"));
-      if (!at->waitResponse()) return false;
-
-      at->sendAT(GF("+QSSLCFG="), GF("\"seclevel"), GF("\","), 0, GF(",1"));
-      if (!at->waitResponse()) return false;
-
-      return true;
-    }
   };
 
   /*
@@ -347,9 +227,10 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
     return waitResponse() == 1;
   }
 
-  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false) {
+  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false,
+                                 uint32_t timeout_ms = 15500L) {
     sendAT(GF("+CFUN="), fun, reset ? ",1" : "");
-    return waitResponse(10000L, GF("OK")) == 1;
+    return waitResponse(timeout_ms, GF("OK")) == 1;
   }
 
   /*
@@ -375,6 +256,16 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
+  /*
+   * Secure socket layer functions
+   */
+ protected:
+  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
+    if (mux >= TINY_GSM_MUX_COUNT) return false;
+    certificates[mux] = certificateName;
+    return true;
+  }
+
   /*
    * GPRS functions
    */
@@ -692,23 +583,76 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    */
  protected:
   bool modemConnect(const char* host, uint16_t port, uint8_t mux,
-                    bool ssl = false, int timeout_s = 150) {
+                    int timeout_s = 150) {
     uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
+    bool     ssl        = sockets[mux]->ssl_sock;
 
     if (ssl) {
-      // AT+QSSLOPEN=1,0,0,"220.180.239.201",8010,0
-      sendAT(GF("+QSSLOPEN=1,"), mux, GF(",0,\""), host, GF("\","), port,
+      // set the ssl version
+      // AT+QSSLCFG="sslversion",<ctxindex>,<sslversion>
+      // <ctxindex> PDP context identifier
+      // <sslversion> 0: QAPI_NET_SSL_3.0
+      //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
+      //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
+      //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
+      //              4: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+QSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
+      if (waitResponse(5000L) != 1) return false;
+      // set the ssl cipher_suite
+      // AT+QSSLCFG="ciphersuite",<ctxindex>,<cipher_suite>
+      // <ctxindex> PDP context identifier
+      // <cipher_suite> 0: TODO
+      //              1: TODO
+      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+      //              0XFFFF: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF(
+          "+QSSLCFG=\"ciphersuite\",0,0X0035"));  // TLS_RSA_WITH_AES_256_CBC_SHA
+      if (waitResponse(5000L) != 1) return false;
+      // set the ssl sec level
+      // AT+QSSLCFG="seclevel",<ctxindex>,<sec_level>
+      // <ctxindex> PDP context identifier
+      // <sec_level> 0: TODO
+      //              1: TODO
+      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
+      //              0XFFFF: ALL
+      // NOTE:  despite docs using caps, "sslversion" must be in lower case
+      sendAT(GF("+QSSLCFG=\"seclevel\",0,1"));
+      if (waitResponse(5000L) != 1) return false;
+
+
+      if (certificates[mux] != "") {
+        // apply the correct certificate to the connection
+        // AT+QSSLCFG="cacert",<ctxindex>,<caname>
+        // <ctxindex> PDP context identifier
+        // <certname> certificate name
+
+        // sendAT(GF("+CASSLCFG="), mux, ",CACERT,\"",
+        // certificates[mux].c_str(),
+        //        "\"");
+        sendAT(GF("+QSSLCFG=\"cacert\",0,\""), certificates[mux].c_str(),
+               GF("\""));
+        if (waitResponse(5000L) != 1) return false;
+      }
+
+      // <PDPcontextID>(1-16), <connectID>(0-11),
+      // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
+      // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
+      // may need previous AT+QSSLCFG
+      sendAT(GF("+QSSLOPEN=1,1,"), mux, GF(",\""), host, GF("\","), port,
              GF(",0"));
       waitResponse();
 
       if (waitResponse(timeout_ms, GF(AT_NL "+QSSLOPEN:")) != 1) {
         return false;
       }
-
-      if (streamGetIntBefore(',') != 0) {
-        return false;
-      }  // make sure client_id is 0
-
+      // 20230629 -> +QSSLOPEN: <clientID>,<err>
+      // clientID is mux
+      // err must be 0
+      if (streamGetIntBefore(',') != mux) { return false; }
+      // Read status
+      return (0 == streamGetIntBefore('\n'));
     } else {
       // AT+QIOPEN=1,0,"TCP","220.180.239.212",8009,0,0
       // <PDPcontextID>(1-16), <connectID>(0-11),
@@ -727,19 +671,33 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   }
 
   int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
-    sendAT(GF("+QISEND="), mux, ',', (uint16_t)len);
+    bool ssl = sockets[mux]->ssl_sock;
+    if (ssl) {
+      sendAT(GF("+QSSLSEND="), mux, ',', (uint16_t)len);
+    } else {
+      sendAT(GF("+QISEND="), mux, ',', (uint16_t)len);
+    }
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(reinterpret_cast<const uint8_t*>(buff), len);
     stream.flush();
     if (waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
-    // TODO(?): Wait for ACK? AT+QISEND=id,0
+    // TODO(?): Wait for ACK? (AT+QISEND=id,0 or AT+QSSLSEND=id,0)
     return len;
   }
 
   size_t modemRead(size_t size, uint8_t mux) {
     if (!sockets[mux]) return 0;
-    sendAT(GF("+QIRD="), mux, ',', (uint16_t)size);
-    if (waitResponse(GF("+QIRD:")) != 1) { return 0; }
+    bool ssl = sockets[mux]->ssl_sock;
+    if (ssl) {
+      sendAT(GF("+QSSLRECV="), mux, ',', (uint16_t)size);
+      if (waitResponse(GF("+QSSLRECV:")) != 1) {
+        DBG("### READ: For unknown reason close");
+        return 0;
+      }
+    } else {
+      sendAT(GF("+QIRD="), mux, ',', (uint16_t)size);
+      if (waitResponse(GF("+QIRD:")) != 1) { return 0; }
+    }
     int16_t len = streamGetIntBefore('\n');
 
     for (int i = 0; i < len; i++) { moveCharFromStreamToFifo(mux); }
@@ -751,36 +709,68 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
 
   size_t modemGetAvailable(uint8_t mux) {
     if (!sockets[mux]) return 0;
-    sendAT(GF("+QIRD="), mux, GF(",0"));
+    bool   ssl    = sockets[mux]->ssl_sock;
     size_t result = 0;
-    if (waitResponse(GF("+QIRD:")) == 1) {
-      streamSkipUntil(',');  // Skip total received
-      streamSkipUntil(',');  // Skip have read
-      result = streamGetIntBefore('\n');
-      if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
-      waitResponse();
+    if (ssl) {
+      sendAT(GF("+QSSLRECV="), mux, GF(",0"));
+      if (waitResponse(GF("+QSSLRECV:")) == 1) {
+        streamSkipUntil(',');  // Skip total received
+        streamSkipUntil(',');  // Skip have read
+        result = streamGetIntBefore('\n');
+        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
+        waitResponse();
+      }
+    } else {
+      sendAT(GF("+QIRD="), mux, GF(",0"));
+      if (waitResponse(GF("+QIRD:")) == 1) {
+        streamSkipUntil(',');  // Skip total received
+        streamSkipUntil(',');  // Skip have read
+        result = streamGetIntBefore('\n');
+        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
+        waitResponse();
+      }
     }
     if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
     return result;
   }
 
   bool modemGetConnected(uint8_t mux) {
-    sendAT(GF("+QISTATE=1,"), mux);
-    // +QISTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
+    bool ssl = sockets[mux]->ssl_sock;
+    if (ssl) {
+      sendAT(GF("+QSSLSTATE=1,"), mux);
+      // +QSSLSTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
 
-    if (waitResponse(GF("+QISTATE:")) != 1) { return false; }
+      if (waitResponse(GF("+QSSLSTATE:")) != 1) { return false; }
 
-    streamSkipUntil(',');                  // Skip mux
-    streamSkipUntil(',');                  // Skip socket type
-    streamSkipUntil(',');                  // Skip remote ip
-    streamSkipUntil(',');                  // Skip remote port
-    streamSkipUntil(',');                  // Skip local port
-    int8_t res = streamGetIntBefore(',');  // socket state
+      streamSkipUntil(',');                  // Skip clientID
+      streamSkipUntil(',');                  // Skip "SSLClient"
+      streamSkipUntil(',');                  // Skip remote ip
+      streamSkipUntil(',');                  // Skip remote port
+      streamSkipUntil(',');                  // Skip local port
+      int8_t res = streamGetIntBefore(',');  // socket state
 
-    waitResponse();
+      waitResponse();
 
-    // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
-    return 2 == res;
+      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
+      return 2 == res;
+    } else {
+      sendAT(GF("+QISTATE=1,"), mux);
+      // +QISTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
+
+      if (waitResponse(GF("+QISTATE:")) != 1) { return false; }
+
+      streamSkipUntil(',');                  // Skip mux
+      streamSkipUntil(',');                  // Skip socket type
+      streamSkipUntil(',');                  // Skip remote ip
+      streamSkipUntil(',');                  // Skip remote port
+      streamSkipUntil(',');                  // Skip local port
+      int8_t res = streamGetIntBefore(',');  // socket state
+
+      waitResponse();
+
+      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
+      return 2 == res;
+    }
   }
 
   /*
@@ -818,6 +808,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
 
  protected:
   GsmClientBG96* sockets[TINY_GSM_MUX_COUNT];
+  String         certificates[TINY_GSM_MUX_COUNT];
 };
 
 #endif  // SRC_TINYGSMCLIENTBG96_H_

From c29132fdd375852aec855c474f9587727a5e8c18 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 20 May 2024 12:33:17 -0400
Subject: [PATCH 065/100] Remove redundant BG95

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClient.h        |   7 +-
 src/TinyGsmClientBG95SSL.h | 814 -------------------------------------
 2 files changed, 1 insertion(+), 820 deletions(-)
 delete mode 100644 src/TinyGsmClientBG95SSL.h

diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index aafdf96..3b6741c 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -79,17 +79,12 @@ typedef TinyGsmSaraR5::GsmClientSecureR5 TinyGsmClientSecure;
 typedef TinyGsmM95               TinyGsm;
 typedef TinyGsmM95::GsmClientM95 TinyGsmClient;
 
-#elif defined(TINY_GSM_MODEM_BG96)
+#elif defined(TINY_GSM_MODEM_BG96) || defined(TINY_GSM_MODEM_BG95SSL)
 #include "TinyGsmClientBG96.h"
 typedef TinyGsmBG96                      TinyGsm;
 typedef TinyGsmBG96::GsmClientBG96       TinyGsmClient;
 typedef TinyGsmBG96::GsmClientSecureBG96 TinyGsmClientSecure;
 
-#elif defined(TINY_GSM_MODEM_BG95SSL)
-#include "TinyGsmClientBG95SSL.h"
-typedef TinyGsmBG95                      TinyGsm;
-typedef TinyGsmBG95::GsmClientSecureBG95 TinyGsmClientSecure;
-
 #elif defined(TINY_GSM_MODEM_A6) || defined(TINY_GSM_MODEM_A7)
 #include "TinyGsmClientA6.h"
 typedef TinyGsmA6              TinyGsm;
diff --git a/src/TinyGsmClientBG95SSL.h b/src/TinyGsmClientBG95SSL.h
deleted file mode 100644
index 38629a8..0000000
--- a/src/TinyGsmClientBG95SSL.h
+++ /dev/null
@@ -1,814 +0,0 @@
-/**
- * @file       TinyGsmClientBG95.h
- * @author     Aurelien BOUIN
- * @license    LGPL-3.0
- * @copyright  Copyright (c) 2023 Aurelien BOUIN
- * @date       Aug 2023
- */
-
-#ifndef SRC_TINYGSMCLIENTBG95_H_
-#define SRC_TINYGSMCLIENTBG95_H_
-// #pragma message("TinyGSM:  TinyGsmClientBG95")
-
-// #define TINY_GSM_DEBUG Serial
-
-#define TINY_GSM_MUX_COUNT 12
-#define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
-#ifdef AT_NL
-#undef AT_NL
-#endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
-
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGPS.tpp"
-#include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmTCP.tpp"
-#include "TinyGsmSSL.tpp"
-#include "TinyGsmTemperature.tpp"
-#include "TinyGsmTime.tpp"
-#include "TinyGsmNTP.tpp"
-
-enum BG95RegStatus {
-  REG_NO_RESULT    = -1,
-  REG_UNREGISTERED = 0,
-  REG_SEARCHING    = 2,
-  REG_DENIED       = 3,
-  REG_OK_HOME      = 1,
-  REG_OK_ROAMING   = 5,
-  REG_UNKNOWN      = 4,
-};
-
-class TinyGsmBG95 : public TinyGsmModem<TinyGsmBG95>,
-                    public TinyGsmGPRS<TinyGsmBG95>,
-                    public TinyGsmTCP<TinyGsmBG95, TINY_GSM_MUX_COUNT>,
-                    public TinyGsmCalling<TinyGsmBG95>,
-                    public TinyGsmSMS<TinyGsmBG95>,
-                    public TinyGsmTime<TinyGsmBG95>,
-                    public TinyGsmNTP<TinyGsmBG95>,
-                    public TinyGsmGPS<TinyGsmBG95>,
-                    public TinyGsmBattery<TinyGsmBG95>,
-                    public TinyGsmTemperature<TinyGsmBG95> {
-  friend class TinyGsmModem<TinyGsmBG95>;
-  friend class TinyGsmGPRS<TinyGsmBG95>;
-  friend class TinyGsmTCP<TinyGsmBG95, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmCalling<TinyGsmBG95>;
-  friend class TinyGsmSMS<TinyGsmBG95>;
-  friend class TinyGsmTime<TinyGsmBG95>;
-  friend class TinyGsmNTP<TinyGsmBG95>;
-  friend class TinyGsmGPS<TinyGsmBG95>;
-  friend class TinyGsmBattery<TinyGsmBG95>;
-  friend class TinyGsmTemperature<TinyGsmBG95>;
-
-  /*
-   * Inner Client
-   */
- public:
-  class GsmClientBG95 : public GsmClient {
-    friend class TinyGsmBG95;
-
-   public:
-    GsmClientBG95() {}
-
-    explicit GsmClientBG95(TinyGsmBG95& modem, uint8_t mux = 0) {
-      ssl_sock = false;
-      init(&modem, mux);
-    }
-
-    bool init(TinyGsmBG95* modem, uint8_t mux = 0) {
-      this->at       = modem;
-      sock_available = 0;
-      prev_check     = 0;
-      sock_connected = false;
-      got_data       = false;
-
-      if (mux < TINY_GSM_MUX_COUNT) {
-        this->mux = mux;
-      } else {
-        this->mux = (mux % TINY_GSM_MUX_COUNT);
-      }
-      at->sockets[this->mux] = this;
-
-      return true;
-    }
-
-    virtual int connect(const char* host, uint16_t port, int timeout_s) {
-      stop();
-      TINY_GSM_YIELD();
-      rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, timeout_s);
-      return sock_connected;
-    }
-    TINY_GSM_CLIENT_CONNECT_OVERRIDES
-
-    virtual void stop(uint32_t maxWaitMs) {
-      uint32_t startMillis = millis();
-      dumpModemBuffer(maxWaitMs);
-      at->sendAT(GF("+QICLOSE="), mux);
-      sock_connected = false;
-      at->waitResponse((maxWaitMs - (millis() - startMillis)));
-    }
-    void stop() override {
-      stop(15000L);
-    }
-
-    /*
-     * Extended API
-     */
-
-    String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
-
-   protected:
-    bool ssl_sock;
-  };
-
-  /*
-   * Inner Secure Client
-   */
-
-  class GsmClientSecureBG95 : public GsmClientBG95 {
-   public:
-    GsmClientSecureBG95() {}
-
-    explicit GsmClientSecureBG95(TinyGsmBG95& modem, uint8_t mux = 0)
-        : GsmClientBG95(modem, mux) {
-      ssl_sock = true;
-    }
-
-    bool setCertificate(const String& certificateName) {
-      return at->setCertificate(certificateName, mux);
-    }
-
-    void stop(uint32_t maxWaitMs) override {
-      uint32_t startMillis = millis();
-      dumpModemBuffer(maxWaitMs);
-      at->sendAT(GF("+QSSLCLOSE="), mux);
-      sock_connected = false;
-      at->waitResponse((maxWaitMs - (millis() - startMillis)));
-    }
-  };
-
-  /*
-   * Constructor
-   */
- public:
-  explicit TinyGsmBG95(Stream& stream) : stream(stream) {
-    memset(sockets, 0, sizeof(sockets));
-  }
-
-  /*
-   * Basic functions
-   */
- protected:
-  bool initImpl(const char* pin = nullptr) {
-    DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
-    DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientBG95"));
-
-    if (!testAT()) { return false; }
-
-    sendAT(GF("E0"));  // Echo Off
-    if (waitResponse() != 1) { return false; }
-
-#ifdef TINY_GSM_DEBUG
-    sendAT(GF("+CMEE=2"));  // turn on verbose error codes
-#else
-    sendAT(GF("+CMEE=0"));  // turn off error codes
-#endif
-    waitResponse();
-
-    DBG(GF("### Modem:"), getModemName());
-
-    // Disable time and time zone URC's
-    sendAT(GF("+CTZR=0"));
-    if (waitResponse(10000L) != 1) { return false; }
-
-    // Enable automatic time zone update
-    sendAT(GF("+CTZU=1"));
-    if (waitResponse(10000L) != 1) { return false; }
-
-    SimStatus ret = getSimStatus();
-    // if the sim isn't ready and a pin has been provided, try to unlock the sim
-    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
-      simUnlock(pin);
-      return (getSimStatus() == SIM_READY);
-    } else {
-      // if the sim is ready, or it's locked but no pin has been provided,
-      // return true
-      return (ret == SIM_READY || ret == SIM_LOCKED);
-    }
-  }
-
-  /*
-   * Power functions
-   */
- protected:
-  bool restartImpl(const char* pin = nullptr) {
-    if (!testAT()) { return false; }
-    if (!setPhoneFunctionality(1, true)) { return false; }
-    waitResponse(10000L, GF("APP RDY"));
-    return init(pin);
-  }
-
-  bool powerOffImpl() {
-    sendAT(GF("+QPOWD=1"));
-    waitResponse(300);  // returns OK first
-    return waitResponse(300, GF("POWERED DOWN")) == 1;
-  }
-
-  // When entering into sleep mode is enabled, DTR is pulled up, and WAKEUP_IN
-  // is pulled up, the module can directly enter into sleep mode.If entering
-  // into sleep mode is enabled, DTR is pulled down, and WAKEUP_IN is pulled
-  // down, there is a need to pull the DTR pin and the WAKEUP_IN pin up first,
-  // and then the module can enter into sleep mode.
-  bool sleepEnableImpl(bool enable = true) {
-    sendAT(GF("+QSCLK="), enable);
-    return waitResponse() == 1;
-  }
-
-  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false,
-                                 uint32_t timeout_ms = 15500L) {
-    sendAT(GF("+CFUN="), fun, reset ? ",1" : "");
-    return waitResponse(timeout_ms, GF("OK")) == 1;
-  }
-
-  /*
-   * Generic network functions
-   */
- public:
-  BG95RegStatus getRegistrationStatus() {
-    // Check first for EPS registration
-    BG95RegStatus epsStatus = (BG95RegStatus)getRegistrationStatusXREG("CEREG");
-
-    // If we're connected on EPS, great!
-    if (epsStatus == REG_OK_HOME || epsStatus == REG_OK_ROAMING) {
-      return epsStatus;
-    } else {
-      // Otherwise, check generic network status
-      return (BG95RegStatus)getRegistrationStatusXREG("CREG");
-    }
-  }
-
- protected:
-  bool isNetworkConnectedImpl() {
-    BG95RegStatus s = getRegistrationStatus();
-    return (s == REG_OK_HOME || s == REG_OK_ROAMING);
-  }
-
-  /*
-   * Secure socket layer functions
-   */
- protected:
-  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
-    if (mux >= TINY_GSM_MUX_COUNT) return false;
-    certificates[mux] = certificateName;
-    return true;
-  }
-
-  /*
-   * GPRS functions
-   */
- protected:
-  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
-                       const char* pwd = nullptr) {
-    gprsDisconnect();
-
-    // Configure the TCPIP Context
-    sendAT(GF("+QICSGP=1,1,\""), apn, GF("\",\""), user, GF("\",\""), pwd,
-           GF("\""));
-    if (waitResponse() != 1) { return false; }
-
-    // Activate GPRS/CSD Context
-    sendAT(GF("+QIACT=1"));
-    if (waitResponse(150000L) != 1) { return false; }
-
-    // Attach to Packet Domain service - is this necessary?
-    sendAT(GF("+CGATT=1"));
-    if (waitResponse(60000L) != 1) { return false; }
-
-    return true;
-  }
-
-  bool gprsDisconnectImpl() {
-    sendAT(GF("+QIDEACT=1"));  // Deactivate the bearer context
-    if (waitResponse(40000L) != 1) { return false; }
-
-    return true;
-  }
-
-  /*
-   * SIM card functions
-   */
- protected:
-  String getSimCCIDImpl() {
-    sendAT(GF("+QCCID"));
-    if (waitResponse(GF(AT_NL "+QCCID:")) != 1) { return ""; }
-    String res = stream.readStringUntil('\n');
-    waitResponse();
-    res.trim();
-    return res;
-  }
-
-  /*
-   * Phone Call functions
-   */
- protected:
-  // Can follow all of the phone call functions from the template
-
-  /*
-   * Messaging functions
-   */
- protected:
-  // Follows all messaging functions per template
-
-  /*
-   * GSM Location functions
-   */
- protected:
-  // NOTE:  As of application firmware version 01.016.01.016 triangulated
-  // locations can be obtained via the QuecLocator service and accompanying AT
-  // commands.  As this is a separate paid service which I do not have access
-  // to, I am not implementing it here.
-
-  /*
-   * GPS/GNSS/GLONASS location functions
-   */
- protected:
-  // enable GPS
-  bool enableGPSImpl() {
-    sendAT(GF("+QGPS=1"));
-    if (waitResponse() != 1) { return false; }
-    return true;
-  }
-
-  bool disableGPSImpl() {
-    sendAT(GF("+QGPSEND"));
-    if (waitResponse() != 1) { return false; }
-    return true;
-  }
-
-  // get the RAW GPS output
-  String getGPSrawImpl() {
-    sendAT(GF("+QGPSLOC=2"));
-    if (waitResponse(10000L, GF(AT_NL "+QGPSLOC:")) != 1) { return ""; }
-    String res = stream.readStringUntil('\n');
-    waitResponse();
-    res.trim();
-    return res;
-  }
-
-  // get GPS informations
-  bool getGPSImpl(float* lat, float* lon, float* speed = 0, float* alt = 0,
-                  int* vsat = 0, int* usat = 0, float* accuracy = 0,
-                  int* year = 0, int* month = 0, int* day = 0, int* hour = 0,
-                  int* minute = 0, int* second = 0) {
-    sendAT(GF("+QGPSLOC=2"));
-    if (waitResponse(10000L, GF(AT_NL "+QGPSLOC:")) != 1) {
-      // NOTE:  Will return an error if the position isn't fixed
-      return false;
-    }
-
-    // init variables
-    float ilat         = 0;
-    float ilon         = 0;
-    float ispeed       = 0;
-    float ialt         = 0;
-    int   iusat        = 0;
-    float iaccuracy    = 0;
-    int   iyear        = 0;
-    int   imonth       = 0;
-    int   iday         = 0;
-    int   ihour        = 0;
-    int   imin         = 0;
-    float secondWithSS = 0;
-
-    // UTC date & Time
-    ihour        = streamGetIntLength(2);      // Two digit hour
-    imin         = streamGetIntLength(2);      // Two digit minute
-    secondWithSS = streamGetFloatBefore(',');  // 6 digit second with subseconds
-
-    ilat      = streamGetFloatBefore(',');  // Latitude
-    ilon      = streamGetFloatBefore(',');  // Longitude
-    iaccuracy = streamGetFloatBefore(',');  // Horizontal precision
-    ialt      = streamGetFloatBefore(',');  // Altitude from sea level
-    streamSkipUntil(',');                   // GNSS positioning mode
-    streamSkipUntil(',');  // Course Over Ground based on true north
-    streamSkipUntil(',');  // Speed Over Ground in Km/h
-    ispeed = streamGetFloatBefore(',');  // Speed Over Ground in knots
-
-    iday   = streamGetIntLength(2);    // Two digit day
-    imonth = streamGetIntLength(2);    // Two digit month
-    iyear  = streamGetIntBefore(',');  // Two digit year
-
-    iusat = streamGetIntBefore(',');  // Number of satellites,
-    streamSkipUntil('\n');  // The error code of the operation. If it is not
-                            // 0, it is the type of error.
-
-    // Set pointers
-    if (lat != nullptr) *lat = ilat;
-    if (lon != nullptr) *lon = ilon;
-    if (speed != nullptr) *speed = ispeed;
-    if (alt != nullptr) *alt = ialt;
-    if (vsat != nullptr) *vsat = 0;
-    if (usat != nullptr) *usat = iusat;
-    if (accuracy != nullptr) *accuracy = iaccuracy;
-    if (iyear < 2000) iyear += 2000;
-    if (year != nullptr) *year = iyear;
-    if (month != nullptr) *month = imonth;
-    if (day != nullptr) *day = iday;
-    if (hour != nullptr) *hour = ihour;
-    if (minute != nullptr) *minute = imin;
-    if (second != nullptr) *second = static_cast<int>(secondWithSS);
-
-    waitResponse();  // Final OK
-    return true;
-  }
-
-  /*
-   * Time functions
-   */
- protected:
-  String getGSMDateTimeImpl(TinyGSMDateTimeFormat format) {
-    sendAT(GF("+QLTS=2"));
-    if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return ""; }
-
-    String res;
-
-    switch (format) {
-      case DATE_FULL: res = stream.readStringUntil('"'); break;
-      case DATE_TIME:
-        streamSkipUntil(',');
-        res = stream.readStringUntil('"');
-        break;
-      case DATE_DATE: res = stream.readStringUntil(','); break;
-    }
-    waitResponse();  // Ends with OK
-    return res;
-  }
-
-  // The BG95 returns UTC time instead of local time as other modules do in
-  // response to CCLK, so we're using QLTS where we can specifically request
-  // local time.
-  bool getNetworkUTCTimeImpl(int* year, int* month, int* day, int* hour,
-                             int* minute, int* second, float* timezone) {
-    sendAT(GF("+QLTS=1"));
-    if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return false; }
-
-    int iyear     = 0;
-    int imonth    = 0;
-    int iday      = 0;
-    int ihour     = 0;
-    int imin      = 0;
-    int isec      = 0;
-    int itimezone = 0;
-
-    // Date & Time
-    iyear       = streamGetIntBefore('/');
-    imonth      = streamGetIntBefore('/');
-    iday        = streamGetIntBefore(',');
-    ihour       = streamGetIntBefore(':');
-    imin        = streamGetIntBefore(':');
-    isec        = streamGetIntLength(2);
-    char tzSign = stream.read();
-    itimezone   = streamGetIntBefore(',');
-    if (tzSign == '-') { itimezone = itimezone * -1; }
-    streamSkipUntil('\n');  // DST flag
-
-    // Set pointers
-    if (iyear < 2000) iyear += 2000;
-    if (year != nullptr) *year = iyear;
-    if (month != nullptr) *month = imonth;
-    if (day != nullptr) *day = iday;
-    if (hour != nullptr) *hour = ihour;
-    if (minute != nullptr) *minute = imin;
-    if (second != nullptr) *second = isec;
-    if (timezone != nullptr) *timezone = static_cast<float>(itimezone) / 4.0;
-
-    // Final OK
-    waitResponse();  // Ends with OK
-    return true;
-  }
-
-  // The BG95 returns UTC time instead of local time as other modules do in
-  // response to CCLK, so we're using QLTS where we can specifically request
-  // local time.
-  bool getNetworkTimeImpl(int* year, int* month, int* day, int* hour,
-                          int* minute, int* second, float* timezone) {
-    sendAT(GF("+QLTS=2"));
-    if (waitResponse(2000L, GF("+QLTS: \"")) != 1) { return false; }
-
-    int iyear     = 0;
-    int imonth    = 0;
-    int iday      = 0;
-    int ihour     = 0;
-    int imin      = 0;
-    int isec      = 0;
-    int itimezone = 0;
-
-    // Date & Time
-    iyear       = streamGetIntBefore('/');
-    imonth      = streamGetIntBefore('/');
-    iday        = streamGetIntBefore(',');
-    ihour       = streamGetIntBefore(':');
-    imin        = streamGetIntBefore(':');
-    isec        = streamGetIntLength(2);
-    char tzSign = stream.read();
-    itimezone   = streamGetIntBefore(',');
-    if (tzSign == '-') { itimezone = itimezone * -1; }
-    streamSkipUntil('\n');  // DST flag
-
-    // Set pointers
-    if (iyear < 2000) iyear += 2000;
-    if (year != nullptr) *year = iyear;
-    if (month != nullptr) *month = imonth;
-    if (day != nullptr) *day = iday;
-    if (hour != nullptr) *hour = ihour;
-    if (minute != nullptr) *minute = imin;
-    if (second != nullptr) *second = isec;
-    if (timezone != nullptr) *timezone = static_cast<float>(itimezone) / 4.0;
-
-    // Final OK
-    waitResponse();  // Ends with OK
-    return true;
-  }
-
-  /*
-   * NTP server functions
-   */
-
-  byte NTPServerSyncImpl(String server = "pool.ntp.org", byte = -5) {
-    // Request network synchronization
-    // AT+QNTP=<contextID>,<server>[,<port>][,<autosettime>]
-    sendAT(GF("+QNTP=1,\""), server, '"');
-    if (waitResponse(10000L, GF("+QNTP:"))) {
-      String result = stream.readStringUntil(',');
-      streamSkipUntil('\n');
-      result.trim();
-      if (TinyGsmIsValidNumber(result)) { return result.toInt(); }
-    } else {
-      return -1;
-    }
-    return -1;
-  }
-
-  String ShowNTPErrorImpl(byte error) TINY_GSM_ATTR_NOT_IMPLEMENTED;
-
-  /*
-   * Battery functions
-   */
- protected:
-  // Can follow CBC as in the template
-
-  /*
-   * Temperature functions
-   */
- protected:
-  // get temperature in degree celsius
-  uint16_t getTemperatureImpl() {
-    sendAT(GF("+QTEMP"));
-    if (waitResponse(GF(AT_NL "+QTEMP:")) != 1) { return 0; }
-    // return temperature in C
-    uint16_t res =
-        streamGetIntBefore(',');  // read PMIC (primary ic) temperature
-    streamSkipUntil(',');         // skip XO temperature ??
-    streamSkipUntil('\n');        // skip PA temperature ??
-    // Wait for final OK
-    waitResponse();
-    return res;
-  }
-
-  /*
-   * Client related functions
-   */
- protected:
-  bool modemConnect(const char* host, uint16_t port, uint8_t mux,
-                    int timeout_s = 150) {
-    uint32_t timeout_ms = ((uint32_t)timeout_s) * 1000;
-    bool     ssl        = sockets[mux]->ssl_sock;
-
-    if (ssl) {
-      // set the ssl version
-      // AT+QSSLCFG="sslversion",<ctxindex>,<sslversion>
-      // <ctxindex> PDP context identifier
-      // <sslversion> 0: QAPI_NET_SSL_3.0
-      //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
-      //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
-      //              3: QAPI_NET_SSL_PROTOCOL_TLS_1_2
-      //              4: ALL
-      // NOTE:  despite docs using caps, "sslversion" must be in lower case
-      sendAT(GF("+QSSLCFG=\"sslversion\",0,3"));  // TLS 1.2
-      if (waitResponse(5000L) != 1) return false;
-      // set the ssl cipher_suite
-      // AT+QSSLCFG="ciphersuite",<ctxindex>,<cipher_suite>
-      // <ctxindex> PDP context identifier
-      // <cipher_suite> 0: TODO
-      //              1: TODO
-      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
-      //              0XFFFF: ALL
-      // NOTE:  despite docs using caps, "sslversion" must be in lower case
-      sendAT(GF(
-          "+QSSLCFG=\"ciphersuite\",0,0X0035"));  // TLS_RSA_WITH_AES_256_CBC_SHA
-      if (waitResponse(5000L) != 1) return false;
-      // set the ssl sec level
-      // AT+QSSLCFG="seclevel",<ctxindex>,<sec_level>
-      // <ctxindex> PDP context identifier
-      // <sec_level> 0: TODO
-      //              1: TODO
-      //              0X0035: TLS_RSA_WITH_AES_256_CBC_SHA
-      //              0XFFFF: ALL
-      // NOTE:  despite docs using caps, "sslversion" must be in lower case
-      sendAT(GF("+QSSLCFG=\"seclevel\",0,1"));
-      if (waitResponse(5000L) != 1) return false;
-
-
-      if (certificates[mux] != "") {
-        // apply the correct certificate to the connection
-        // AT+QSSLCFG="cacert",<ctxindex>,<caname>
-        // <ctxindex> PDP context identifier
-        // <certname> certificate name
-
-        // sendAT(GF("+CASSLCFG="), mux, ",CACERT,\"",
-        // certificates[mux].c_str(),
-        //        "\"");
-        sendAT(GF("+QSSLCFG=\"cacert\",0,\""), certificates[mux].c_str(),
-               GF("\""));
-        if (waitResponse(5000L) != 1) return false;
-      }
-
-      // <PDPcontextID>(1-16), <connectID>(0-11),
-      // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
-      // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
-      // may need previous AT+QSSLCFG
-      sendAT(GF("+QSSLOPEN=1,1,"), mux, GF(",\""), host, GF("\","), port,
-             GF(",0"));
-      waitResponse();
-
-      if (waitResponse(timeout_ms, GF(AT_NL "+QSSLOPEN:")) != 1) {
-        return false;
-      }
-      // 20230629 -> +QSSLOPEN: <clientID>,<err>
-      // clientID is mux
-      // err must be 0
-      if (streamGetIntBefore(',') != mux) { return false; }
-      // Read status
-      return (0 == streamGetIntBefore('\n'));
-    } else {
-      // AT+QIOPEN=1,0,"TCP","220.180.239.212",8009,0,0
-      // <PDPcontextID>(1-16), <connectID>(0-11),
-      // "TCP/UDP/TCP LISTENER/UDPSERVICE", "<IP_address>/<domain_name>",
-      // <remote_port>,<local_port>,<access_mode>(0-2; 0=buffer)
-      sendAT(GF("+QIOPEN=1,"), mux, GF(",\""), GF("TCP"), GF("\",\""), host,
-             GF("\","), port, GF(",0,0"));
-      waitResponse();
-
-      if (waitResponse(timeout_ms, GF(AT_NL "+QIOPEN:")) != 1) { return false; }
-
-      if (streamGetIntBefore(',') != mux) { return false; }
-    }
-    // Read status
-    return (0 == streamGetIntBefore('\n'));
-  }
-
-  int16_t modemSend(const void* buff, size_t len, uint8_t mux) {
-    bool ssl = sockets[mux]->ssl_sock;
-    if (ssl) {
-      sendAT(GF("+QSSLSEND="), mux, ',', (uint16_t)len);
-    } else {
-      sendAT(GF("+QISEND="), mux, ',', (uint16_t)len);
-    }
-    if (waitResponse(GF(">")) != 1) { return 0; }
-    stream.write(reinterpret_cast<const uint8_t*>(buff), len);
-    stream.flush();
-    if (waitResponse(GF(AT_NL "SEND OK")) != 1) { return 0; }
-    // TODO(?): Wait for ACK? (AT+QISEND=id,0 or AT+QSSLSEND=id,0)
-    return len;
-  }
-
-  size_t modemRead(size_t size, uint8_t mux) {
-    if (!sockets[mux]) return 0;
-    bool ssl = sockets[mux]->ssl_sock;
-    if (ssl) {
-      sendAT(GF("+QSSLRECV="), mux, ',', (uint16_t)size);
-      if (waitResponse(GF("+QSSLRECV:")) != 1) {
-        DBG("### READ: For unknown reason close");
-        return 0;
-      }
-    } else {
-      sendAT(GF("+QIRD="), mux, ',', (uint16_t)size);
-      if (waitResponse(GF("+QIRD:")) != 1) { return 0; }
-    }
-    int16_t len = streamGetIntBefore('\n');
-
-    for (int i = 0; i < len; i++) { moveCharFromStreamToFifo(mux); }
-    waitResponse();
-    // DBG("### READ:", len, "from", mux);
-    sockets[mux]->sock_available = modemGetAvailable(mux);
-    return len;
-  }
-
-  size_t modemGetAvailable(uint8_t mux) {
-    if (!sockets[mux]) return 0;
-    bool   ssl    = sockets[mux]->ssl_sock;
-    size_t result = 0;
-    if (ssl) {
-      sendAT(GF("+QSSLRECV="), mux, GF(",0"));
-      if (waitResponse(GF("+QSSLRECV:")) == 1) {
-        streamSkipUntil(',');  // Skip total received
-        streamSkipUntil(',');  // Skip have read
-        result = streamGetIntBefore('\n');
-        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
-        waitResponse();
-      }
-    } else {
-      sendAT(GF("+QIRD="), mux, GF(",0"));
-      if (waitResponse(GF("+QIRD:")) == 1) {
-        streamSkipUntil(',');  // Skip total received
-        streamSkipUntil(',');  // Skip have read
-        result = streamGetIntBefore('\n');
-        if (result) { DBG("### DATA AVAILABLE:", result, "on", mux); }
-        waitResponse();
-      }
-    }
-    if (!result) { sockets[mux]->sock_connected = modemGetConnected(mux); }
-    return result;
-  }
-
-  bool modemGetConnected(uint8_t mux) {
-    bool ssl = sockets[mux]->ssl_sock;
-    if (ssl) {
-      sendAT(GF("+QSSLSTATE=1,"), mux);
-      // +QSSLSTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
-
-      if (waitResponse(GF("+QSSLSTATE:")) != 1) { return false; }
-
-      streamSkipUntil(',');                  // Skip clientID
-      streamSkipUntil(',');                  // Skip "SSLClient"
-      streamSkipUntil(',');                  // Skip remote ip
-      streamSkipUntil(',');                  // Skip remote port
-      streamSkipUntil(',');                  // Skip local port
-      int8_t res = streamGetIntBefore(',');  // socket state
-
-      waitResponse();
-
-      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
-      return 2 == res;
-    } else {
-      sendAT(GF("+QISTATE=1,"), mux);
-      // +QISTATE: 0,"TCP","151.139.237.11",80,5087,4,1,0,0,"uart1"
-
-      if (waitResponse(GF("+QISTATE:")) != 1) { return false; }
-
-      streamSkipUntil(',');                  // Skip mux
-      streamSkipUntil(',');                  // Skip socket type
-      streamSkipUntil(',');                  // Skip remote ip
-      streamSkipUntil(',');                  // Skip remote port
-      streamSkipUntil(',');                  // Skip local port
-      int8_t res = streamGetIntBefore(',');  // socket state
-
-      waitResponse();
-
-      // 0 Initial, 1 Opening, 2 Connected, 3 Listening, 4 Closing
-      return 2 == res;
-    }
-  }
-
-  /*
-   * Utilities
-   */
- public:
-  bool handleURCs(String& data) {
-    if (data.endsWith(GF(AT_NL "+QIURC:"))) {
-      streamSkipUntil('\"');
-      String urc = stream.readStringUntil('\"');
-      streamSkipUntil(',');
-      if (urc == "recv") {
-        int8_t mux = streamGetIntBefore('\n');
-        DBG("### URC RECV:", mux);
-        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-          sockets[mux]->got_data = true;
-        }
-      } else if (urc == "closed") {
-        int8_t mux = streamGetIntBefore('\n');
-        DBG("### URC CLOSE:", mux);
-        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-          sockets[mux]->sock_connected = false;
-        }
-      } else {
-        streamSkipUntil('\n');
-      }
-      data = "";
-      return true;
-    }
-    return false;
-  }
-
- public:
-  Stream& stream;
-
- protected:
-  GsmClientBG95* sockets[TINY_GSM_MUX_COUNT];
-  String         certificates[TINY_GSM_MUX_COUNT];
-};
-
-#endif  // SRC_TINYGSMCLIENTBG95_H_

From f77a67167eacacd0d5d43a9713b87d151d543a62 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 20 May 2024 12:49:59 -0400
Subject: [PATCH 066/100] Readd lost stop

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 examples/AllFunctions/AllFunctions.ino | 8 ++++----
 src/TinyGsmClientBG96.h                | 3 +++
 tools/Diagnostics/Diagnostics.ino      | 1 +
 tools/test_build/test_build.ino        | 2 --
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index 4766bab..9fbd32f 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -23,6 +23,7 @@
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
@@ -226,8 +227,7 @@ void loop() {
   DBG("Phone number (USSD):", ussd_phone_num);
 #endif
 
-#if TINY_GSM_TEST_TCP && defined TINY_GSM_MODEM_HAS_TCP && \
-    not defined(TINY_GSM_MODEM_BG95SSL)
+#if TINY_GSM_TEST_TCP && defined TINY_GSM_MODEM_HAS_TCP
   TinyGsmClient client(modem, 0);
   const int     port = 80;
   DBG("Connecting to", server);
@@ -376,9 +376,9 @@ void loop() {
 
 #if TINY_GSM_TEST_GPS && defined TINY_GSM_MODEM_HAS_GPS
   DBG("Enabling GPS/GNSS/GLONASS and waiting 15s for warm-up");
-  #if !defined(TINY_GSM_MODEM_SARAR5)
+#if !defined(TINY_GSM_MODEM_SARAR5)
   modem.enableGPS();
-  #endif
+#endif
   delay(15000L);
   float lat2      = 0;
   float lon2      = 0;
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 35080b7..3955795 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -148,6 +148,9 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
       sock_connected = false;
       at->waitResponse((maxWaitMs - (millis() - startMillis)));
     }
+    void stop() override {
+      stop(15000L);
+    }
   };
 
   /*
diff --git a/tools/Diagnostics/Diagnostics.ino b/tools/Diagnostics/Diagnostics.ino
index 152d6f5..8d2247f 100644
--- a/tools/Diagnostics/Diagnostics.ino
+++ b/tools/Diagnostics/Diagnostics.ino
@@ -22,6 +22,7 @@
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
diff --git a/tools/test_build/test_build.ino b/tools/test_build/test_build.ino
index 80c5aa0..ef5bcb6 100644
--- a/tools/test_build/test_build.ino
+++ b/tools/test_build/test_build.ino
@@ -66,7 +66,6 @@ void loop() {
   char server[]   = "somewhere";
   char resource[] = "something";
 
-#if not defined(TINY_GSM_MODEM_BG95SSL)  // no insecure client
   // Test TCP functions
   modem.maintain();
   TinyGsmClient client;
@@ -91,7 +90,6 @@ void loop() {
   }
 
   client.stop();
-#endif
 
 #if defined(TINY_GSM_MODEM_HAS_SSL)
   // modem.addCertificate();  // not yet impemented

From 8136a25bd648f6025c74fd65bd26944e835d460c Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 20 May 2024 13:33:19 -0400
Subject: [PATCH 067/100] Refactor for handle URCs, add to tests

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .../workflows/build_examples_platformio.yaml  |   9 +-
 README.md                                     |  15 +-
 examples/AllFunctions/AllFunctions.ino        |   1 +
 examples/BlynkClient/BlynkClient.ino          |  18 +-
 examples/FileDownload/FileDownload.ino        |   2 +
 examples/HttpClient/HttpClient.ino            |   2 +
 examples/MqttClient/MqttClient.ino            |   2 +
 examples/WebClient/WebClient.ino              |   2 +
 src/TinyGsmClient.h                           |   3 +-
 src/TinyGsmClientA7672x.h                     | 318 +++++++-----------
 tools/AT_Debug/AT_Debug.ino                   |  50 +--
 tools/Diagnostics/Diagnostics.ino             |   1 +
 tools/FactoryReset/FactoryReset.ino           |  34 +-
 13 files changed, 202 insertions(+), 255 deletions(-)

diff --git a/.github/workflows/build_examples_platformio.yaml b/.github/workflows/build_examples_platformio.yaml
index ef94986..420c0bf 100644
--- a/.github/workflows/build_examples_platformio.yaml
+++ b/.github/workflows/build_examples_platformio.yaml
@@ -27,7 +27,7 @@ jobs:
           [
             TINY_GSM_MODEM_A6,
             TINY_GSM_MODEM_BG96,
-            TINY_GSM_MODEM_BG95SSL,
+            TINY_GSM_MODEM_A7672X,
             TINY_GSM_MODEM_ESP8266,
             TINY_GSM_MODEM_M95,
             TINY_GSM_MODEM_M590,
@@ -44,13 +44,6 @@ jobs:
             TINY_GSM_MODEM_XBEE,
             TINY_GSM_MODEM_SEQUANS_MONARCH,
           ]
-        exclude:
-          - modem: TINY_GSM_MODEM_BG95SSL
-            example: examples/BlynkClient
-          - modem: TINY_GSM_MODEM_BG95SSL
-            example: examples/FileDownload
-          - modem: TINY_GSM_MODEM_BG95SSL
-            example: examples/MqttClient
 
     steps:
       - uses: actions/checkout@v4
diff --git a/README.md b/README.md
index a2e9984..90cfafb 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@ You can also join our chat:
 - [How does it work?](#how-does-it-work)
 - [API Reference](#api-reference)
 - [Troubleshooting](#troubleshooting)
-  - [Ensure stable data & power connection](#ensure-stable-data--power-connection)
+  - [Ensure stable data \& power connection](#ensure-stable-data--power-connection)
   - [Baud rates](#baud-rates)
   - [Broken initial configuration](#broken-initial-configuration)
   - [Failed connection or no data received](#failed-connection-or-no-data-received)
@@ -70,6 +70,7 @@ TinyGSM also pulls data gently from the modem (whenever possible), so it can ope
 - SIMCom LTE Modules (SIM7100E, SIM7500E, SIM7500A, SIM7600C, SIM7600E)
 - SIMCom SIM7000E/A/G CAT-M1/NB-IoT Module
 - SIMCom SIM7070/SIM7080/SIM7090 CAT-M1/NB-IoT Module
+- SIMCom A7672X CAT-M1 Module
 - AI-Thinker A6, A6C, A7, A20
 - ESP8266/ESP32 (AT commands interface, similar to GSM modems)
 - Digi XBee WiFi and Cellular (using XBee command mode)
@@ -92,13 +93,6 @@ TinyGSM also pulls data gently from the modem (whenever possible), so it can ope
 - RAK WisLTE ***(alpha)***
 - ... other modules, based on supported modems. Some boards require [**special configuration**](https://github.com/vshymanskyy/TinyGSM/wiki/Board-configuration).
 
-More modems may be supported later:
-- [ ] Quectel M10, UG95
-- [ ] SIMCom SIM7020
-- [ ] Telit GL865
-- [ ] ZTE MG2639
-- [ ] Hi-Link HLK-RM04
-
 Watch this repo for new updates! And of course, contributions are welcome ;)
 
 ## Features
@@ -120,6 +114,7 @@ Watch this repo for new updates! And of course, contributions are welcome ;)
         - SIM7000 - 8 possible without SSL, only 2 with
         - SIM 7070/7080/7090 - 12
         - SIM 7500/7600/7800 - 10
+        - SIM A7672X - 10
         - u-blox 2G/3G - 7
         - u-blox SARA R4/N4 - 7
         - Digi XBee - _only 1 connection supported!_
@@ -127,10 +122,10 @@ Watch this repo for new updates! And of course, contributions are welcome ;)
     - Not yet supported on any module, though it may be some day
 - SSL/TLS (HTTPS)
     - Supported on:
-        - SIM800, SIM7000, u-Blox, XBee _cellular_, ESP8266, Sequans Monarch and Quectel BG95
+        - SIM800, SIM7000, A7672X, u-Blox, XBee _cellular_, ESP8266, Sequans Monarch and Quectel BG95 and BG96
         - Note:  **only some device models or firmware revisions have this feature** (SIM8xx R14.18, A7, etc.)
     - Not yet supported on:
-        - Quectel BG96, SIM 5360/5320/7100, SIM 7500/7600/7800
+        - SIM 5360/5320/7100, SIM 7500/7600/7800
     - Not possible on:
         - SIM900, A6/A7, Neoway M590, XBee _WiFi_
     - Like TCP, most modules support simultaneous connections
diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index 9fbd32f..b37f70f 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -19,6 +19,7 @@
 // #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
diff --git a/examples/BlynkClient/BlynkClient.ino b/examples/BlynkClient/BlynkClient.ino
index 9dcb319..21a4b05 100644
--- a/examples/BlynkClient/BlynkClient.ino
+++ b/examples/BlynkClient/BlynkClient.ino
@@ -22,11 +22,11 @@
  * Change GPRS apm, user, pass, and Blynk auth token to run :)
  **************************************************************/
 
-#define BLYNK_TEMPLATE_ID           "TMPxxxxxx"
-#define BLYNK_TEMPLATE_NAME         "Device"
-#define BLYNK_AUTH_TOKEN            "YourAuthToken"
+#define BLYNK_TEMPLATE_ID "TMPxxxxxx"
+#define BLYNK_TEMPLATE_NAME "Device"
+#define BLYNK_AUTH_TOKEN "YourAuthToken"
 
-#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
+#define BLYNK_PRINT Serial  // Comment this out to disable prints and save space
 
 // Default heartbeat interval for GSM is 60
 // If you want override this value, uncomment and set this option:
@@ -42,10 +42,12 @@
 // #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
@@ -84,8 +86,7 @@ const char auth[] = "YourAuthToken";
 
 TinyGsm modem(SerialAT);
 
-void setup()
-{
+void setup() {
   // Set console baud rate
   SerialMon.begin(115200);
   delay(10);
@@ -104,12 +105,11 @@ void setup()
   SerialMon.println(modemInfo);
 
   // Unlock your SIM card with a PIN
-  //modem.simUnlock("1234");
+  // modem.simUnlock("1234");
 
   Blynk.begin(auth, modem, apn, user, pass);
 }
 
-void loop()
-{
+void loop() {
   Blynk.run();
 }
diff --git a/examples/FileDownload/FileDownload.ino b/examples/FileDownload/FileDownload.ino
index d41a528..2d96687 100644
--- a/examples/FileDownload/FileDownload.ino
+++ b/examples/FileDownload/FileDownload.ino
@@ -23,10 +23,12 @@
 // #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
diff --git a/examples/HttpClient/HttpClient.ino b/examples/HttpClient/HttpClient.ino
index d6243fe..74f1c7c 100644
--- a/examples/HttpClient/HttpClient.ino
+++ b/examples/HttpClient/HttpClient.ino
@@ -28,10 +28,12 @@
 // #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
diff --git a/examples/MqttClient/MqttClient.ino b/examples/MqttClient/MqttClient.ino
index 05b6993..327461a 100644
--- a/examples/MqttClient/MqttClient.ino
+++ b/examples/MqttClient/MqttClient.ino
@@ -32,10 +32,12 @@
 // #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
diff --git a/examples/WebClient/WebClient.ino b/examples/WebClient/WebClient.ino
index 56755ea..4708d22 100644
--- a/examples/WebClient/WebClient.ino
+++ b/examples/WebClient/WebClient.ino
@@ -18,10 +18,12 @@
 // #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index fefc8e9..4ab2ca8 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -79,7 +79,8 @@ typedef TinyGsmSaraR5::GsmClientSecureR5 TinyGsmClientSecure;
 typedef TinyGsmM95               TinyGsm;
 typedef TinyGsmM95::GsmClientM95 TinyGsmClient;
 
-#elif defined(TINY_GSM_MODEM_BG96) || defined(TINY_GSM_MODEM_BG95SSL)
+#elif defined(TINY_GSM_MODEM_BG96) || defined(TINY_GSM_MODEM_BG95) || \
+    defined(TINY_GSM_MODEM_BG95SSL)
 #include "TinyGsmClientBG96.h"
 typedef TinyGsmBG96                      TinyGsm;
 typedef TinyGsmBG96::GsmClientBG96       TinyGsmClient;
diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 45b231d..e50b372 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -13,6 +13,10 @@
 
 #define TINY_GSM_MUX_COUNT 10
 #define TINY_GSM_BUFFER_READ_AND_CHECK_SIZE
+#ifdef AT_NL
+#undef AT_NL
+#endif
+#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmBattery.tpp"
 #include "TinyGsmCalling.tpp"
@@ -26,15 +30,7 @@
 #include "TinyGsmNTP.tpp"
 #include "TinyGsmTemperature.tpp"
 
-#define GSM_NL "\r\n"
-static const char GSM_OK[] TINY_GSM_PROGMEM    = "OK" GSM_NL;
-static const char GSM_ERROR[] TINY_GSM_PROGMEM = "ERROR" GSM_NL;
-#if defined       TINY_GSM_DEBUG
-static const char GSM_CME_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CME ERROR:";
-static const char GSM_CMS_ERROR[] TINY_GSM_PROGMEM = GSM_NL "+CMS ERROR:";
-#endif
-
-enum RegStatus {
+enum A7672xRegStatus {
   REG_NO_RESULT    = -1,
   REG_UNREGISTERED = 0,
   REG_SEARCHING    = 2,
@@ -181,7 +177,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = NULL) {
+  bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  A7672X"));
 
@@ -203,9 +199,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     DBG(GF("### Modem:"), getModemName());
 
     SimStatus ret = getSimStatus();
-    // if the sim isn't ready and a pin has been provided, try to unlock the
-    // sim
-    if (ret != SIM_READY && pin != NULL && strlen(pin) > 0) {
+    // if the sim isn't ready and a pin has been provided, try to unlock the sim
+    if (ret != SIM_READY && pin != nullptr && strlen(pin) > 0) {
       simUnlock(pin);
       return (getSimStatus() == SIM_READY);
     } else {
@@ -221,7 +216,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     sendAT(GF("+CGMM"));
     String res2;
     if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(GSM_NL "OK" GSM_NL, "");
+    res2.replace(AT_NL "OK" AT_NL, "");
     res2.replace("_", " ");
     res2.trim();
 
@@ -230,18 +225,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return name;
   }
 
-  float getTemperatureImpl() {
-    String res = "";
-    sendAT(GF("+CPMUTEMP"));
-    if (waitResponse(1000L, res)) { return 0; }
-    res        = res.substring(res.indexOf(':'), res.indexOf('\r'));
-    float temp = res.toFloat();
-    waitResponse();
-    return temp;
-  }
-
   bool factoryDefaultImpl() {
-    sendAT(GF("&F"));        // Factory + Reset
+    sendAT(GF("&F"));  // Factory + Reset
     waitResponse();
     sendAT(GF("+IFC=0,0"));  // No Flow Control
     waitResponse();
@@ -249,7 +234,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     waitResponse();
     sendAT(GF("+CSCLK=0"));  // Control UART Sleep always work
     waitResponse();
-    sendAT(GF("&W"));        // Write configuration
+    sendAT(GF("&W"));  // Write configuration
     return waitResponse() == 1;
   }
 
@@ -281,7 +266,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Power functions
    */
  protected:
-  bool restartImpl(const char* pin = NULL) {
+  bool restartImpl(const char* pin = nullptr) {
     if (!testAT()) { return false; }
     sendAT(GF("+CRESET"));
     waitResponse();
@@ -325,8 +310,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Generic network functions
    */
  public:
-  RegStatus getRegistrationStatus() {
-    return (RegStatus)getRegistrationStatusXREG("CREG");
+  A7672xRegStatus getRegistrationStatus() {
+    return (A7672xRegStatus)getRegistrationStatusXREG("CREG");
   }
 
   String getLocalIPImpl() {
@@ -345,7 +330,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 
  protected:
   bool isNetworkConnectedImpl() {
-    RegStatus s = getRegistrationStatus();
+    A7672xRegStatus s = getRegistrationStatus();
     return (s == REG_OK_HOME || s == REG_OK_ROAMING);
   }
 
@@ -381,8 +366,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * GPRS functions
    */
  protected:
-  bool gprsConnectImpl(const char* apn, const char* user = NULL,
-                       const char* pwd = NULL) {
+  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
+                       const char* pwd = nullptr) {
     gprsDisconnect();
 
     // Define the PDP context
@@ -429,7 +414,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
  protected:
   String getSimCCIDImpl() {
     sendAT(GF("+CICCID"));
-    if (waitResponse(GF(GSM_NL "+ICCID:")) != 1) { return ""; }
+    if (waitResponse(GF(AT_NL "+ICCID:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
     waitResponse();
     res.trim();
@@ -473,6 +458,19 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Battery functions //todo:
    */
  protected:
+  /*
+   * Temperature functions
+   */
+ protected:
+  float getTemperatureImpl() {
+    String res = "";
+    sendAT(GF("+CPMUTEMP"));
+    if (waitResponse(1000L, res)) { return 0; }
+    res        = res.substring(res.indexOf(':'), res.indexOf('\r'));
+    float temp = res.toFloat();
+    waitResponse();
+    return temp;
+  }
   /*
    * Client related functions
    */
@@ -537,9 +535,9 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
       if (waitResponse(2000L) != 1) { return false; }
 
       sendAT(GF("+CCHOPEN="), 0, GF(",\""), host, GF("\","), port, GF(",2"));
-      rsp = waitResponse(timeout_ms, GF("+CCHOPEN: 0,0" GSM_NL),
-                         GF("+CCHOPEN: 0,1" GSM_NL), GF("+CCHOPEN: 0,4" GSM_NL),
-                         GF("ERROR" GSM_NL), GF("CLOSE OK" GSM_NL));
+      rsp = waitResponse(timeout_ms, GF("+CCHOPEN: 0,0" AT_NL),
+                         GF("+CCHOPEN: 0,1" AT_NL), GF("+CCHOPEN: 0,4" AT_NL),
+                         GF("ERROR" AT_NL), GF("CLOSE OK" AT_NL));
     } else {
       sendAT(GF("+NETOPEN"));
       if (waitResponse(2000L) != 1) { return false; }
@@ -551,9 +549,9 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
              port);
 
       rsp = waitResponse(
-          timeout_ms, GF("+CIPOPEN: 0,0" GSM_NL), GF("+CIPOPEN: 0,1" GSM_NL),
-          GF("+CIPOPEN: 0,4" GSM_NL), GF("ERROR" GSM_NL),
-          GF("CLOSE OK" GSM_NL));  // Happens when HTTPS handshake fails
+          timeout_ms, GF("+CIPOPEN: 0,0" AT_NL), GF("+CIPOPEN: 0,1" AT_NL),
+          GF("+CIPOPEN: 0,4" AT_NL), GF("ERROR" AT_NL),
+          GF("CLOSE OK" AT_NL));  // Happens when HTTPS handshake fails
     }
 
     return (1 == rsp);
@@ -569,9 +567,9 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     stream.flush();
 
     if (waitResponse() != 1) { return 0; }
-    if (waitResponse(10000L, GF("+CCHSEND: 0,0" GSM_NL),
-                     GF("+CCHSEND: 0,4" GSM_NL), GF("+CCHSEND: 0,9" GSM_NL),
-                     GF("ERROR" GSM_NL), GF("CLOSE OK" GSM_NL)) != 1) {
+    if (waitResponse(10000L, GF("+CCHSEND: 0,0" AT_NL),
+                     GF("+CCHSEND: 0,4" AT_NL), GF("+CCHSEND: 0,9" AT_NL),
+                     GF("ERROR" AT_NL), GF("CLOSE OK" AT_NL)) != 1) {
       return 0;
     }
     return len;
@@ -593,7 +591,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
       streamSkipUntil(',');  // Skip DATA
       streamSkipUntil(',');  // Skip mux
       len_requested = streamGetIntBefore('\n');
-      len_confirmed = len;   // streamGetIntBefore(',');
+      len_confirmed = len;  // streamGetIntBefore(',');
     } else {
       sendAT(GF("+CIPRXGET=2,"), mux, ',', (uint16_t)size);
       if (waitResponse(GF("+CIPRXGET:")) != 1) { return 0; }
@@ -669,162 +667,91 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * Utilities
    */
  public:
-  // TODO(vshymanskyy): Optimize this!
-  int8_t waitResponse(uint32_t timeout_ms, String& data,
-                      GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    /*String r1s(r1); r1s.trim();
-    String r2s(r2); r2s.trim();
-    String r3s(r3); r3s.trim();
-    String r4s(r4); r4s.trim();
-    String r5s(r5); r5s.trim();
-    DBG("### ..:", r1s, ",", r2s, ",", r3s, ",", r4s, ",", r5s);*/
-    data.reserve(64);
-    uint8_t  index       = 0;
-    uint32_t startMillis = millis();
-    do {
-      TINY_GSM_YIELD();
-      while (stream.available() > 0) {
-        TINY_GSM_YIELD();
-        int8_t a = stream.read();
-        if (a <= 0) continue;  // Skip 0x00 bytes, just in case
-        data += static_cast<char>(a);
-        if (r1 && data.endsWith(r1)) {
-          index = 1;
-          goto finish;
-        } else if (r2 && data.endsWith(r2)) {
-          index = 2;
-          goto finish;
-        } else if (r3 && data.endsWith(r3)) {
-#if defined TINY_GSM_DEBUG
-          if (r3 == GFP(GSM_CME_ERROR)) {
-            streamSkipUntil('\n');  // Read out the error
-          }
-#endif
-          index = 3;
-          goto finish;
-        } else if (r4 && data.endsWith(r4)) {
-          index = 4;
-          goto finish;
-        } else if (r5 && data.endsWith(r5)) {
-          index = 5;
-          goto finish;
-        } else if (data.endsWith(GF(GSM_NL "+CIPRXGET:"))) {
-          int8_t mode = streamGetIntBefore(',');
-          if (mode == 1) {
-            int8_t mux = streamGetIntBefore('\n');
-            if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-              sockets[mux]->got_data = true;
-            }
-            data = "";
-            DBG("### Got Data:", mux);
-          } else {
-            data += mode;
-          }
-        } else if (data.endsWith(GF("RECV EVENT" GSM_NL))) {
-          sendAT(GF("+CCHRECV?"));
-          String res = "";
-          waitResponse(2000L, res);
-          int8_t  mux = res.substring(res.lastIndexOf(',') + 1).toInt();
-          int16_t len =
-              res.substring(res.indexOf(',') + 1, res.lastIndexOf(',')).toInt();
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->got_data = true;
-            if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
-          }
-          data = "";
-          DBG("### Got Data:", len, "on", mux);
-        } else if (data.endsWith(GF("+CCHRECV: 0,0" GSM_NL))) {
-          int8_t mux = data.substring(data.lastIndexOf(',') + 1).toInt();
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = true;
-          }
-          data = "";
-          DBG("### ACK:", mux);
-        } else if (data.endsWith(GF("+IPCLOSE:"))) {
-          int8_t mux = streamGetIntBefore(',');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          streamSkipUntil('\n');
-          DBG("### TCP Closed: ", mux);
-        } else if (data.endsWith(GF("+CCHCLOSE:"))) {
-          int8_t mux = streamGetIntBefore(',');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          streamSkipUntil('\n');
-          DBG("### SSL Closed: ", mux);
-        } else if (data.endsWith(GF("+CCH_PEER_CLOSED:"))) {
-          int8_t mux = streamGetIntBefore('\n');
-          if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
-            sockets[mux]->sock_connected = false;
-          }
-          data = "";
-          DBG("### SSL Closed: ", mux);
-        } else if (data.endsWith(GF("*PSNWID:"))) {
-          streamSkipUntil('\n');  // Refresh network name by network
-          data = "";
-          DBG("### Network name updated.");
-        } else if (data.endsWith(GF("*PSUTTZ:"))) {
-          streamSkipUntil('\n');  // Refresh time and time zone by network
-          data = "";
-          DBG("### Network time and time zone updated.");
-        } else if (data.endsWith(GF("+CTZV:"))) {
-          streamSkipUntil('\n');  // Refresh network time zone by network
-          data = "";
-          DBG("### Network time zone updated.");
-        } else if (data.endsWith(GF("DST:"))) {
-          streamSkipUntil(
-              '\n');  // Refresh Network Daylight Saving Time by network
-          data = "";
-          DBG("### Daylight savings time state updated.");
+  bool handleURCs(String& data) {
+    if (data.endsWith(GF(AT_NL "+CIPRXGET:"))) {
+      int8_t mode = streamGetIntBefore(',');
+      if (mode == 1) {
+        int8_t mux = streamGetIntBefore('\n');
+        if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+          sockets[mux]->got_data = true;
         }
+        data = "";
+        DBG("### Got Data:", mux);
+        return true;
+      } else {
+        data += mode;
+        return false;
+      }
+    } else if (data.endsWith(GF("RECV EVENT" AT_NL))) {
+      sendAT(GF("+CCHRECV?"));
+      String res = "";
+      waitResponse(2000L, res);
+      int8_t  mux = res.substring(res.lastIndexOf(',') + 1).toInt();
+      int16_t len =
+          res.substring(res.indexOf(',') + 1, res.lastIndexOf(',')).toInt();
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->got_data = true;
+        if (len >= 0 && len <= 1024) { sockets[mux]->sock_available = len; }
       }
-    } while (millis() - startMillis < timeout_ms);
-  finish:
-    if (!index) {
-      data.trim();
-      if (data.length()) { DBG("### Unhandled:", data); }
       data = "";
+      DBG("### Got Data:", len, "on", mux);
+      return true;
+    } else if (data.endsWith(GF("+CCHRECV: 0,0" AT_NL))) {
+      int8_t mux = data.substring(data.lastIndexOf(',') + 1).toInt();
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = true;
+      }
+      data = "";
+      DBG("### ACK:", mux);
+      return true;
+    } else if (data.endsWith(GF("+IPCLOSE:"))) {
+      int8_t mux = streamGetIntBefore(',');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      streamSkipUntil('\n');
+      DBG("### TCP Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("+CCHCLOSE:"))) {
+      int8_t mux = streamGetIntBefore(',');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      streamSkipUntil('\n');
+      DBG("### SSL Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("+CCH_PEER_CLOSED:"))) {
+      int8_t mux = streamGetIntBefore('\n');
+      if (mux >= 0 && mux < TINY_GSM_MUX_COUNT && sockets[mux]) {
+        sockets[mux]->sock_connected = false;
+      }
+      data = "";
+      DBG("### SSL Closed: ", mux);
+      return true;
+    } else if (data.endsWith(GF("*PSNWID:"))) {
+      streamSkipUntil('\n');  // Refresh network name by network
+      data = "";
+      DBG("### Network name updated.");
+      return true;
+    } else if (data.endsWith(GF("*PSUTTZ:"))) {
+      streamSkipUntil('\n');  // Refresh time and time zone by network
+      data = "";
+      DBG("### Network time and time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("+CTZV:"))) {
+      streamSkipUntil('\n');  // Refresh network time zone by network
+      data = "";
+      DBG("### Network time zone updated.");
+      return true;
+    } else if (data.endsWith(GF("DST:"))) {
+      streamSkipUntil('\n');  // Refresh Network Daylight Saving Time by network
+      data = "";
+      DBG("### Daylight savings time state updated.");
+      return true;
     }
-    // data.replace(GSM_NL, "/");
-    // DBG('<', index, '>', data);
-    return index;
-  }
-
-  int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    String data;
-    return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5);
-  }
-
-  int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
-                      GsmConstStr r2 = GFP(GSM_ERROR),
-#if defined TINY_GSM_DEBUG
-                      GsmConstStr r3 = GFP(GSM_CME_ERROR),
-                      GsmConstStr r4 = GFP(GSM_CMS_ERROR),
-#else
-                      GsmConstStr r3 = NULL, GsmConstStr r4 = NULL,
-#endif
-                      GsmConstStr r5 = NULL) {
-    return waitResponse(1000, r1, r2, r3, r4, r5);
+    return false;
   }
 
  public:
@@ -832,7 +759,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
 
  protected:
   GsmClientA7672X* sockets[TINY_GSM_MUX_COUNT];
-  const char*      gsmNL  = GSM_NL;
   bool             hasSSL = false;
   String           certificates[TINY_GSM_MUX_COUNT];
 };
diff --git a/tools/AT_Debug/AT_Debug.ino b/tools/AT_Debug/AT_Debug.ino
index 1514a7c..65762e3 100644
--- a/tools/AT_Debug/AT_Debug.ino
+++ b/tools/AT_Debug/AT_Debug.ino
@@ -10,11 +10,20 @@
 
 // Select your modem:
 #define TINY_GSM_MODEM_SIM800
-// #define TINY_GSM_MODEM_SIM900
 // #define TINY_GSM_MODEM_SIM808
 // #define TINY_GSM_MODEM_SIM868
+// #define TINY_GSM_MODEM_SIM900
+// #define TINY_GSM_MODEM_SIM7000
+// #define TINY_GSM_MODEM_SIM7000SSL
+// #define TINY_GSM_MODEM_SIM7080
+// #define TINY_GSM_MODEM_SIM5360
+// #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_SARAR5
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
@@ -23,6 +32,7 @@
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
 // #define TINY_GSM_MODEM_XBEE
+// #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
 // Set serial for debug console (to the Serial Monitor, speed 115200)
 #define SerialMon Serial
@@ -43,7 +53,7 @@ SoftwareSerial SerialAT(2, 3);  // RX, TX
 #include <TinyGsmClient.h>
 
 // Module baud rate
-uint32_t rate = 0; // Set to 0 for Auto-Detect
+uint32_t rate = 0;  // Set to 0 for Auto-Detect
 
 void setup() {
   // Set console baud rate
@@ -52,17 +62,17 @@ void setup() {
 }
 
 void loop() {
+  if (!rate) { rate = TinyGsmAutoBaud(SerialAT); }
 
   if (!rate) {
-    rate = TinyGsmAutoBaud(SerialAT);
-  }
-
-  if (!rate) {
-    SerialMon.println(F("***********************************************************"));
+    SerialMon.println(
+        F("***********************************************************"));
     SerialMon.println(F(" Module does not respond!"));
     SerialMon.println(F("   Check your Serial wiring"));
-    SerialMon.println(F("   Check the module is correctly powered and turned on"));
-    SerialMon.println(F("***********************************************************"));
+    SerialMon.println(
+        F("   Check the module is correctly powered and turned on"));
+    SerialMon.println(
+        F("***********************************************************"));
     delay(30000L);
     return;
   }
@@ -70,19 +80,19 @@ void loop() {
   SerialAT.begin(rate);
 
   // Access AT commands from Serial Monitor
-  SerialMon.println(F("***********************************************************"));
+  SerialMon.println(
+      F("***********************************************************"));
   SerialMon.println(F(" You can now send AT commands"));
-  SerialMon.println(F(" Enter \"AT\" (without quotes), and you should see \"OK\""));
-  SerialMon.println(F(" If it doesn't work, select \"Both NL & CR\" in Serial Monitor"));
-  SerialMon.println(F("***********************************************************"));
+  SerialMon.println(
+      F(" Enter \"AT\" (without quotes), and you should see \"OK\""));
+  SerialMon.println(
+      F(" If it doesn't work, select \"Both NL & CR\" in Serial Monitor"));
+  SerialMon.println(
+      F("***********************************************************"));
 
-  while(true) {
-    if (SerialAT.available()) {
-      SerialMon.write(SerialAT.read());
-    }
-    if (SerialMon.available()) {
-      SerialAT.write(SerialMon.read());
-    }
+  while (true) {
+    if (SerialAT.available()) { SerialMon.write(SerialAT.read()); }
+    if (SerialMon.available()) { SerialAT.write(SerialMon.read()); }
     delay(0);
   }
 }
diff --git a/tools/Diagnostics/Diagnostics.ino b/tools/Diagnostics/Diagnostics.ino
index 8d2247f..88e3a22 100644
--- a/tools/Diagnostics/Diagnostics.ino
+++ b/tools/Diagnostics/Diagnostics.ino
@@ -19,6 +19,7 @@
 // #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
 // #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_M95
diff --git a/tools/FactoryReset/FactoryReset.ino b/tools/FactoryReset/FactoryReset.ino
index 545a247..27f137f 100644
--- a/tools/FactoryReset/FactoryReset.ino
+++ b/tools/FactoryReset/FactoryReset.ino
@@ -11,11 +11,19 @@
 
 // Select your modem:
 #define TINY_GSM_MODEM_SIM800
-// #define TINY_GSM_MODEM_SIM900
 // #define TINY_GSM_MODEM_SIM808
 // #define TINY_GSM_MODEM_SIM868
+// #define TINY_GSM_MODEM_SIM900
+// #define TINY_GSM_MODEM_SIM7000
+// #define TINY_GSM_MODEM_SIM7000SSL
+// #define TINY_GSM_MODEM_SIM7080
+// #define TINY_GSM_MODEM_SIM5360
+// #define TINY_GSM_MODEM_SIM7600
+// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG95
 // #define TINY_GSM_MODEM_BG96
 // #define TINY_GSM_MODEM_A6
 // #define TINY_GSM_MODEM_A7
@@ -24,6 +32,7 @@
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
 // #define TINY_GSM_MODEM_XBEE
+// #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
 #include <TinyGsmClient.h>
 
@@ -43,7 +52,7 @@ SoftwareSerial SerialAT(2, 3);  // RX, TX
 
 #include <StreamDebugger.h>
 StreamDebugger debugger(SerialAT, SerialMon);
-TinyGsm modem(debugger);
+TinyGsm        modem(debugger);
 
 void setup() {
   // Set console baud rate
@@ -55,22 +64,25 @@ void setup() {
   delay(6000);
 
   if (!modem.init()) {
-    SerialMon.println(F("***********************************************************"));
+    SerialMon.println(
+        F("***********************************************************"));
     SerialMon.println(F(" Cannot initialize modem!"));
-    SerialMon.println(F("   Use File -> Examples -> TinyGSM -> tools -> AT_Debug"));
+    SerialMon.println(
+        F("   Use File -> Examples -> TinyGSM -> tools -> AT_Debug"));
     SerialMon.println(F("   to find correct configuration"));
-    SerialMon.println(F("***********************************************************"));
+    SerialMon.println(
+        F("***********************************************************"));
     return;
   }
 
   bool ret = modem.factoryDefault();
 
-  SerialMon.println(F("***********************************************************"));
-  SerialMon.print  (F(" Return settings to Factory Defaults: "));
+  SerialMon.println(
+      F("***********************************************************"));
+  SerialMon.print(F(" Return settings to Factory Defaults: "));
   SerialMon.println((ret) ? "OK" : "FAIL");
-  SerialMon.println(F("***********************************************************"));
+  SerialMon.println(
+      F("***********************************************************"));
 }
 
-void loop() {
-
-}
+void loop() {}

From d6082295228e8b2c1433b84cce62de146489d0f6 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Mon, 20 May 2024 15:31:55 -0400
Subject: [PATCH 068/100] Fix A7672x case

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClient.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index 4ab2ca8..470a2e0 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -123,7 +123,7 @@ typedef TinyGsmSequansMonarch::GsmClientSecureSequansMonarch
     TinyGsmClientSecure;
 
 #elif defined(TINY_GSM_MODEM_A7672X)
-#include "TinyGsmClientA7672X.h"
+#include "TinyGsmClientA7672x.h"
 typedef TinyGsmA7672X                        TinyGsm;
 typedef TinyGsmA7672X::GsmClientA7672X       TinyGsmClient;
 typedef TinyGsmA7672X::GsmClientSecureA7672X TinyGsmClientSecure;

From edb42d896a75505a3386b334e8adb29e2b852973 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 21 May 2024 15:46:19 -0400
Subject: [PATCH 069/100] Added some notes

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmBattery.tpp     | 12 ++++++++++++
 src/TinyGsmBluetooth.tpp   | 11 +++++++++++
 src/TinyGsmCalling.tpp     | 11 +++++++++++
 src/TinyGsmGPRS.tpp        | 11 +++++++++++
 src/TinyGsmGPS.tpp         | 12 ++++++++++++
 src/TinyGsmGSMLocation.tpp | 11 +++++++++++
 src/TinyGsmModem.tpp       | 13 ++++++++++++-
 src/TinyGsmNTP.tpp         | 11 +++++++++++
 src/TinyGsmSMS.tpp         | 13 ++++++++++++-
 src/TinyGsmSSL.tpp         | 27 ++++++++-------------------
 src/TinyGsmTCP.tpp         | 11 +++++++++++
 src/TinyGsmTemperature.tpp | 11 +++++++++++
 src/TinyGsmTime.tpp        | 10 ++++++++++
 src/TinyGsmWifi.tpp        | 11 +++++++++++
 14 files changed, 154 insertions(+), 21 deletions(-)

diff --git a/src/TinyGsmBattery.tpp b/src/TinyGsmBattery.tpp
index a662682..401af5a 100644
--- a/src/TinyGsmBattery.tpp
+++ b/src/TinyGsmBattery.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmBattery {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Battery functions
@@ -44,6 +49,13 @@ class TinyGsmBattery {
     return static_cast<modemType&>(*this);
   }
 
+
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * Battery functions
    */
diff --git a/src/TinyGsmBluetooth.tpp b/src/TinyGsmBluetooth.tpp
index 58b538d..3a300dc 100644
--- a/src/TinyGsmBluetooth.tpp
+++ b/src/TinyGsmBluetooth.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmBluetooth {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Bluetooth functions
@@ -43,6 +48,12 @@ class TinyGsmBluetooth {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * Bluetooth functions
    */
diff --git a/src/TinyGsmCalling.tpp b/src/TinyGsmCalling.tpp
index 413515a..c3ed284 100644
--- a/src/TinyGsmCalling.tpp
+++ b/src/TinyGsmCalling.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmCalling {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Phone Call functions
@@ -43,6 +48,12 @@ class TinyGsmCalling {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * Phone Call functions
    */
diff --git a/src/TinyGsmGPRS.tpp b/src/TinyGsmGPRS.tpp
index 69d253a..512d696 100644
--- a/src/TinyGsmGPRS.tpp
+++ b/src/TinyGsmGPRS.tpp
@@ -22,6 +22,11 @@ enum SimStatus {
 
 template <class modemType>
 class TinyGsmGPRS {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * SIM card functions
@@ -81,6 +86,12 @@ class TinyGsmGPRS {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmGPS.tpp b/src/TinyGsmGPS.tpp
index 897d1f9..814de6a 100644
--- a/src/TinyGsmGPS.tpp
+++ b/src/TinyGsmGPS.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmGPS {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * GPS/GNSS/GLONASS location functions
@@ -62,6 +67,13 @@ class TinyGsmGPS {
     return static_cast<modemType&>(*this);
   }
 
+
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * GPS/GNSS/GLONASS location functions
    */
diff --git a/src/TinyGsmGSMLocation.tpp b/src/TinyGsmGSMLocation.tpp
index b05a65d..edfde61 100644
--- a/src/TinyGsmGSMLocation.tpp
+++ b/src/TinyGsmGSMLocation.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmGSMLocation {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * GSM Location functions
@@ -54,6 +59,12 @@ class TinyGsmGSMLocation {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * GSM Location functions
    * Template is based on SIMCOM commands
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 24d7b50..26cf237 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -43,6 +43,11 @@ static const char GSM_VERBOSE_2[] TINY_GSM_PROGMEM = AT_VERBOSE_2;
 
 template <class modemType>
 class TinyGsmModem {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Basic functions
@@ -168,6 +173,12 @@ class TinyGsmModem {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * Basic functions
    */
@@ -175,7 +186,7 @@ class TinyGsmModem {
   bool setBaudImpl(uint32_t baud) {
     thisModem().sendAT(GF("+IPR="), baud);
     return thisModem().waitResponse() == 1;
-  } 
+  }
 
   bool testATImpl(uint32_t timeout_ms = 10000L) {
     for (uint32_t start = millis(); millis() - start < timeout_ms;) {
diff --git a/src/TinyGsmNTP.tpp b/src/TinyGsmNTP.tpp
index 6ae23cc..eedbf7f 100644
--- a/src/TinyGsmNTP.tpp
+++ b/src/TinyGsmNTP.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmNTP {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * NTP server functions
@@ -50,6 +55,12 @@ class TinyGsmNTP {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * NTP server functions
    */
diff --git a/src/TinyGsmSMS.tpp b/src/TinyGsmSMS.tpp
index 10e3ce8..c8960f1 100644
--- a/src/TinyGsmSMS.tpp
+++ b/src/TinyGsmSMS.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmSMS {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Messaging functions
@@ -41,7 +46,7 @@ class TinyGsmSMS {
   }
 
   /*
-   * Messaging functions
+   * Utilities
    */
  protected:
   static inline String TinyGsmDecodeHex7bit(String& instr) {
@@ -111,6 +116,12 @@ class TinyGsmSMS {
     return result;
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   String sendUSSDImpl(const String& code) {
     // Set preferred message format to text mode
     thisModem().sendAT(GF("+CMGF=1"));
diff --git a/src/TinyGsmSSL.tpp b/src/TinyGsmSSL.tpp
index f33a579..d659944 100644
--- a/src/TinyGsmSSL.tpp
+++ b/src/TinyGsmSSL.tpp
@@ -16,6 +16,11 @@
 
 template <class modemType>
 class TinyGsmSSL {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * SSL functions
@@ -38,27 +43,11 @@ class TinyGsmSSL {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
   /*
-   * Inner Secure Client
+   * Define the default function implementations
    */
-  /*
- public:
-  class GsmClientSecure : public GsmClient {
-   public:
-    GsmClientSecureSim800() {}
-
-    explicit GsmClientSecureSim800(TinyGsmSim800& modem, uint8_t mux = 0)
-        : GsmClientSim800(modem, mux) {}
-
-   public:
-    int connect(const char* host, uint16_t port, int timeout_s) overide {
-      stop();
-      TINY_GSM_YIELD();
-      rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
-      return sock_connected;
-    }
-  };*/
 
   /*
    * SSL functions
diff --git a/src/TinyGsmTCP.tpp b/src/TinyGsmTCP.tpp
index 7487e72..7b81fbb 100644
--- a/src/TinyGsmTCP.tpp
+++ b/src/TinyGsmTCP.tpp
@@ -43,6 +43,11 @@
 
 template <class modemType, uint8_t muxCount>
 class TinyGsmTCP {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Basic functions
@@ -315,6 +320,12 @@ class TinyGsmTCP {
     RxFifo     rx;
   };
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * Basic functions
    */
diff --git a/src/TinyGsmTemperature.tpp b/src/TinyGsmTemperature.tpp
index 215f250..22a2976 100644
--- a/src/TinyGsmTemperature.tpp
+++ b/src/TinyGsmTemperature.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmTemperature {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Temperature functions
@@ -34,6 +39,12 @@ class TinyGsmTemperature {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   float getTemperatureImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
 };
 
diff --git a/src/TinyGsmTime.tpp b/src/TinyGsmTime.tpp
index 4e3c1a0..d9ff9f6 100644
--- a/src/TinyGsmTime.tpp
+++ b/src/TinyGsmTime.tpp
@@ -17,6 +17,11 @@ enum TinyGSMDateTimeFormat { DATE_FULL = 0, DATE_TIME = 1, DATE_DATE = 2 };
 
 template <class modemType>
 class TinyGsmTime {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * Time functions
@@ -46,6 +51,11 @@ class TinyGsmTime {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
   /*
    * Time functions
    */
diff --git a/src/TinyGsmWifi.tpp b/src/TinyGsmWifi.tpp
index cbf92bb..6629442 100644
--- a/src/TinyGsmWifi.tpp
+++ b/src/TinyGsmWifi.tpp
@@ -15,6 +15,11 @@
 
 template <class modemType>
 class TinyGsmWifi {
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the interface
+   */
  public:
   /*
    * WiFi functions
@@ -37,6 +42,12 @@ class TinyGsmWifi {
     return static_cast<modemType&>(*this);
   }
 
+  /* =========================================== */
+  /* =========================================== */
+  /*
+   * Define the default function implementations
+   */
+
   /*
    * WiFi functions
    */

From d9608f94b4ca7519c2b429916f04ed3dacb84d88 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 21 May 2024 15:47:49 -0400
Subject: [PATCH 070/100] Reorder utilities

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmModem.tpp | 251 ++++++++++++++++++++++---------------------
 src/TinyGsmNTP.tpp   |  17 +--
 2 files changed, 136 insertions(+), 132 deletions(-)

diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 26cf237..9d8d5ce 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -173,6 +173,132 @@ class TinyGsmModem {
     return static_cast<modemType&>(*this);
   }
 
+  /*
+   Utilities
+   */
+ public:
+  // Utility templates for writing/skipping characters on a stream
+  template <typename T>
+  inline void streamWrite(T last) {
+    thisModem().stream.print(last);
+  }
+
+  template <typename T, typename... Args>
+  inline void streamWrite(T head, Args... tail) {
+    thisModem().stream.print(head);
+    thisModem().streamWrite(tail...);
+  }
+
+  inline void streamClear() {
+    while (thisModem().stream.available()) {
+      thisModem().waitResponse(50, nullptr, nullptr);
+    }
+  }
+
+ protected:
+  inline bool streamGetLength(char* buf, int8_t numChars,
+                              const uint32_t timeout_ms = 1000L) {
+    if (!buf) { return false; }
+
+    int8_t   numCharsReady = -1;
+    uint32_t startMillis   = millis();
+    while (millis() - startMillis < timeout_ms &&
+           (numCharsReady = thisModem().stream.available()) < numChars) {
+      TINY_GSM_YIELD();
+    }
+
+    if (numCharsReady >= numChars) {
+      thisModem().stream.readBytes(buf, numChars);
+      return true;
+    }
+
+    return false;
+  }
+
+  inline int16_t streamGetIntLength(int8_t         numChars,
+                                    const uint32_t timeout_ms = 1000L) {
+    char buf[numChars + 1];
+    if (streamGetLength(buf, numChars, timeout_ms)) {
+      buf[numChars] = '\0';
+      return atoi(buf);
+    }
+
+    return -9999;
+  }
+
+  inline int16_t streamGetIntBefore(char lastChar) {
+    char   buf[7];
+    size_t bytesRead = thisModem().stream.readBytesUntil(
+        lastChar, buf, static_cast<size_t>(7));
+    // if we read 7 or more bytes, it's an overflow
+    if (bytesRead && bytesRead < 7) {
+      buf[bytesRead] = '\0';
+      int16_t res    = atoi(buf);
+      return res;
+    }
+
+    return -9999;
+  }
+
+  inline float streamGetFloatLength(int8_t         numChars,
+                                    const uint32_t timeout_ms = 1000L) {
+    char buf[numChars + 1];
+    if (streamGetLength(buf, numChars, timeout_ms)) {
+      buf[numChars] = '\0';
+      return atof(buf);
+    }
+
+    return -9999.0F;
+  }
+
+  inline float streamGetFloatBefore(char lastChar) {
+    char   buf[16];
+    size_t bytesRead = thisModem().stream.readBytesUntil(
+        lastChar, buf, static_cast<size_t>(16));
+    // if we read 16 or more bytes, it's an overflow
+    if (bytesRead && bytesRead < 16) {
+      buf[bytesRead] = '\0';
+      float res      = atof(buf);
+      return res;
+    }
+
+    return -9999.0F;
+  }
+
+  inline bool streamSkipUntil(const char c, const uint32_t timeout_ms = 1000L) {
+    uint32_t startMillis = millis();
+    while (millis() - startMillis < timeout_ms) {
+      while (millis() - startMillis < timeout_ms &&
+             !thisModem().stream.available()) {
+        TINY_GSM_YIELD();
+      }
+      if (thisModem().stream.read() == c) { return true; }
+    }
+    return false;
+  }
+
+ protected:
+  static inline IPAddress TinyGsmIpFromString(const String& strIP) {
+    int Parts[4] = {
+        0,
+    };
+    int Part = 0;
+    for (uint8_t i = 0; i < strIP.length(); i++) {
+      char c = strIP[i];
+      if (c == '.') {
+        Part++;
+        if (Part > 3) { return IPAddress(0, 0, 0, 0); }
+        continue;
+      } else if (c >= '0' && c <= '9') {
+        Parts[Part] *= 10;
+        Parts[Part] += c - '0';
+      } else {
+        if (Part == 3) break;
+      }
+    }
+    return IPAddress(Parts[0], Parts[1], Parts[2], Parts[3]);
+  }
+
   /* =========================================== */
   /* =========================================== */
   /*
@@ -429,131 +555,6 @@ class TinyGsmModem {
     if (thisModem().waitResponse() != 1) { return ""; }
     return res;
   }
-
-  static inline IPAddress TinyGsmIpFromString(const String& strIP) {
-    int Parts[4] = {
-        0,
-    };
-    int Part = 0;
-    for (uint8_t i = 0; i < strIP.length(); i++) {
-      char c = strIP[i];
-      if (c == '.') {
-        Part++;
-        if (Part > 3) { return IPAddress(0, 0, 0, 0); }
-        continue;
-      } else if (c >= '0' && c <= '9') {
-        Parts[Part] *= 10;
-        Parts[Part] += c - '0';
-      } else {
-        if (Part == 3) break;
-      }
-    }
-    return IPAddress(Parts[0], Parts[1], Parts[2], Parts[3]);
-  }
-
-  /*
-   Utilities
-   */
- public:
-  // Utility templates for writing/skipping characters on a stream
-  template <typename T>
-  inline void streamWrite(T last) {
-    thisModem().stream.print(last);
-  }
-
-  template <typename T, typename... Args>
-  inline void streamWrite(T head, Args... tail) {
-    thisModem().stream.print(head);
-    thisModem().streamWrite(tail...);
-  }
-
-  inline void streamClear() {
-    while (thisModem().stream.available()) {
-      thisModem().waitResponse(50, nullptr, nullptr);
-    }
-  }
-
- protected:
-  inline bool streamGetLength(char* buf, int8_t numChars,
-                              const uint32_t timeout_ms = 1000L) {
-    if (!buf) { return false; }
-
-    int8_t   numCharsReady = -1;
-    uint32_t startMillis   = millis();
-    while (millis() - startMillis < timeout_ms &&
-           (numCharsReady = thisModem().stream.available()) < numChars) {
-      TINY_GSM_YIELD();
-    }
-
-    if (numCharsReady >= numChars) {
-      thisModem().stream.readBytes(buf, numChars);
-      return true;
-    }
-
-    return false;
-  }
-
-  inline int16_t streamGetIntLength(int8_t         numChars,
-                                    const uint32_t timeout_ms = 1000L) {
-    char buf[numChars + 1];
-    if (streamGetLength(buf, numChars, timeout_ms)) {
-      buf[numChars] = '\0';
-      return atoi(buf);
-    }
-
-    return -9999;
-  }
-
-  inline int16_t streamGetIntBefore(char lastChar) {
-    char   buf[7];
-    size_t bytesRead = thisModem().stream.readBytesUntil(
-        lastChar, buf, static_cast<size_t>(7));
-    // if we read 7 or more bytes, it's an overflow
-    if (bytesRead && bytesRead < 7) {
-      buf[bytesRead] = '\0';
-      int16_t res    = atoi(buf);
-      return res;
-    }
-
-    return -9999;
-  }
-
-  inline float streamGetFloatLength(int8_t         numChars,
-                                    const uint32_t timeout_ms = 1000L) {
-    char buf[numChars + 1];
-    if (streamGetLength(buf, numChars, timeout_ms)) {
-      buf[numChars] = '\0';
-      return atof(buf);
-    }
-
-    return -9999.0F;
-  }
-
-  inline float streamGetFloatBefore(char lastChar) {
-    char   buf[16];
-    size_t bytesRead = thisModem().stream.readBytesUntil(
-        lastChar, buf, static_cast<size_t>(16));
-    // if we read 16 or more bytes, it's an overflow
-    if (bytesRead && bytesRead < 16) {
-      buf[bytesRead] = '\0';
-      float res      = atof(buf);
-      return res;
-    }
-
-    return -9999.0F;
-  }
-
-  inline bool streamSkipUntil(const char c, const uint32_t timeout_ms = 1000L) {
-    uint32_t startMillis = millis();
-    while (millis() - startMillis < timeout_ms) {
-      while (millis() - startMillis < timeout_ms &&
-             !thisModem().stream.available()) {
-        TINY_GSM_YIELD();
-      }
-      if (thisModem().stream.read() == c) { return true; }
-    }
-    return false;
-  }
 };
 
 #endif  // SRC_TINYGSMMODEM_H_
diff --git a/src/TinyGsmNTP.tpp b/src/TinyGsmNTP.tpp
index eedbf7f..3fd8235 100644
--- a/src/TinyGsmNTP.tpp
+++ b/src/TinyGsmNTP.tpp
@@ -26,6 +26,16 @@ class TinyGsmNTP {
    */
 
  public:
+  byte NTPServerSync(String server = "pool.ntp.org", int TimeZone = 0) {
+    return thisModem().NTPServerSyncImpl(server, TimeZone);
+  }
+  String ShowNTPError(byte error) {
+    return thisModem().ShowNTPErrorImpl(error);
+  }
+
+  /*
+   * Utilities
+   */
   bool TinyGsmIsValidNumber(String str) {
     if (!(str.charAt(0) == '+' || str.charAt(0) == '-' ||
           isDigit(str.charAt(0))))
@@ -37,13 +47,6 @@ class TinyGsmNTP {
     return true;
   }
 
-  byte NTPServerSync(String server = "pool.ntp.org", int TimeZone = 0) {
-    return thisModem().NTPServerSyncImpl(server, TimeZone);
-  }
-  String ShowNTPError(byte error) {
-    return thisModem().ShowNTPErrorImpl(error);
-  }
-
   /*
    * CRTP Helper
    */

From 24504071ddd568132d94cff9afd58b481f12d93d Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 21 May 2024 15:49:05 -0400
Subject: [PATCH 071/100] protected template destructors

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmBattery.tpp     |  2 +-
 src/TinyGsmBluetooth.tpp   |  1 +
 src/TinyGsmCalling.tpp     |  1 +
 src/TinyGsmClientSIM70xx.h |  4 +++-
 src/TinyGsmClientSIM7600.h | 17 ++++++++++-------
 src/TinyGsmGPRS.tpp        |  1 +
 src/TinyGsmGPS.tpp         |  2 +-
 src/TinyGsmGSMLocation.tpp |  1 +
 src/TinyGsmModem.tpp       |  1 +
 src/TinyGsmNTP.tpp         |  1 +
 src/TinyGsmSMS.tpp         |  1 +
 src/TinyGsmSSL.tpp         |  1 +
 src/TinyGsmTCP.tpp         |  1 +
 src/TinyGsmTemperature.tpp |  1 +
 src/TinyGsmTime.tpp        |  1 +
 src/TinyGsmWifi.tpp        |  1 +
 16 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/src/TinyGsmBattery.tpp b/src/TinyGsmBattery.tpp
index 401af5a..1979d8d 100644
--- a/src/TinyGsmBattery.tpp
+++ b/src/TinyGsmBattery.tpp
@@ -48,7 +48,7 @@ class TinyGsmBattery {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
-
+  ~TinyGsmBattery() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmBluetooth.tpp b/src/TinyGsmBluetooth.tpp
index 3a300dc..a6164fd 100644
--- a/src/TinyGsmBluetooth.tpp
+++ b/src/TinyGsmBluetooth.tpp
@@ -47,6 +47,7 @@ class TinyGsmBluetooth {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmBluetooth() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmCalling.tpp b/src/TinyGsmCalling.tpp
index c3ed284..8494f04 100644
--- a/src/TinyGsmCalling.tpp
+++ b/src/TinyGsmCalling.tpp
@@ -47,6 +47,7 @@ class TinyGsmCalling {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmCalling() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 605c14c..43fe210 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -60,6 +60,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmSim70xx() {}
 
   /*
    * Constructor
@@ -86,6 +87,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
     res2.trim();
 
     name = res2;
+    DBG("### Modem:", name);
     return name;
   }
 
@@ -381,7 +383,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   /*
    * Time functions
    */
-  // Can follow CCLK as per template
+  // Can follow the standard CCLK function in the template
 
   /*
    * NTP server functions
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 20ee830..0db3f17 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -267,6 +267,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
 
  public:
   String getNetworkModes() {
+    // Get the help string, not the setting value
     sendAT(GF("+CNMP=?"));
     if (waitResponse(GF(AT_NL "+CNMP:")) != 1) { return ""; }
     String res = stream.readStringUntil('\n');
@@ -489,13 +490,15 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
       int   imin         = 0;
       float secondWithSS = 0;
 
-      streamSkipUntil(',');                           // GPS satellite valid numbers
-      streamSkipUntil(',');                           // GLONASS satellite valid numbers
-      streamSkipUntil(',');                           // BEIDOU satellite valid numbers
-      ilat  = streamGetFloatBefore(',');              // Latitude in ddmm.mmmmmm
-      north = stream.readStringUntil(',').charAt(0);  // N/S Indicator, N=north or S=south
-      ilon  = streamGetFloatBefore(',');              // Longitude in ddmm.mmmmmm
-      east  = stream.readStringUntil(',').charAt(0);  // E/W Indicator, E=east or W=west
+      streamSkipUntil(',');               // GPS satellite valid numbers
+      streamSkipUntil(',');               // GLONASS satellite valid numbers
+      streamSkipUntil(',');               // BEIDOU satellite valid numbers
+      ilat  = streamGetFloatBefore(',');  // Latitude in ddmm.mmmmmm
+      north = stream.readStringUntil(',').charAt(
+          0);                            // N/S Indicator, N=north or S=south
+      ilon = streamGetFloatBefore(',');  // Longitude in ddmm.mmmmmm
+      east = stream.readStringUntil(',').charAt(
+          0);  // E/W Indicator, E=east or W=west
 
       // Date. Output format is ddmmyy
       iday   = streamGetIntLength(2);    // Two digit day
diff --git a/src/TinyGsmGPRS.tpp b/src/TinyGsmGPRS.tpp
index 512d696..a657dc2 100644
--- a/src/TinyGsmGPRS.tpp
+++ b/src/TinyGsmGPRS.tpp
@@ -85,6 +85,7 @@ class TinyGsmGPRS {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmGPRS() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmGPS.tpp b/src/TinyGsmGPS.tpp
index 814de6a..2235510 100644
--- a/src/TinyGsmGPS.tpp
+++ b/src/TinyGsmGPS.tpp
@@ -66,7 +66,7 @@ class TinyGsmGPS {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
-
+  ~TinyGsmGPS() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmGSMLocation.tpp b/src/TinyGsmGSMLocation.tpp
index edfde61..c326de4 100644
--- a/src/TinyGsmGSMLocation.tpp
+++ b/src/TinyGsmGSMLocation.tpp
@@ -58,6 +58,7 @@ class TinyGsmGSMLocation {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmGSMLocation() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 9d8d5ce..37da2e3 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -172,6 +172,7 @@ class TinyGsmModem {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmModem() {}
 
   /*
    Utilities
diff --git a/src/TinyGsmNTP.tpp b/src/TinyGsmNTP.tpp
index 3fd8235..f1f4b48 100644
--- a/src/TinyGsmNTP.tpp
+++ b/src/TinyGsmNTP.tpp
@@ -57,6 +57,7 @@ class TinyGsmNTP {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmNTP() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmSMS.tpp b/src/TinyGsmSMS.tpp
index c8960f1..602f471 100644
--- a/src/TinyGsmSMS.tpp
+++ b/src/TinyGsmSMS.tpp
@@ -44,6 +44,7 @@ class TinyGsmSMS {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmSMS() {}
 
   /*
    * Utilities
diff --git a/src/TinyGsmSSL.tpp b/src/TinyGsmSSL.tpp
index d659944..b783803 100644
--- a/src/TinyGsmSSL.tpp
+++ b/src/TinyGsmSSL.tpp
@@ -42,6 +42,7 @@ class TinyGsmSSL {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmSSL() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmTCP.tpp b/src/TinyGsmTCP.tpp
index 7b81fbb..afeafad 100644
--- a/src/TinyGsmTCP.tpp
+++ b/src/TinyGsmTCP.tpp
@@ -66,6 +66,7 @@ class TinyGsmTCP {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmTCP() {}
 
   /*
    * Inner Client
diff --git a/src/TinyGsmTemperature.tpp b/src/TinyGsmTemperature.tpp
index 22a2976..7f0ae0b 100644
--- a/src/TinyGsmTemperature.tpp
+++ b/src/TinyGsmTemperature.tpp
@@ -38,6 +38,7 @@ class TinyGsmTemperature {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmTemperature() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmTime.tpp b/src/TinyGsmTime.tpp
index d9ff9f6..5d2356c 100644
--- a/src/TinyGsmTime.tpp
+++ b/src/TinyGsmTime.tpp
@@ -50,6 +50,7 @@ class TinyGsmTime {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmTime() {}
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmWifi.tpp b/src/TinyGsmWifi.tpp
index 6629442..b53ea35 100644
--- a/src/TinyGsmWifi.tpp
+++ b/src/TinyGsmWifi.tpp
@@ -41,6 +41,7 @@ class TinyGsmWifi {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  ~TinyGsmWifi() {}
 
   /* =========================================== */
   /* =========================================== */

From d8b6d3a801513225d99e1c77913a187316fe86cc Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 21 May 2024 15:49:32 -0400
Subject: [PATCH 072/100] Add fxns for 7080

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSIM7080.h | 34 ++++++++++++++++++++++++++++------
 1 file changed, 28 insertions(+), 6 deletions(-)

diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index 783e8f7..c8d908e 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -183,11 +183,33 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     while (stream.available()) { waitResponse(15, nullptr, nullptr); }
   }
 
+  bool factoryDefaultImpl() {
+    sendAT(GF("&FZE0"));  // Factory + Reset + Echo Off + Write
+    waitResponse();
+    sendAT(GF("+IPR=0"));  // Auto-baud
+    waitResponse();
+    sendAT(GF("+IFC=0,0"));  // No Flow Control
+    waitResponse();
+    sendAT(GF("+ICF=3,3"));  // 8 data 0 parity 1 stop
+    waitResponse();
+    sendAT(GF("+CSCLK=0"));  // Disable Slow Clock
+    return waitResponse() == 1;
+  }
+
   /*
    * Power functions
    */
  protected:
-  // Follows the SIM70xx template
+  bool restartImpl(const char* pin = nullptr) {
+    bool success = true;
+    sendAT(GF("E0"));  // Echo Off
+    waitResponse();
+    sendAT(GF("+CREBOOT"));  // Reboot
+    success &= waitResponse() == 1;
+    waitResponse(30000L, GF("SMS Ready"));
+    success &= initImpl(pin);
+    return success;
+  }
 
   /*
    * Generic network functions
@@ -324,7 +346,8 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
   byte NTPServerSyncImpl(String server = "pool.ntp.org", int TimeZone = 0) {
     // Set GPRS bearer profile to associate with NTP sync
     // this may fail, it's not supported by all modules
-    sendAT(GF("+CNTPCID=0")); // CID must be 0. With 1 (like other modules) does not work!
+    sendAT(GF("+CNTPCID=0"));  // CID must be 0. With 1 (like other modules)
+                               // does not work!
     waitResponse(10000L);
 
     // Set NTP server and timezone
@@ -335,11 +358,10 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     sendAT(GF("+CNTP"));
     if (waitResponse(10000L, GF("+CNTP:"))) {
       String result = stream.readStringUntil('\n');
-      // Check for ',' in case the module appends the time next to the return code. Eg: +CNTP: <code>[,<time>]
+      // Check for ',' in case the module appends the time next to the return
+      // code. Eg: +CNTP: <code>[,<time>]
       int index = result.indexOf(',');
-      if(index > 0) {
-          result.remove(index);
-      }
+      if (index > 0) { result.remove(index); }
       result.trim();
       if (TinyGsmIsValidNumber(result)) { return result.toInt(); }
     } else {

From 9a7c313671938b79807e578359e2734efd3fc193 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 21 May 2024 16:23:55 -0400
Subject: [PATCH 073/100] Another note change

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmNTP.tpp         | 7 +++----
 src/TinyGsmSMS.tpp         | 4 ++++
 src/TinyGsmSSL.tpp         | 1 -
 src/TinyGsmTemperature.tpp | 4 ++++
 src/TinyGsmTime.tpp        | 6 +++---
 5 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/TinyGsmNTP.tpp b/src/TinyGsmNTP.tpp
index f1f4b48..c099412 100644
--- a/src/TinyGsmNTP.tpp
+++ b/src/TinyGsmNTP.tpp
@@ -83,11 +83,10 @@ class TinyGsmNTP {
     thisModem().sendAT(GF("+CNTP"));
     if (thisModem().waitResponse(10000L, GF("+CNTP:"))) {
       String result = thisModem().stream.readStringUntil('\n');
-      // Check for ',' in case the module appends the time next to the return code. Eg: +CNTP: <code>[,<time>]
+      // Check for ',' in case the module appends the time next to the return
+      // code. Eg: +CNTP: <code>[,<time>]
       int index = result.indexOf(',');
-      if(index > 0) {
-          result.remove(index);
-      }
+      if (index > 0) { result.remove(index); }
       result.trim();
       if (TinyGsmIsValidNumber(result)) { return result.toInt(); }
     } else {
diff --git a/src/TinyGsmSMS.tpp b/src/TinyGsmSMS.tpp
index 602f471..2fa92f1 100644
--- a/src/TinyGsmSMS.tpp
+++ b/src/TinyGsmSMS.tpp
@@ -123,6 +123,10 @@ class TinyGsmSMS {
    * Define the default function implementations
    */
 
+  /*
+   * Messaging functions
+   */
+
   String sendUSSDImpl(const String& code) {
     // Set preferred message format to text mode
     thisModem().sendAT(GF("+CMGF=1"));
diff --git a/src/TinyGsmSSL.tpp b/src/TinyGsmSSL.tpp
index b783803..63d5df0 100644
--- a/src/TinyGsmSSL.tpp
+++ b/src/TinyGsmSSL.tpp
@@ -13,7 +13,6 @@
 
 #define TINY_GSM_MODEM_HAS_SSL
 
-
 template <class modemType>
 class TinyGsmSSL {
   /* =========================================== */
diff --git a/src/TinyGsmTemperature.tpp b/src/TinyGsmTemperature.tpp
index 7f0ae0b..aa6b85a 100644
--- a/src/TinyGsmTemperature.tpp
+++ b/src/TinyGsmTemperature.tpp
@@ -46,6 +46,10 @@ class TinyGsmTemperature {
    * Define the default function implementations
    */
 
+  /*
+   * Temperature functions
+   */
+
   float getTemperatureImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
 };
 
diff --git a/src/TinyGsmTime.tpp b/src/TinyGsmTime.tpp
index 5d2356c..e74742c 100644
--- a/src/TinyGsmTime.tpp
+++ b/src/TinyGsmTime.tpp
@@ -34,10 +34,10 @@ class TinyGsmTime {
     return thisModem().getNetworkTimeImpl(year, month, day, hour, minute,
                                           second, timezone);
   }
-  bool getNetworkUTCTime(int* year, int* month, int* day, int* hour, int* minute,
-                      int* second, float* timezone) {
+  bool getNetworkUTCTime(int* year, int* month, int* day, int* hour,
+                         int* minute, int* second, float* timezone) {
     return thisModem().getNetworkUTCTimeImpl(year, month, day, hour, minute,
-                                          second, timezone);
+                                             second, timezone);
   }
 
   /*

From d2ce860c78476a1d274e9bf3df092ad3b65fcaa8 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 22 May 2024 11:34:17 -0400
Subject: [PATCH 074/100] Note changes

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h             |  2 +-
 src/TinyGsmClientA7672x.h         |  2 +-
 src/TinyGsmClientBG96.h           |  8 +++----
 src/TinyGsmClientM590.h           |  4 ++--
 src/TinyGsmClientM95.h            |  8 +++----
 src/TinyGsmClientMC60.h           |  8 +++----
 src/TinyGsmClientSIM5360.h        |  6 +++---
 src/TinyGsmClientSIM7000.h        | 14 ++++++-------
 src/TinyGsmClientSIM7000SSL.h     | 35 +++++++++++++++++++++----------
 src/TinyGsmClientSIM7080.h        | 12 +++++------
 src/TinyGsmClientSIM70xx.h        |  8 +++----
 src/TinyGsmClientSIM7600.h        |  9 ++++----
 src/TinyGsmClientSIM800.h         | 12 +++++------
 src/TinyGsmClientSaraR4.h         |  2 +-
 src/TinyGsmClientSaraR5.h         |  6 +++---
 src/TinyGsmClientSequansMonarch.h |  4 ++--
 src/TinyGsmClientUBLOX.h          |  6 +++---
 src/TinyGsmSSL.tpp                |  4 ++--
 18 files changed, 82 insertions(+), 68 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index d05f02f..ad4b62a 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -391,7 +391,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
   // Note - the clock probably has to be set manaually first
 
   /*
diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index e50b372..478080c 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -335,7 +335,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   }
 
   /*
-   * Secure socket layer functions
+   * Secure socket layer (SSL) functions
    */
  public:
   // The name of the certificate/key/password file. The file name must
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 4b30b18..42de69b 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -260,7 +260,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   }
 
   /*
-   * Secure socket layer functions
+   * Secure socket layer (SSL) functions
    */
  protected:
   bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
@@ -317,13 +317,13 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * Phone Call functions
    */
  protected:
-  // Can follow all of the phone call functions from the template
+  // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM Location functions
@@ -561,7 +561,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * Battery functions
    */
  protected:
-  // Can follow CBC as in the template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * Temperature functions
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index 273621d..bb41192 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -293,7 +293,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
    * SIM card functions
    */
  protected:
-  // Able to follow all SIM card functions as inherited from the template
+  // Able to follow all SIM card functions as inherited from TinyGsmGPRS.tpp
 
   /*
    * Messaging functions
@@ -306,7 +306,7 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 9713af4..903fb16 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -353,13 +353,13 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    * Phone Call functions
    */
  protected:
-  // Can follow all of the phone call functions from the template
+  // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
    * Messaging functions
    */
  protected:
-  // Can follow all template functions
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
  public:
   /** Delete all SMS */
@@ -375,12 +375,12 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * Battery functions
    */
-  // Can follow the battery functions in the template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * Temperature functions
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index 792027c..bf67163 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -336,13 +336,13 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    * Phone Call functions
    */
  protected:
-  // Can follow all of the phone call functions from the template
+  // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
    * Messaging functions
    */
  protected:
-  // Can follow all template functions
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
  public:
   /** Delete all SMS */
@@ -358,12 +358,12 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * Battery functions
    */
-  // Can follow battery functions as in the template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 44539b1..1c12959 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -525,7 +525,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM Location functions
@@ -538,12 +538,12 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
   /*
    * Battery functions
diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index e686e06..ca5ceb0 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -144,7 +144,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
    * Power functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Generic network functions
@@ -252,35 +252,35 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
    * SIM card functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Time functions
    */
-  // Can follow CCLK as per template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
   /*
    * Battery functions
    */
  protected:
-  // Follows all battery functions per template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index dd97032..02daf43 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -19,16 +19,30 @@
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmSSL.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmTime.tpp"
+#include "TinyGsmGSMLocation.tpp"
 
 class TinyGsmSim7000SSL
     : public TinyGsmSim70xx<TinyGsmSim7000SSL>,
       public TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>,
+      public TinyGsmSSL<TinyGsmSim7000SSL>,
+      public TinyGsmSMS<TinyGsmSim7000SSL>,
+      public TinyGsmTime<TinyGsmSim7000SSL>,
       public TinyGsmNTP<TinyGsmSim7000SSL>,
-      public TinyGsmSSL<TinyGsmSim7000SSL> {
+      public TinyGsmBattery<TinyGsmSim7000SSL>,
+      public TinyGsmGSMLocation<TinyGsmSim7000SSL> {
   friend class TinyGsmSim70xx<TinyGsmSim7000SSL>;
   friend class TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmNTP<TinyGsmSim7000SSL>;
   friend class TinyGsmSSL<TinyGsmSim7000SSL>;
+  friend class TinyGsmModem<TinyGsmSim7000SSL>;
+  friend class TinyGsmGPRS<TinyGsmSim7000SSL>;
+  friend class TinyGsmSMS<TinyGsmSim7000SSL>;
+  friend class TinyGsmNTP<TinyGsmSim7000SSL>;
+  friend class TinyGsmTime<TinyGsmSim7000SSL>;
+  friend class TinyGsmBattery<TinyGsmSim7000SSL>;
+  friend class TinyGsmGSMLocation<TinyGsmSim7000SSL>;
+  friend class TinyGsmGPS<TinyGsmSim7000SSL>;
 
   /*
    * Inner Client
@@ -189,7 +203,7 @@ class TinyGsmSim7000SSL
    * Power functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Generic network functions
@@ -205,7 +219,7 @@ class TinyGsmSim7000SSL
   }
 
   /*
-   * Secure socket layer functions
+   * Secure socket layer (SSL) functions
    */
  protected:
   bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
@@ -293,35 +307,35 @@ class TinyGsmSim7000SSL
    * SIM card functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Time functions
    */
-  // Can follow CCLK as per template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
   /*
    * Battery functions
    */
  protected:
-  // Follows all battery functions per template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * Client related functions
@@ -645,7 +659,6 @@ class TinyGsmSim7000SSL
       data = "";
       DBG("### Unexpected module reset!");
       init();
-      data = "";
       return true;
     }
     return false;
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index c8d908e..82d8007 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -225,7 +225,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
   }
 
   /*
-   * Secure socket layer functions
+   * Secure socket layer (SSL) functions
    */
  protected:
   bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
@@ -320,24 +320,24 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
    * SIM card functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
    */
  protected:
-  // Follows the SIM70xx template
+  // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
    * Time functions
    */
-  // Can follow CCLK as per template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * NTP server functions
@@ -386,7 +386,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
    * Battery functions
    */
  protected:
-  // Follows all battery functions per template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 43fe210..7842230 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -266,7 +266,7 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
@@ -383,18 +383,18 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
   /*
    * Time functions
    */
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
   /*
    * Battery functions
    */
  protected:
-  // Follows all battery functions per template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 0db3f17..7fb46b6 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -427,13 +427,14 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM Location functions
    */
  protected:
-  // Can return a GSM-based location from CLBS as per the template
+  // Follows all GSM-based location functions as inherited from
+  // TinyGsmGSMLocation.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
@@ -573,12 +574,12 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
   /*
    * Battery functions
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 710008f..f8d1911 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -425,14 +425,14 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM Location functions
    */
  protected:
   // Depending on the exacty model and firmware revision, should return a
-  // GSM-based location from CLBS as per the template
+  // GSM-based location from CLBS as as inherited from TinyGsmGSMLocation.tpp
   // TODO(?):  Check number of digits in year (2 or 4)
 
   /*
@@ -484,23 +484,23 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
   /*
    * Battery functions
    */
  protected:
-  // Follows all battery functions per template
+  // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
    * NTP server functions
    */
-  // Can sync with server using CNTP as per template
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 603f862..f97dcfa 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -584,7 +584,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * Battery functions
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index 492e0e1..17cc4a9 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -461,13 +461,13 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * Phone Call functions
    */
  protected:
-  // Can follow all of the phone call functions from the template
+  // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
    * Messaging functions
    */
  protected:
-  // Can follow all template functions
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM/GPS/GNSS/GLONASS Location functions
@@ -622,7 +622,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * Battery functions
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 9343b52..47777ee 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -401,13 +401,13 @@ class TinyGsmSequansMonarch
    * Messaging functions
    */
  protected:
-  // Follows all messaging functions per template
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * Temperature functions
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index 5ae3853..145449f 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -413,13 +413,13 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * Phone Call functions
    */
  protected:
-  // Can follow all of the phone call functions from the template
+  // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
    * Messaging functions
    */
  protected:
-  // Can follow all template functions
+  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM/GPS/GNSS/GLONASS Location functions
@@ -583,7 +583,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * Time functions
    */
  protected:
-  // Can follow the standard CCLK function in the template
+  // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
    * Battery functions
diff --git a/src/TinyGsmSSL.tpp b/src/TinyGsmSSL.tpp
index 63d5df0..0bd1327 100644
--- a/src/TinyGsmSSL.tpp
+++ b/src/TinyGsmSSL.tpp
@@ -22,7 +22,7 @@ class TinyGsmSSL {
    */
  public:
   /*
-   * SSL functions
+   * Secure socket layer (SSL) functions
    */
   bool addCertificate(const char* filename) {
     return thisModem().addCertificateImpl(filename);
@@ -50,7 +50,7 @@ class TinyGsmSSL {
    */
 
   /*
-   * SSL functions
+   * Secure socket layer (SSL) functions
    */
  protected:
   bool addCertificateImpl(const char* filename) TINY_GSM_ATTR_NOT_IMPLEMENTED;

From 5a266dda56aa288ca056d0ec3d196aeea17525f5 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 22 May 2024 11:41:53 -0400
Subject: [PATCH 075/100] Moved setCertificates to the SSL template

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA7672x.h         | 16 +++++-----------
 src/TinyGsmClientBG96.h           |  8 +++-----
 src/TinyGsmClientESP8266.h        |  4 ++--
 src/TinyGsmClientSIM7000SSL.h     | 10 +++-------
 src/TinyGsmClientSIM7080.h        |  6 +-----
 src/TinyGsmClientSIM800.h         |  4 ++--
 src/TinyGsmClientSaraR4.h         |  4 ++--
 src/TinyGsmClientSaraR5.h         |  4 ++--
 src/TinyGsmClientSequansMonarch.h |  4 ++--
 src/TinyGsmClientUBLOX.h          |  4 ++--
 src/TinyGsmClientXBee.h           |  4 ++--
 src/TinyGsmSSL.tpp                | 10 +++++++++-
 12 files changed, 35 insertions(+), 43 deletions(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 478080c..c2ca4ff 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -42,7 +42,7 @@ enum A7672xRegStatus {
 class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
                       public TinyGsmGPRS<TinyGsmA7672X>,
                       public TinyGsmTCP<TinyGsmA7672X, TINY_GSM_MUX_COUNT>,
-                      public TinyGsmSSL<TinyGsmA7672X>,
+                      public TinyGsmSSL<TinyGsmA7672X, TINY_GSM_MUX_COUNT>,
                       public TinyGsmCalling<TinyGsmA7672X>,
                       public TinyGsmSMS<TinyGsmA7672X>,
                       public TinyGsmGSMLocation<TinyGsmA7672X>,
@@ -53,7 +53,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   friend class TinyGsmModem<TinyGsmA7672X>;
   friend class TinyGsmGPRS<TinyGsmA7672X>;
   friend class TinyGsmTCP<TinyGsmA7672X, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmA7672X>;
+  friend class TinyGsmSSL<TinyGsmA7672X, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmCalling<TinyGsmA7672X>;
   friend class TinyGsmSMS<TinyGsmA7672X>;
   friend class TinyGsmGSMLocation<TinyGsmA7672X>;
@@ -342,8 +342,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   // havetype like ".pem" or ".der".
   // The certificate like - const char ca_cert[] PROGMEM =  R"EOF(-----BEGIN...
   // len of certificate like - sizeof(ca_cert)
-  bool addCertificate(const String& certificateName, const String& cert,
-                      const uint16_t len) {
+  bool addCertificateImpl(const String& certificateName, const String& cert,
+                          const uint16_t len) {
     sendAT(GF("+CCERTDOWN="), certificateName, GF(","), len);
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(cert.c_str(), len);
@@ -351,13 +351,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return waitResponse() == 1;
   }
 
-  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
-    if (mux >= TINY_GSM_MUX_COUNT) return false;
-    certificates[mux] = certificateName;
-    return true;
-  }
-
-  bool deleteCertificate(const String& certificateName) {  // todo test
+  bool deleteCertificateImpl(const String& certificateName) {  // todo test
     sendAT(GF("+CCERTDELE="), certificateName);
     return waitResponse() == 1;
   }
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 42de69b..6c760d1 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -44,6 +44,7 @@ enum BG96RegStatus {
 class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
                     public TinyGsmGPRS<TinyGsmBG96>,
                     public TinyGsmTCP<TinyGsmBG96, TINY_GSM_MUX_COUNT>,
+                    public TinyGsmSSL<TinyGsmBG96, TINY_GSM_MUX_COUNT>,
                     public TinyGsmCalling<TinyGsmBG96>,
                     public TinyGsmSMS<TinyGsmBG96>,
                     public TinyGsmTime<TinyGsmBG96>,
@@ -54,6 +55,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   friend class TinyGsmModem<TinyGsmBG96>;
   friend class TinyGsmGPRS<TinyGsmBG96>;
   friend class TinyGsmTCP<TinyGsmBG96, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmSSL<TinyGsmBG96, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmCalling<TinyGsmBG96>;
   friend class TinyGsmSMS<TinyGsmBG96>;
   friend class TinyGsmTime<TinyGsmBG96>;
@@ -263,11 +265,7 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
    * Secure socket layer (SSL) functions
    */
  protected:
-  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
-    if (mux >= TINY_GSM_MUX_COUNT) return false;
-    certificates[mux] = certificateName;
-    return true;
-  }
+  // Follows functions as inherited from TinyGsmSSL.tpp
 
   /*
    * GPRS functions
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 0e66e92..bd2cc31 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -46,11 +46,11 @@ enum ESP8266RegStatus {
 class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
                        public TinyGsmWifi<TinyGsmESP8266>,
                        public TinyGsmTCP<TinyGsmESP8266, TINY_GSM_MUX_COUNT>,
-                       public TinyGsmSSL<TinyGsmESP8266> {
+                       public TinyGsmSSL<TinyGsmESP8266, TINY_GSM_MUX_COUNT> {
   friend class TinyGsmModem<TinyGsmESP8266>;
   friend class TinyGsmWifi<TinyGsmESP8266>;
   friend class TinyGsmTCP<TinyGsmESP8266, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmESP8266>;
+  friend class TinyGsmSSL<TinyGsmESP8266, TINY_GSM_MUX_COUNT>;
 
   /*
    * Inner Client
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index 02daf43..cafde4a 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -26,7 +26,7 @@
 class TinyGsmSim7000SSL
     : public TinyGsmSim70xx<TinyGsmSim7000SSL>,
       public TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>,
-      public TinyGsmSSL<TinyGsmSim7000SSL>,
+      public TinyGsmSSL<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>,
       public TinyGsmSMS<TinyGsmSim7000SSL>,
       public TinyGsmTime<TinyGsmSim7000SSL>,
       public TinyGsmNTP<TinyGsmSim7000SSL>,
@@ -34,7 +34,7 @@ class TinyGsmSim7000SSL
       public TinyGsmGSMLocation<TinyGsmSim7000SSL> {
   friend class TinyGsmSim70xx<TinyGsmSim7000SSL>;
   friend class TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmSim7000SSL>;
+  friend class TinyGsmSSL<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmModem<TinyGsmSim7000SSL>;
   friend class TinyGsmGPRS<TinyGsmSim7000SSL>;
   friend class TinyGsmSMS<TinyGsmSim7000SSL>;
@@ -222,11 +222,7 @@ class TinyGsmSim7000SSL
    * Secure socket layer (SSL) functions
    */
  protected:
-  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
-    if (mux >= TINY_GSM_MUX_COUNT) return false;
-    certificates[mux] = certificateName;
-    return true;
-  }
+  // Follows functions as inherited from TinyGsmSSL.tpp
 
   /*
    * GPRS functions
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index 82d8007..249d3ac 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -228,11 +228,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
    * Secure socket layer (SSL) functions
    */
  protected:
-  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
-    if (mux >= TINY_GSM_MUX_COUNT) return false;
-    certificates[mux] = certificateName;
-    return true;
-  }
+  // Follows functions as inherited from TinyGsmSSL.tpp
 
   /*
    * GPRS functions
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index f8d1911..fd9b0f0 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -43,7 +43,7 @@ enum SIM800RegStatus {
 class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
                       public TinyGsmGPRS<TinyGsmSim800>,
                       public TinyGsmTCP<TinyGsmSim800, TINY_GSM_MUX_COUNT>,
-                      public TinyGsmSSL<TinyGsmSim800>,
+                      public TinyGsmSSL<TinyGsmSim800, TINY_GSM_MUX_COUNT>,
                       public TinyGsmCalling<TinyGsmSim800>,
                       public TinyGsmSMS<TinyGsmSim800>,
                       public TinyGsmGSMLocation<TinyGsmSim800>,
@@ -53,7 +53,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
   friend class TinyGsmModem<TinyGsmSim800>;
   friend class TinyGsmGPRS<TinyGsmSim800>;
   friend class TinyGsmTCP<TinyGsmSim800, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmSim800>;
+  friend class TinyGsmSSL<TinyGsmSim800, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmCalling<TinyGsmSim800>;
   friend class TinyGsmSMS<TinyGsmSim800>;
   friend class TinyGsmGSMLocation<TinyGsmSim800>;
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index f97dcfa..382583d 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -43,7 +43,7 @@ enum SaraR4RegStatus {
 class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
                       public TinyGsmGPRS<TinyGsmSaraR4>,
                       public TinyGsmTCP<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>,
-                      public TinyGsmSSL<TinyGsmSaraR4>,
+                      public TinyGsmSSL<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>,
                       public TinyGsmBattery<TinyGsmSaraR4>,
                       public TinyGsmGSMLocation<TinyGsmSaraR4>,
                       public TinyGsmGPS<TinyGsmSaraR4>,
@@ -53,7 +53,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
   friend class TinyGsmModem<TinyGsmSaraR4>;
   friend class TinyGsmGPRS<TinyGsmSaraR4>;
   friend class TinyGsmTCP<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmSaraR4>;
+  friend class TinyGsmSSL<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmBattery<TinyGsmSaraR4>;
   friend class TinyGsmGSMLocation<TinyGsmSaraR4>;
   friend class TinyGsmGPS<TinyGsmSaraR4>;
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index 17cc4a9..5d62b59 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -60,7 +60,7 @@ enum SaraR5RegStatus {
 class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
                       public TinyGsmGPRS<TinyGsmSaraR5>,
                       public TinyGsmTCP<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>,
-                      public TinyGsmSSL<TinyGsmSaraR5>,
+                      public TinyGsmSSL<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>,
                       public TinyGsmCalling<TinyGsmSaraR5>,
                       public TinyGsmSMS<TinyGsmSaraR5>,
                       public TinyGsmGSMLocation<TinyGsmSaraR5>,
@@ -70,7 +70,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
   friend class TinyGsmModem<TinyGsmSaraR5>;
   friend class TinyGsmGPRS<TinyGsmSaraR5>;
   friend class TinyGsmTCP<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmSaraR5>;
+  friend class TinyGsmSSL<TinyGsmSaraR5, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmCalling<TinyGsmSaraR5>;
   friend class TinyGsmSMS<TinyGsmSaraR5>;
   friend class TinyGsmGSMLocation<TinyGsmSaraR5>;
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 47777ee..0d90a57 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -51,7 +51,7 @@ class TinyGsmSequansMonarch
     : public TinyGsmModem<TinyGsmSequansMonarch>,
       public TinyGsmGPRS<TinyGsmSequansMonarch>,
       public TinyGsmTCP<TinyGsmSequansMonarch, TINY_GSM_MUX_COUNT>,
-      public TinyGsmSSL<TinyGsmSequansMonarch>,
+      public TinyGsmSSL<TinyGsmSequansMonarch, TINY_GSM_MUX_COUNT>,
       public TinyGsmCalling<TinyGsmSequansMonarch>,
       public TinyGsmSMS<TinyGsmSequansMonarch>,
       public TinyGsmTime<TinyGsmSequansMonarch>,
@@ -59,7 +59,7 @@ class TinyGsmSequansMonarch
   friend class TinyGsmModem<TinyGsmSequansMonarch>;
   friend class TinyGsmGPRS<TinyGsmSequansMonarch>;
   friend class TinyGsmTCP<TinyGsmSequansMonarch, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmSequansMonarch>;
+  friend class TinyGsmSSL<TinyGsmSequansMonarch, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmCalling<TinyGsmSequansMonarch>;
   friend class TinyGsmSMS<TinyGsmSequansMonarch>;
   friend class TinyGsmTime<TinyGsmSequansMonarch>;
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index 145449f..d90a2ac 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -43,7 +43,7 @@ enum UBLOXRegStatus {
 class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
                      public TinyGsmGPRS<TinyGsmUBLOX>,
                      public TinyGsmTCP<TinyGsmUBLOX, TINY_GSM_MUX_COUNT>,
-                     public TinyGsmSSL<TinyGsmUBLOX>,
+                     public TinyGsmSSL<TinyGsmUBLOX, TINY_GSM_MUX_COUNT>,
                      public TinyGsmCalling<TinyGsmUBLOX>,
                      public TinyGsmSMS<TinyGsmUBLOX>,
                      public TinyGsmGSMLocation<TinyGsmUBLOX>,
@@ -53,7 +53,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
   friend class TinyGsmModem<TinyGsmUBLOX>;
   friend class TinyGsmGPRS<TinyGsmUBLOX>;
   friend class TinyGsmTCP<TinyGsmUBLOX, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmUBLOX>;
+  friend class TinyGsmSSL<TinyGsmUBLOX, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmCalling<TinyGsmUBLOX>;
   friend class TinyGsmSMS<TinyGsmUBLOX>;
   friend class TinyGsmGSMLocation<TinyGsmUBLOX>;
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 7c4dcd8..269de66 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -71,7 +71,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
                     public TinyGsmGPRS<TinyGsmXBee>,
                     public TinyGsmWifi<TinyGsmXBee>,
                     public TinyGsmTCP<TinyGsmXBee, TINY_GSM_MUX_COUNT>,
-                    public TinyGsmSSL<TinyGsmXBee>,
+                    public TinyGsmSSL<TinyGsmXBee, TINY_GSM_MUX_COUNT>,
                     public TinyGsmSMS<TinyGsmXBee>,
                     public TinyGsmBattery<TinyGsmXBee>,
                     public TinyGsmTemperature<TinyGsmXBee> {
@@ -79,7 +79,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
   friend class TinyGsmGPRS<TinyGsmXBee>;
   friend class TinyGsmWifi<TinyGsmXBee>;
   friend class TinyGsmTCP<TinyGsmXBee, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmXBee>;
+  friend class TinyGsmSSL<TinyGsmXBee, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmSMS<TinyGsmXBee>;
   friend class TinyGsmBattery<TinyGsmXBee>;
   friend class TinyGsmTemperature<TinyGsmXBee>;
diff --git a/src/TinyGsmSSL.tpp b/src/TinyGsmSSL.tpp
index 0bd1327..045f4bc 100644
--- a/src/TinyGsmSSL.tpp
+++ b/src/TinyGsmSSL.tpp
@@ -13,7 +13,7 @@
 
 #define TINY_GSM_MODEM_HAS_SSL
 
-template <class modemType>
+template <class modemType, uint8_t muxCount>
 class TinyGsmSSL {
   /* =========================================== */
   /* =========================================== */
@@ -31,6 +31,12 @@ class TinyGsmSSL {
     return thisModem().deleteCertificateImpl();
   }
 
+  bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
+    if (mux >= muxCount) return false;
+    certificates[mux] = certificateName;
+    return true;
+  }
+
   /*
    * CRTP Helper
    */
@@ -55,6 +61,8 @@ class TinyGsmSSL {
  protected:
   bool addCertificateImpl(const char* filename) TINY_GSM_ATTR_NOT_IMPLEMENTED;
   bool deleteCertificateImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+
+  String certificates[muxCount];
 };
 
 #endif  // SRC_TINYGSMSSL_H_

From a1983999ce794bc7b0489c34e3893a6953ba511e Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 22 May 2024 13:51:24 -0400
Subject: [PATCH 076/100] Fix SIM70xx inheritance

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSIM7000.h    | 21 ++++++++++++---
 src/TinyGsmClientSIM7000SSL.h | 17 ++++++------
 src/TinyGsmClientSIM7080.h    | 23 +++++++++++++---
 src/TinyGsmClientSIM70xx.h    | 49 ++++++++---------------------------
 4 files changed, 56 insertions(+), 54 deletions(-)

diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index ca5ceb0..335442f 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -17,14 +17,29 @@
 
 #include "TinyGsmClientSIM70xx.h"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
 
 class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
+                       public TinyGsmTCP<TinyGsmSim7000, TINY_GSM_MUX_COUNT>,
+                       public TinyGsmSMS<TinyGsmSim7000>,
+                       public TinyGsmTime<TinyGsmSim7000>,
                        public TinyGsmNTP<TinyGsmSim7000>,
-                       public TinyGsmTCP<TinyGsmSim7000, TINY_GSM_MUX_COUNT> {
+                       public TinyGsmGSMLocation<TinyGsmSim7000>,
+                       public TinyGsmBattery<TinyGsmSim7000> {
   friend class TinyGsmSim70xx<TinyGsmSim7000>;
-  friend class TinyGsmNTP<TinyGsmSim7000>;
+  friend class TinyGsmModem<TinyGsmSim7000>;
+  friend class TinyGsmGPRS<TinyGsmSim7000>;
   friend class TinyGsmTCP<TinyGsmSim7000, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmSMS<TinyGsmSim7000>;
+  friend class TinyGsmGSMLocation<TinyGsmSim7000>;
+  friend class TinyGsmGPS<TinyGsmSim7000>;
+  friend class TinyGsmTime<TinyGsmSim7000>;
+  friend class TinyGsmNTP<TinyGsmSim7000>;
+  friend class TinyGsmBattery<TinyGsmSim7000>;
 
   /*
    * Inner Client
@@ -87,7 +102,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
   /*
    * Inner Secure Client
    */
-  // NOTE:  Use modem TINYGSMSIM7000SSL for a secure client!
+  // NOTE:  Use modem TinyGsmSim7000SSL for a secure client!
 
   /*
    * Constructor
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index cafde4a..ba299cc 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -18,31 +18,32 @@
 #include "TinyGsmClientSIM70xx.h"
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmSSL.tpp"
-#include "TinyGsmNTP.tpp"
 #include "TinyGsmSMS.tpp"
-#include "TinyGsmTime.tpp"
 #include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmTime.tpp"
+#include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
 
 class TinyGsmSim7000SSL
     : public TinyGsmSim70xx<TinyGsmSim7000SSL>,
       public TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>,
       public TinyGsmSSL<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>,
       public TinyGsmSMS<TinyGsmSim7000SSL>,
+      public TinyGsmGSMLocation<TinyGsmSim7000SSL>,
       public TinyGsmTime<TinyGsmSim7000SSL>,
       public TinyGsmNTP<TinyGsmSim7000SSL>,
-      public TinyGsmBattery<TinyGsmSim7000SSL>,
-      public TinyGsmGSMLocation<TinyGsmSim7000SSL> {
+      public TinyGsmBattery<TinyGsmSim7000SSL> {
   friend class TinyGsmSim70xx<TinyGsmSim7000SSL>;
   friend class TinyGsmTCP<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmSSL<TinyGsmSim7000SSL, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmModem<TinyGsmSim7000SSL>;
   friend class TinyGsmGPRS<TinyGsmSim7000SSL>;
   friend class TinyGsmSMS<TinyGsmSim7000SSL>;
+  friend class TinyGsmGSMLocation<TinyGsmSim7000SSL>;
+  friend class TinyGsmGPS<TinyGsmSim7000SSL>;
   friend class TinyGsmNTP<TinyGsmSim7000SSL>;
   friend class TinyGsmTime<TinyGsmSim7000SSL>;
   friend class TinyGsmBattery<TinyGsmSim7000SSL>;
-  friend class TinyGsmGSMLocation<TinyGsmSim7000SSL>;
-  friend class TinyGsmGPS<TinyGsmSim7000SSL>;
 
   /*
    * Inner Client
@@ -135,8 +136,7 @@ class TinyGsmSim7000SSL
    */
  public:
   explicit TinyGsmSim7000SSL(Stream& stream)
-      : TinyGsmSim70xx<TinyGsmSim7000SSL>(stream),
-        certificates() {
+      : TinyGsmSim70xx<TinyGsmSim7000SSL>(stream) {
     memset(sockets, 0, sizeof(sockets));
   }
 
@@ -662,7 +662,6 @@ class TinyGsmSim7000SSL
 
  protected:
   GsmClientSim7000SSL* sockets[TINY_GSM_MUX_COUNT];
-  String               certificates[TINY_GSM_MUX_COUNT];
 };
 
 #endif  // SRC_TINYGSMCLIENTSIM7000SSL_H_
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index 249d3ac..38418b8 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -18,16 +18,31 @@
 #include "TinyGsmClientSIM70xx.h"
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmSSL.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
 
 class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
-                       public TinyGsmNTP<TinyGsmSim7080>,
                        public TinyGsmTCP<TinyGsmSim7080, TINY_GSM_MUX_COUNT>,
-                       public TinyGsmSSL<TinyGsmSim7080> {
+                       public TinyGsmSSL<TinyGsmSim7080, TINY_GSM_MUX_COUNT>,
+                       public TinyGsmSMS<TinyGsmSim7080>,
+                       public TinyGsmGSMLocation<TinyGsmSim7080>,
+                       public TinyGsmTime<TinyGsmSim7080>,
+                       public TinyGsmNTP<TinyGsmSim7080>,
+                       public TinyGsmBattery<TinyGsmSim7080> {
   friend class TinyGsmSim70xx<TinyGsmSim7080>;
-  friend class TinyGsmNTP<TinyGsmSim7080>;
+  friend class TinyGsmModem<TinyGsmSim7080>;
+  friend class TinyGsmGPRS<TinyGsmSim7080>;
   friend class TinyGsmTCP<TinyGsmSim7080, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmSSL<TinyGsmSim7080>;
+  friend class TinyGsmSSL<TinyGsmSim7080, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmSMS<TinyGsmSim7080>;
+  friend class TinyGsmGSMLocation<TinyGsmSim7080>;
+  friend class TinyGsmGPS<TinyGsmSim7080>;
+  friend class TinyGsmTime<TinyGsmSim7080>;
+  friend class TinyGsmNTP<TinyGsmSim7080>;
+  friend class TinyGsmBattery<TinyGsmSim7080>;
 
   /*
    * Inner Client
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 7842230..526599e 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -20,9 +20,6 @@
 #include "TinyGsmGPRS.tpp"
 #include "TinyGsmGPS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmTime.tpp"
-#include "TinyGsmGSMLocation.tpp"
 
 enum SIM70xxRegStatus {
   REG_NO_RESULT    = -1,
@@ -34,31 +31,23 @@ enum SIM70xxRegStatus {
   REG_UNKNOWN      = 4,
 };
 
-template <class modemType>
-class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
-                       public TinyGsmGPRS<TinyGsmSim70xx<modemType>>,
-                       public TinyGsmSMS<TinyGsmSim70xx<modemType>>,
-                       public TinyGsmGPS<TinyGsmSim70xx<modemType>>,
-                       public TinyGsmTime<TinyGsmSim70xx<modemType>>,
-                       public TinyGsmBattery<TinyGsmSim70xx<modemType>>,
-                       public TinyGsmGSMLocation<TinyGsmSim70xx<modemType>> {
-  friend class TinyGsmModem<TinyGsmSim70xx<modemType>>;
-  friend class TinyGsmGPRS<TinyGsmSim70xx<modemType>>;
-  friend class TinyGsmSMS<TinyGsmSim70xx<modemType>>;
-  friend class TinyGsmGPS<TinyGsmSim70xx<modemType>>;
-  friend class TinyGsmTime<TinyGsmSim70xx<modemType>>;
-  friend class TinyGsmBattery<TinyGsmSim70xx<modemType>>;
-  friend class TinyGsmGSMLocation<TinyGsmSim70xx<modemType>>;
+template <class SIM70xxType>
+class TinyGsmSim70xx : public TinyGsmModem<SIM70xxType>,
+                       public TinyGsmGPRS<SIM70xxType>,
+                       public TinyGsmGPS<SIM70xxType> {
+  friend class TinyGsmModem<SIM70xxType>;
+  friend class TinyGsmGPRS<SIM70xxType>;
+  friend class TinyGsmGPS<SIM70xxType>;
 
   /*
    * CRTP Helper
    */
  protected:
-  inline const modemType& thisModem() const {
-    return static_cast<const modemType&>(*this);
+  inline const SIM70xxType& thisModem() const {
+    return static_cast<const SIM70xxType&>(*this);
   }
-  inline modemType& thisModem() {
-    return static_cast<modemType&>(*this);
+  inline SIM70xxType& thisModem() {
+    return static_cast<SIM70xxType&>(*this);
   }
   ~TinyGsmSim70xx() {}
 
@@ -72,10 +61,6 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
    * Basic functions
    */
  protected:
-  bool initImpl(const char* pin = nullptr) {
-    return thisModem().initImpl(pin);
-  }
-
   String getModemNameImpl() {
     String name = "SIMCom SIM7000";
 
@@ -230,23 +215,11 @@ class TinyGsmSim70xx : public TinyGsmModem<TinyGsmSim70xx<modemType>>,
     return thisModem().waitResponse() == 1;
   }
 
-  String getLocalIPImpl() {
-    return thisModem().getLocalIPImpl();
-  }
-
   /*
    * GPRS functions
    */
  protected:
   // should implement in sub-classes
-  bool gprsConnectImpl(const char* apn, const char* user = nullptr,
-                       const char* pwd = nullptr) {
-    return thisModem().gprsConnectImpl(apn, user, pwd);
-  }
-
-  bool gprsDisconnectImpl() {
-    return thisModem().gprsDisconnectImpl();
-  }
 
   /*
    * SIM card functions

From c2c64aec9d50df3aca4729bcd56e43afb1522cb0 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 22 May 2024 13:59:42 -0400
Subject: [PATCH 077/100] Rearrange includes, add empty blocks for unsupported

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h             |  47 ++++++++++--
 src/TinyGsmClientA7672x.h         |  99 +++++++++++++-----------
 src/TinyGsmClientBG96.h           |  39 ++++++----
 src/TinyGsmClientESP8266.h        |  70 ++++++++++++++++-
 src/TinyGsmClientM590.h           |  72 +++++++++++++++++-
 src/TinyGsmClientM95.h            |  86 +++++++++++++--------
 src/TinyGsmClientMC60.h           |  89 ++++++++++++++--------
 src/TinyGsmClientSIM5360.h        | 122 +++++++++++++++---------------
 src/TinyGsmClientSIM7000.h        |  45 +++++++++--
 src/TinyGsmClientSIM7000SSL.h     |  43 ++++++++---
 src/TinyGsmClientSIM7080.h        |  51 +++++++++----
 src/TinyGsmClientSIM70xx.h        |  30 +-------
 src/TinyGsmClientSIM7600.h        |  65 ++++++++--------
 src/TinyGsmClientSIM800.h         |  71 +++++++++--------
 src/TinyGsmClientSaraR4.h         |  71 +++++++++++++----
 src/TinyGsmClientSaraR5.h         |  21 +++--
 src/TinyGsmClientSequansMonarch.h |  69 ++++++++++++++---
 src/TinyGsmClientUBLOX.h          |  48 ++++++++----
 src/TinyGsmClientXBee.h           |  59 ++++++++++++---
 src/TinyGsmSMS.tpp                |   4 +-
 20 files changed, 816 insertions(+), 385 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index ad4b62a..181bb1a 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -19,13 +19,13 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
 #include "TinyGsmTime.tpp"
+#include "TinyGsmBattery.tpp"
 
 enum A6RegStatus {
   REG_NO_RESULT    = -1,
@@ -228,6 +228,17 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+ protected:
+  // No functions of this type supported
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -362,7 +373,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
   }
 
   /*
-   * Messaging functions
+   * Text messaging (SMS) functions
    */
  protected:
   String sendUSSDImpl(const String& code) {
@@ -387,13 +398,32 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     }
   }
 
+  /*
+   * GSM Location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
+
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
   // Note - the clock probably has to be set manaually first
 
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
@@ -425,6 +455,11 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     return true;
   }
 
+  /*
+   * Temperature functions
+   */
+  // No functions of this type supported
+
   /*
    * Client related functions
    */
diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index c2ca4ff..ca1dd7d 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -18,16 +18,16 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
 #include "TinyGsmTemperature.tpp"
 
 enum A7672xRegStatus {
@@ -238,30 +238,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return waitResponse() == 1;
   }
 
-  /*
-   * SIM card functions
-   */
- protected:
-  SimStatus getSimStatusImpl(uint32_t timeout_ms = 10000L) {
-    for (uint32_t start = millis(); millis() - start < timeout_ms;) {
-      sendAT(GF("+CPIN?"));
-      if (waitResponse(GF("+CPIN:")) != 1) {
-        delay(1000);
-        continue;
-      }
-      int8_t status = waitResponse(GF("READY"), GF("SIM PIN"), GF("SIM PUK"),
-                                   GF("SIM not inserted"), GF("SIM REMOVED"));
-      waitResponse();
-      switch (status) {
-        case 2:
-        case 3: return SIM_LOCKED;
-        case 1: return SIM_READY;
-        default: return SIM_ERROR;
-      }
-    }
-    return SIM_ERROR;
-  }
-
   /*
    * Power functions
    */
@@ -356,6 +332,11 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return waitResponse() == 1;
   }
 
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -406,6 +387,26 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
    * SIM card functions
    */
  protected:
+  SimStatus getSimStatusImpl(uint32_t timeout_ms = 10000L) {
+    for (uint32_t start = millis(); millis() - start < timeout_ms;) {
+      sendAT(GF("+CPIN?"));
+      if (waitResponse(GF("+CPIN:")) != 1) {
+        delay(1000);
+        continue;
+      }
+      int8_t status = waitResponse(GF("READY"), GF("SIM PIN"), GF("SIM PUK"),
+                                   GF("SIM not inserted"), GF("SIM REMOVED"));
+      waitResponse();
+      switch (status) {
+        case 2:
+        case 3: return SIM_LOCKED;
+        case 1: return SIM_READY;
+        default: return SIM_ERROR;
+      }
+    }
+    return SIM_ERROR;
+  }
+
   String getSimCCIDImpl() {
     sendAT(GF("+CICCID"));
     if (waitResponse(GF(AT_NL "+ICCID:")) != 1) { return ""; }
@@ -425,33 +426,43 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   }
 
   /*
-   * GSM Location functions //todo:
+   * Audio functions
    */
- protected:
+  // No functions of this type supported
+
   /*
-   * GPS/GNSS/GLONASS location functions //todo:
+   * Text messaging (SMS) functions
    */
- protected:
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
+
   /*
-   * Audio functions //todo:
+   * GSM Location functions
    */
- protected:
+  // No functions of this type supported
   /*
-   * Time functions //todo:
+   * GPS/GNSS/GLONASS location functions
    */
- protected:
+  // No functions of this type supported
+
   /*
-   * NTP server functions //todo:
+   * Time functions
    */
- protected:
+  // No functions of this type supported
   /*
-   * BLE functions //todo:
+   * NTP server functions
    */
- protected:
+  // No functions of this type supported
+
   /*
-   * Battery functions //todo:
+   * BLE functions
    */
- protected:
+  // No functions of this type supported
+
+  /*
+   * Battery functions
+   */
+  // No functions of this type supported
+
   /*
    * Temperature functions
    */
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 6c760d1..5ad208c 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -19,17 +19,17 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGPS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
 #include "TinyGsmSSL.tpp"
-#include "TinyGsmTemperature.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGPS.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmTemperature.tpp"
 
 enum BG96RegStatus {
   REG_NO_RESULT    = -1,
@@ -47,9 +47,9 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
                     public TinyGsmSSL<TinyGsmBG96, TINY_GSM_MUX_COUNT>,
                     public TinyGsmCalling<TinyGsmBG96>,
                     public TinyGsmSMS<TinyGsmBG96>,
+                    public TinyGsmGPS<TinyGsmBG96>,
                     public TinyGsmTime<TinyGsmBG96>,
                     public TinyGsmNTP<TinyGsmBG96>,
-                    public TinyGsmGPS<TinyGsmBG96>,
                     public TinyGsmBattery<TinyGsmBG96>,
                     public TinyGsmTemperature<TinyGsmBG96> {
   friend class TinyGsmModem<TinyGsmBG96>;
@@ -58,9 +58,9 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   friend class TinyGsmSSL<TinyGsmBG96, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmCalling<TinyGsmBG96>;
   friend class TinyGsmSMS<TinyGsmBG96>;
+  friend class TinyGsmGPS<TinyGsmBG96>;
   friend class TinyGsmTime<TinyGsmBG96>;
   friend class TinyGsmNTP<TinyGsmBG96>;
-  friend class TinyGsmGPS<TinyGsmBG96>;
   friend class TinyGsmBattery<TinyGsmBG96>;
   friend class TinyGsmTemperature<TinyGsmBG96>;
 
@@ -264,9 +264,13 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   /*
    * Secure socket layer (SSL) functions
    */
- protected:
   // Follows functions as inherited from TinyGsmSSL.tpp
 
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -314,14 +318,17 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
   /*
    * Phone Call functions
    */
- protected:
   // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
-   * Messaging functions
+   * Audio functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM Location functions
@@ -555,10 +562,14 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
 
   String ShowNTPErrorImpl(byte error) TINY_GSM_ATTR_NOT_IMPLEMENTED;
 
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
- protected:
   // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index bd2cc31..24b37cc 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -20,8 +20,8 @@
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
 #include "TinyGsmWifi.tpp"
 
 static uint8_t TINY_GSM_TCP_KEEP_ALIVE = 120;
@@ -44,13 +44,13 @@ enum ESP8266RegStatus {
 };
 
 class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
-                       public TinyGsmWifi<TinyGsmESP8266>,
                        public TinyGsmTCP<TinyGsmESP8266, TINY_GSM_MUX_COUNT>,
-                       public TinyGsmSSL<TinyGsmESP8266, TINY_GSM_MUX_COUNT> {
+                       public TinyGsmSSL<TinyGsmESP8266, TINY_GSM_MUX_COUNT>,
+                       public TinyGsmWifi<TinyGsmESP8266> {
   friend class TinyGsmModem<TinyGsmESP8266>;
-  friend class TinyGsmWifi<TinyGsmESP8266>;
   friend class TinyGsmTCP<TinyGsmESP8266, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmSSL<TinyGsmESP8266, TINY_GSM_MUX_COUNT>;
+  friend class TinyGsmWifi<TinyGsmESP8266>;
 
   /*
    * Inner Client
@@ -315,6 +315,12 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     return res2;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // Follows functions as inherited from TinyGsmSSL.tpp
+
+
   /*
    * WiFi functions
    */
@@ -340,6 +346,62 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     return retVal;
   }
 
+
+  /*
+   * GPRS functions
+   */
+  // No functions of this type supported
+
+  /*
+   * SIM card functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GSM Location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Time functions
+   */
+  // No functions of this type supported
+
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Battery functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Temperature functions
+   */
+  // No functions of this type supported
+
   /*
    * Client related functions
    */
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index bb41192..33cd777 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -19,10 +19,10 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmSMS.tpp"
 #include "TinyGsmTime.tpp"
 
 enum M590RegStatus {
@@ -102,6 +102,11 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
     String remoteIP() TINY_GSM_ATTR_NOT_IMPLEMENTED;
   };
 
+  /*
+   * Inner Secure Client
+   */
+  // NOT SUPPORTED
+
   /*
    * Constructor
    */
@@ -233,6 +238,16 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // No functions of this type supported
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -295,18 +310,67 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
  protected:
   // Able to follow all SIM card functions as inherited from TinyGsmGPRS.tpp
 
+
   /*
-   * Messaging functions
+   * Phone Call functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
    */
  protected:
   bool sendSMS_UTF16Impl(const String& number, const void* text,
                          size_t len) TINY_GSM_ATTR_NOT_AVAILABLE;
 
+  /*
+   * GSM Location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
+
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
+  /*
+   * NTP server functions
+   */
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Battery functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Temperature functions
+   */
+  // No functions of this type supported
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 903fb16..130d956 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -20,14 +20,14 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
-#include "TinyGsmTemperature.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
 #include "TinyGsmTime.tpp"
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmTemperature.tpp"
 
 enum M95RegStatus {
   REG_NO_RESULT    = -1,
@@ -117,29 +117,7 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
   /*
    * Inner Secure Client
    */
-
-  /*
-    class GsmClientSecureM95 : public GsmClientM95
-    {
-    public:
-      GsmClientSecure() {}
-
-      GsmClientSecure(TinyGsmm95& modem, uint8_t mux = 0)
-       : GsmClient(modem, mux)
-      {}
-
-
-    public:
-      int connect(const char* host, uint16_t port, int timeout_s) override {
-        stop();
-        TINY_GSM_YIELD();
-        rx.clear();
-        sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
-        return sock_connected;
-      }
-      TINY_GSM_CLIENT_CONNECT_OVERRIDES
-    };
-  */
+  // NOT SUPPORTED
 
   /*
    * Constructor
@@ -257,6 +235,16 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // No functions of this type supported
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -352,14 +340,17 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
   /*
    * Phone Call functions
    */
- protected:
   // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
+
   /*
-   * Messaging functions
+   * Audio functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
 
  public:
   /** Delete all SMS */
@@ -371,12 +362,41 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
     return false;
   }
 
+  /*
+   * GSM Location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
+
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
+  /*
+   * NTP server functions
+   */
+  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index bf67163..5c869b6 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -22,13 +22,13 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
 #include "TinyGsmTime.tpp"
+#include "TinyGsmBattery.tpp"
 
 enum MC60RegStatus {
   REG_NO_RESULT    = -1,
@@ -116,29 +116,7 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
   /*
    * Inner Secure Client
    */
-
-  /*
-    class GsmClientSecureMC60 : public GsmClientMC60
-    {
-    public:
-      GsmClientSecure() {}
-
-      GsmClientSecure(TinyGsmMC60& modem, uint8_t mux = 0)
-       : GsmClient(modem, mux)
-      {}
-
-
-    public:
-      int connect(const char* host, uint16_t port, int timeout_s) override {
-        stop();
-        TINY_GSM_YIELD();
-        rx.clear();
-        sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
-        return sock_connected;
-      }
-      TINY_GSM_CLIENT_CONNECT_OVERRIDES
-    };
- */
+  // NOT SUPPORTED
 
   /*
    * Constructor
@@ -243,6 +221,16 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // No functions of this type supported
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -335,14 +323,17 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
   /*
    * Phone Call functions
    */
- protected:
   // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
-   * Messaging functions
+   * Audio functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
 
  public:
   /** Delete all SMS */
@@ -354,17 +345,51 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
     return false;
   }
 
+  /*
+   * GSM Location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
+
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
   // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
+  /*
+   * Temperature functions
+   */
+  // No functions of this type supported
+
   /*
    * Client related functions
    */
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 1c12959..cb397d6 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -19,16 +19,16 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGPS.tpp"
-#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
-#include "TinyGsmTemperature.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmGPS.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmTemperature.tpp"
 
 enum SIM5360RegStatus {
   REG_NO_RESULT    = -1,
@@ -44,20 +44,20 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
                        public TinyGsmGPRS<TinyGsmSim5360>,
                        public TinyGsmTCP<TinyGsmSim5360, TINY_GSM_MUX_COUNT>,
                        public TinyGsmSMS<TinyGsmSim5360>,
-                       public TinyGsmTime<TinyGsmSim5360>,
-                       public TinyGsmNTP<TinyGsmSim5360>,
                        public TinyGsmGSMLocation<TinyGsmSim5360>,
                        public TinyGsmGPS<TinyGsmSim5360>,
+                       public TinyGsmTime<TinyGsmSim5360>,
+                       public TinyGsmNTP<TinyGsmSim5360>,
                        public TinyGsmBattery<TinyGsmSim5360>,
                        public TinyGsmTemperature<TinyGsmSim5360> {
   friend class TinyGsmModem<TinyGsmSim5360>;
   friend class TinyGsmGPRS<TinyGsmSim5360>;
   friend class TinyGsmTCP<TinyGsmSim5360, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmSMS<TinyGsmSim5360>;
-  friend class TinyGsmTime<TinyGsmSim5360>;
-  friend class TinyGsmNTP<TinyGsmSim5360>;
   friend class TinyGsmGSMLocation<TinyGsmSim5360>;
   friend class TinyGsmGPS<TinyGsmSim5360>;
+  friend class TinyGsmTime<TinyGsmSim5360>;
+  friend class TinyGsmNTP<TinyGsmSim5360>;
   friend class TinyGsmBattery<TinyGsmSim5360>;
   friend class TinyGsmTemperature<TinyGsmSim5360>;
 
@@ -122,27 +122,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   /*
    * Inner Secure Client
    */
-
-  // TODO(?): Add SSL support
-  /*
-  class GsmClientSecureSim5360 : public GsmClientSim5360 {
-   public:
-    GsmClientSecureSim5360() {}
-
-    explicit GsmClientSecureSim5360(TinyGsmSim5360& modem, uint8_t mux = 0)
-      : GsmClientSim5360(modem, mux) {}
-
-   public:
-    int connect(const char* host, uint16_t port, int timeout_s) override {
-      stop();
-      TINY_GSM_YIELD();
-      rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
-      return sock_connected;
-    }
-    TINY_GSM_CLIENT_CONNECT_OVERRIDES
-  };
-  */
+  // NOT SUPPORTED
 
   /*
    * Constructor
@@ -296,6 +276,16 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // No functions of this type supported
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -410,7 +400,42 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   }
 
   /*
-   * GPS location functions
+   * SIM card functions
+   */
+ protected:
+  // Gets the CCID of a sim card via AT+CCID
+  String getSimCCIDImpl() {
+    sendAT(GF("+CICCID"));
+    if (waitResponse(GF(AT_NL "+ICCID:")) != 1) { return ""; }
+    String res = stream.readStringUntil('\n');
+    waitResponse();
+    res.trim();
+    return res;
+  }
+
+  /*
+   * Phone Call functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
+
+  /*
+   * GSM Location functions
+   */
+  // SIM5360 and SIM7100 can return a GSM-based location from CLBS as per the
+  // template; SIM5320 doesn't not appear to be able to
+
+  /*
+   * GPS/GNSS/GLONASS location functions
    */
  protected:
   // enable GPS
@@ -507,37 +532,9 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     return false;
   }
 
-  /*
-   * SIM card functions
-   */
- protected:
-  // Gets the CCID of a sim card via AT+CCID
-  String getSimCCIDImpl() {
-    sendAT(GF("+CICCID"));
-    if (waitResponse(GF(AT_NL "+ICCID:")) != 1) { return ""; }
-    String res = stream.readStringUntil('\n');
-    waitResponse();
-    res.trim();
-    return res;
-  }
-
-  /*
-   * Messaging functions
-   */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
-
-  /*
-   * GSM Location functions
-   */
- protected:
-  // SIM5360 and SIM7100 can return a GSM-based location from CLBS as per the
-  // template; SIM5320 doesn't not appear to be able to
-
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
@@ -545,6 +542,11 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    */
   // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index 335442f..33c4841 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -158,7 +158,6 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
   /*
    * Power functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
@@ -175,6 +174,16 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // NOTE:  Use modem TinyGsmSim7000SSL for a secure client!
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -266,19 +275,32 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
   /*
    * SIM card functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
-   * Messaging functions
+   * Phone Call functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
+
+  /*
+   * GSM Location functions
+   */
+  // Follows all GSM-based location functions as inherited from
+  // TinyGsmGSMLocation.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
@@ -291,12 +313,21 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
    */
   // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
- protected:
   // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
+  /*
+   * Temperature functions
+   */
+  // No functions of this type supported
+
   /*
    * Client related functions
    */
diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index ba299cc..0140e12 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -106,7 +106,7 @@ class TinyGsmSim7000SSL
   /*
    * Inner Secure Client
    */
-
+ public:
   class GsmClientSecureSIM7000SSL : public GsmClientSim7000SSL {
    public:
     GsmClientSecureSIM7000SSL() {}
@@ -115,7 +115,6 @@ class TinyGsmSim7000SSL
                                        uint8_t            mux = 0)
         : GsmClientSim7000SSL(modem, mux) {}
 
-   public:
     bool setCertificate(const String& certificateName) {
       return at->setCertificate(certificateName, mux);
     }
@@ -202,7 +201,6 @@ class TinyGsmSim7000SSL
   /*
    * Power functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
@@ -221,9 +219,13 @@ class TinyGsmSim7000SSL
   /*
    * Secure socket layer (SSL) functions
    */
- protected:
   // Follows functions as inherited from TinyGsmSSL.tpp
 
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -302,19 +304,31 @@ class TinyGsmSim7000SSL
   /*
    * SIM card functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
-   * Messaging functions
+   * Phone Call functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
+  /*
+   * GSM Location functions
+   */
+  // Follows all GSM-based location functions as inherited from
+  // TinyGsmGSMLocation.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
@@ -327,12 +341,21 @@ class TinyGsmSim7000SSL
    */
   // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
- protected:
   // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
+  /*
+   * Temperature functions
+   */
+  // No functions of this type supported
+
   /*
    * Client related functions
    */
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index 38418b8..f798385 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -105,7 +105,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
   /*
    * Inner Secure Client
    */
-
+ public:
   class GsmClientSecureSIM7080 : public GsmClientSim7080 {
    public:
     GsmClientSecureSIM7080() {}
@@ -113,13 +113,11 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     explicit GsmClientSecureSIM7080(TinyGsmSim7080& modem, uint8_t mux = 0)
         : GsmClientSim7080(modem, mux) {}
 
-   public:
     bool setCertificate(const String& certificateName) {
       return at->setCertificate(certificateName, mux);
     }
 
-    virtual int connect(const char* host, uint16_t port,
-                        int timeout_s) override {
+    int connect(const char* host, uint16_t port, int timeout_s) override {
       stop();
       TINY_GSM_YIELD();
       rx.clear();
@@ -134,8 +132,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
    */
  public:
   explicit TinyGsmSim7080(Stream& stream)
-      : TinyGsmSim70xx<TinyGsmSim7080>(stream),
-        certificates() {
+      : TinyGsmSim70xx<TinyGsmSim7080>(stream) {
     memset(sockets, 0, sizeof(sockets));
   }
 
@@ -242,9 +239,13 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
   /*
    * Secure socket layer (SSL) functions
    */
- protected:
   // Follows functions as inherited from TinyGsmSSL.tpp
 
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -330,19 +331,32 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
   /*
    * SIM card functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
-   * Messaging functions
+   * Phone Call functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
+
+  /*
+   * GSM Location functions
+   */
+  // Follows all GSM-based location functions as inherited from
+  // TinyGsmGSMLocation.tpp
 
   /*
    * GPS/GNSS/GLONASS location functions
    */
- protected:
   // Follows functions as inherited from TinyGsmClientSIM70xx.h
 
   /*
@@ -353,7 +367,7 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
   /*
    * NTP server functions
    */
-
+ protected:
   byte NTPServerSyncImpl(String server = "pool.ntp.org", int TimeZone = 0) {
     // Set GPRS bearer profile to associate with NTP sync
     // this may fail, it's not supported by all modules
@@ -393,12 +407,21 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     }
   }
 
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
- protected:
   // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
+  /*
+   * Temperature functions
+   */
+  // No functions of this type supported
+
   /*
    * Client related functions
    */
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index 526599e..e4f3dca 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -16,10 +16,9 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
+#include "TinyGsmModem.tpp"
 #include "TinyGsmGPRS.tpp"
 #include "TinyGsmGPS.tpp"
-#include "TinyGsmModem.tpp"
 
 enum SIM70xxRegStatus {
   REG_NO_RESULT    = -1,
@@ -235,12 +234,6 @@ class TinyGsmSim70xx : public TinyGsmModem<SIM70xxType>,
     return res;
   }
 
-  /*
-   * Messaging functions
-   */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
-
   /*
    * GPS/GNSS/GLONASS location functions
    */
@@ -352,27 +345,6 @@ class TinyGsmSim70xx : public TinyGsmModem<SIM70xxType>,
     thisModem().waitResponse();
     return false;
   }
-
-  /*
-   * Time functions
-   */
-  // Follows all clock functions as inherited from TinyGsmTime.tpp
-
-  /*
-   * NTP server functions
-   */
-  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
-
-  /*
-   * Battery functions
-   */
- protected:
-  // Follows all battery functions as inherited from TinyGsmBattery.tpp
-
-  /*
-   * Client related functions
-   */
-  // should implement in sub-classes
   bool handleURCs(String& data) {
     return thisModem().handleURCs(data);
   }
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 7fb46b6..217a312 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -19,17 +19,17 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGPS.tpp"
-#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
 #include "TinyGsmTCP.tpp"
-#include "TinyGsmTemperature.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmGPS.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmTemperature.tpp"
 
 
 enum SIM7600RegStatus {
@@ -126,28 +126,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   /*
    * Inner Secure Client
    */
-
-  /*TODO(?))
-  class GsmClientSecureSIM7600 : public GsmClientSim7600
-  {
-  public:
-    GsmClientSecure() {}
-
-    GsmClientSecure(TinyGsmSim7600& modem, uint8_t mux = 0)
-     : public GsmClient(modem, mux)
-    {}
-
-  public:
-    int connect(const char* host, uint16_t port, int timeout_s) override {
-      stop();
-      TINY_GSM_YIELD();
-      rx.clear();
-      sock_connected = at->modemConnect(host, port, mux, true, timeout_s);
-      return sock_connected;
-    }
-    TINY_GSM_CLIENT_CONNECT_OVERRIDES
-  };
-  */
+  // NOT SUPPORTED
 
   /*
    * Constructor
@@ -310,6 +289,16 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // No functions of this type supported
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -424,15 +413,18 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   }
 
   /*
-   * Messaging functions
+   * Audio functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  //  No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM Location functions
    */
- protected:
   // Follows all GSM-based location functions as inherited from
   // TinyGsmGSMLocation.tpp
 
@@ -547,7 +539,6 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     return false;
   }
 
-
   /**
    *  CGNSSMODE: <gnss_mode>,<dpo_mode>
    *  This command is used to configure GPS, GLONASS, BEIDOU and QZSS support
@@ -573,7 +564,6 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
@@ -581,6 +571,11 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    */
   // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index fd9b0f0..3fac243 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -20,16 +20,16 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmTime.tpp"
 #include "TinyGsmNTP.tpp"
+#include "TinyGsmBattery.tpp"
 
 enum SIM800RegStatus {
   REG_NO_RESULT    = -1,
@@ -130,7 +130,6 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     explicit GsmClientSecureSim800(TinyGsmSim800& modem, uint8_t mux = 0)
         : GsmClientSim800(modem, mux) {}
 
-   public:
     int connect(const char* host, uint16_t port, int timeout_s) override {
       stop();
       TINY_GSM_YIELD();
@@ -306,6 +305,16 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // Follows functions as inherited from TinyGsmSSL.tpp
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -421,26 +430,6 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     return waitResponse() == 1;
   }
 
-  /*
-   * Messaging functions
-   */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
-
-  /*
-   * GSM Location functions
-   */
- protected:
-  // Depending on the exacty model and firmware revision, should return a
-  // GSM-based location from CLBS as as inherited from TinyGsmGSMLocation.tpp
-  // TODO(?):  Check number of digits in year (2 or 4)
-
-  /*
-   * GPS/GNSS/GLONASS location functions
-   */
- protected:
-  // No functions of this type supported
-
   /*
    * Audio functions
    */
@@ -480,10 +469,26 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     return waitResponse();
   }
 
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
+
+  /*
+   * GSM Location functions
+   */
+  // Depending on the exacty model and firmware revision, should return a
+  // GSM-based location from CLBS as as inherited from TinyGsmGSMLocation.tpp
+  // TODO(?):  Check number of digits in year (2 or 4)
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
+
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
@@ -491,16 +496,20 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
    */
   // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
 
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
- protected:
   // Follows all battery functions as inherited from TinyGsmBattery.tpp
 
   /*
-   * NTP server functions
+   * Temperature functions
    */
-  // Follows all NTP server functions as inherited from TinyGsmNTP.tpp
+  // No functions of this type supported
 
   /*
    * Client related functions
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 382583d..4397470 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -19,16 +19,16 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGPS.tpp"
-#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
-#include "TinyGsmTemperature.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmGPS.tpp"
 #include "TinyGsmTime.tpp"
+#include "TinyGsmBattery.tpp"
+#include "TinyGsmTemperature.tpp"
 
 enum SaraR4RegStatus {
   REG_NO_RESULT    = -1,
@@ -44,22 +44,22 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
                       public TinyGsmGPRS<TinyGsmSaraR4>,
                       public TinyGsmTCP<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>,
                       public TinyGsmSSL<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>,
-                      public TinyGsmBattery<TinyGsmSaraR4>,
+                      public TinyGsmSMS<TinyGsmSaraR4>,
                       public TinyGsmGSMLocation<TinyGsmSaraR4>,
                       public TinyGsmGPS<TinyGsmSaraR4>,
-                      public TinyGsmSMS<TinyGsmSaraR4>,
-                      public TinyGsmTemperature<TinyGsmSaraR4>,
-                      public TinyGsmTime<TinyGsmSaraR4> {
+                      public TinyGsmTime<TinyGsmSaraR4>,
+                      public TinyGsmBattery<TinyGsmSaraR4>,
+                      public TinyGsmTemperature<TinyGsmSaraR4> {
   friend class TinyGsmModem<TinyGsmSaraR4>;
   friend class TinyGsmGPRS<TinyGsmSaraR4>;
   friend class TinyGsmTCP<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>;
   friend class TinyGsmSSL<TinyGsmSaraR4, TINY_GSM_MUX_COUNT>;
-  friend class TinyGsmBattery<TinyGsmSaraR4>;
+  friend class TinyGsmSMS<TinyGsmSaraR4>;
   friend class TinyGsmGSMLocation<TinyGsmSaraR4>;
   friend class TinyGsmGPS<TinyGsmSaraR4>;
-  friend class TinyGsmSMS<TinyGsmSaraR4>;
-  friend class TinyGsmTemperature<TinyGsmSaraR4>;
   friend class TinyGsmTime<TinyGsmSaraR4>;
+  friend class TinyGsmTemperature<TinyGsmSaraR4>;
+  friend class TinyGsmBattery<TinyGsmSaraR4>;
 
   /*
    * Inner Client
@@ -349,6 +349,16 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     return restart();
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // Follows functions as inherited from TinyGsmSSL.tpp
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -415,7 +425,17 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
   }
 
   /*
-   * Messaging functions
+   * Phone Call functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
    */
  protected:
   String sendUSSDImpl(const String& code) TINY_GSM_ATTR_NOT_IMPLEMENTED;
@@ -583,9 +603,28 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index 5d62b59..691cb29 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -19,16 +19,16 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGPS.tpp"
-#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmGPS.tpp"
 #include "TinyGsmTime.tpp"
+#include "TinyGsmBattery.tpp"
 
 #include <string.h>
 
@@ -460,14 +460,12 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
   /*
    * Phone Call functions
    */
- protected:
   // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
-   * Messaging functions
+   * Text messaging (SMS) functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM/GPS/GNSS/GLONASS Location functions
@@ -621,7 +619,6 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
   /*
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 0d90a57..3e240a4 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -18,14 +18,14 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
-#include "TinyGsmTemperature.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
 #include "TinyGsmTime.tpp"
+#include "TinyGsmTemperature.tpp"
 
 enum MonarchRegStatus {
   REG_NO_RESULT    = -1,
@@ -336,6 +336,16 @@ class TinyGsmSequansMonarch
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // Follows functions as inherited from TinyGsmSSL.tpp
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -397,18 +407,56 @@ class TinyGsmSequansMonarch
   bool dtmfSendImpl(char cmd,
                     int  duration_ms = 100) TINY_GSM_ATTR_NOT_AVAILABLE;
 
+
   /*
-   * Messaging functions
+   * Audio functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
+
+  /*
+   * GSM Location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
 
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Battery functions
+   */
+  // No functions of this type supportedp
+
   /*
    * Temperature functions
    */
@@ -424,6 +472,9 @@ class TinyGsmSequansMonarch
     return res.toFloat();
   }
 
+  /*
+   * Client related functions
+   */
  protected:
   bool modemConnect(const char* host, uint16_t port, uint8_t mux,
                     bool ssl = false, int timeout_s = 75) {
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index d90a2ac..7eb6dda 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -19,16 +19,16 @@
 #endif
 #define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmCalling.tpp"
-#include "TinyGsmGPRS.tpp"
-#include "TinyGsmGPS.tpp"
-#include "TinyGsmGSMLocation.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmSSL.tpp"
 #include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmCalling.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmGSMLocation.tpp"
+#include "TinyGsmGPS.tpp"
 #include "TinyGsmTime.tpp"
+#include "TinyGsmBattery.tpp"
 
 enum UBLOXRegStatus {
   REG_NO_RESULT    = -1,
@@ -139,7 +139,6 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     explicit GsmClientSecureUBLOX(TinyGsmUBLOX& modem, uint8_t mux = 0)
         : GsmClientUBLOX(modem, mux) {}
 
-   public:
     int connect(const char* host, uint16_t port, int timeout_s) override {
       // stop();  // DON'T stop!
       TINY_GSM_YIELD();
@@ -311,6 +310,16 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     return res;
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // Follows functions as inherited from TinyGsmSSL.tpp
+
+  /*
+   * WiFi functions
+   */
+  // No functions of this type supported
+
   /*
    * GPRS functions
    */
@@ -412,14 +421,17 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
   /*
    * Phone Call functions
    */
- protected:
   // Follows all phone call functions as inherited from TinyGsmCalling.tpp
 
   /*
-   * Messaging functions
+   * Audio functions
    */
- protected:
-  // Follows all messaging functions as inherited from TinyGsmSMS.tpp
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
+   */
+  // Follows all text messaging (SMS) functions as inherited from TinyGsmSMS.tpp
 
   /*
    * GSM/GPS/GNSS/GLONASS Location functions
@@ -582,9 +594,18 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
   /*
    * Time functions
    */
- protected:
   // Follows all clock functions as inherited from TinyGsmTime.tpp
 
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
@@ -615,7 +636,6 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
   /*
    * Temperature functions
    */
-
   // This would only available for a small number of modules in this group
   // (TOBY-L)
   float getTemperatureImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 269de66..1859f30 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -26,14 +26,14 @@
 #endif
 #define AT_NL "\r"
 
-#include "TinyGsmBattery.tpp"
-#include "TinyGsmGPRS.tpp"
 #include "TinyGsmModem.tpp"
-#include "TinyGsmSMS.tpp"
-#include "TinyGsmSSL.tpp"
-#include "TinyGsmTCP.tpp"
-#include "TinyGsmTemperature.tpp"
 #include "TinyGsmWifi.tpp"
+#include "TinyGsmGPRS.tpp"
+#include "TinyGsmTCP.tpp"
+#include "TinyGsmSSL.tpp"
+#include "TinyGsmSMS.tpp"
+#include "TinyGsmTemperature.tpp"
+#include "TinyGsmBattery.tpp"
 
 // Use this to avoid too many entrances and exits from command mode.
 // The cellular Bee's often freeze up and won't respond when attempting
@@ -320,10 +320,11 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     // Start with the default guard time of 1 second
     memset(sockets, 0, sizeof(sockets));
   }
+
   /*
    * Basic functions
    */
-
+ protected:
   bool initImpl(const char* pin = nullptr) {
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientXBee"));
@@ -824,6 +825,11 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return TinyGsmIpFromString(getDNS());
   }
 
+  /*
+   * Secure socket layer (SSL) functions
+   */
+  // Follows functions as inherited from TinyGsmSSL.tpp
+
   /*
    * WiFi functions
    */
@@ -962,7 +968,17 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
   }
 
   /*
-   * Messaging functions
+   * Phone Call functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Audio functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Text messaging (SMS) functions
    */
  protected:
   String sendUSSDImpl(const String& code) TINY_GSM_ATTR_NOT_AVAILABLE;
@@ -1015,6 +1031,31 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return true;
   }
 
+  /*
+   * GSM Location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * GPS/GNSS/GLONASS location functions
+   */
+  // No functions of this type supported
+
+  /*
+   * Time functions
+   */
+  // No functions of this type supported
+
+  /*
+   * NTP server functions
+   */
+  // No functions of this type supported
+
+  /*
+   * BLE functions
+   */
+  // No functions of this type supported
+
   /*
    * Battery functions
    */
@@ -1046,7 +1087,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
   /*
    * Temperature functions
    */
-
+ protected:
   float getTemperatureImpl() {
     XBEE_COMMAND_START_DECORATOR(5, static_cast<float>(-9999))
     String res = sendATGetString(GF("TP"));
diff --git a/src/TinyGsmSMS.tpp b/src/TinyGsmSMS.tpp
index 2fa92f1..d7fc678 100644
--- a/src/TinyGsmSMS.tpp
+++ b/src/TinyGsmSMS.tpp
@@ -22,7 +22,7 @@ class TinyGsmSMS {
    */
  public:
   /*
-   * Messaging functions
+   * Text messaging (SMS) functions
    */
   String sendUSSD(const String& code) {
     return thisModem().sendUSSDImpl(code);
@@ -124,7 +124,7 @@ class TinyGsmSMS {
    */
 
   /*
-   * Messaging functions
+   * Text messaging (SMS) functions
    */
 
   String sendUSSDImpl(const String& code) {

From 587bfd0d6d8e16ea91a8609fcb9ab1ed5f41b23c Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 22 May 2024 14:03:00 -0400
Subject: [PATCH 078/100] Fix for SARA-R5

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .github/workflows/build_examples_platformio.yaml | 1 +
 src/TinyGsmClientSaraR5.h                        | 9 +++------
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/build_examples_platformio.yaml b/.github/workflows/build_examples_platformio.yaml
index 420c0bf..0a5b148 100644
--- a/.github/workflows/build_examples_platformio.yaml
+++ b/.github/workflows/build_examples_platformio.yaml
@@ -41,6 +41,7 @@ jobs:
             TINY_GSM_MODEM_SIM7070,
             TINY_GSM_MODEM_UBLOX,
             TINY_GSM_MODEM_SARAR4,
+            TINY_GSM_MODEM_SARAR5,
             TINY_GSM_MODEM_XBEE,
             TINY_GSM_MODEM_SEQUANS_MONARCH,
           ]
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index 691cb29..9c536bd 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -30,8 +30,6 @@
 #include "TinyGsmTime.tpp"
 #include "TinyGsmBattery.tpp"
 
-#include <string.h>
-
 enum SaraR5RegStatus {
   REG_NO_RESULT        = -1,
   REG_UNREGISTERED     = 0,
@@ -312,7 +310,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     return true;
   }
 
-  bool getCurrentRadioAccessTechnology(int& set) {
+  bool getCurrentRadioAccessTechnology() {
     sendAT(GF("+URAT?"));
     String response;
     if (waitResponse(10000L, response) != 1) { return false; }
@@ -416,9 +414,8 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
         "+UPSDA=0,4"));  // Deactivate the PDP context associated with profile 0
     waitResponse(360000L);  // Can return an error if previously not activated
 
-    sendAT(
-        GF("+UPSD=0,100,") +
-        String(rcid));  // Deactivate the PDP context associated with profile 0
+    sendAT(GF("+UPSD=0,100,"),
+           rcid);  // Deactivate the PDP context associated with profile 0
     waitResponse();
 
     sendAT(GF(

From de1ce1137eabf837f3257e8db86d056bd3d3422c Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 22 May 2024 19:13:42 -0400
Subject: [PATCH 079/100] Add ESP32 as definable

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 examples/AllFunctions/AllFunctions.ino | 43 +++++++++++++++++++-------
 examples/BlynkClient/BlynkClient.ino   |  1 +
 examples/FileDownload/FileDownload.ino |  1 +
 examples/HttpClient/HttpClient.ino     |  1 +
 examples/HttpsClient/HttpsClient.ino   |  1 +
 examples/MqttClient/MqttClient.ino     |  1 +
 examples/WebClient/WebClient.ino       |  1 +
 src/TinyGsmClient.h                    |  2 +-
 8 files changed, 38 insertions(+), 13 deletions(-)

diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index b37f70f..bae2adb 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -32,6 +32,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
@@ -72,17 +73,17 @@ SoftwareSerial SerialAT(2, 3);  // RX, TX
 #define TINY_GSM_TEST_WIFI false
 #define TINY_GSM_TEST_TCP true
 #define TINY_GSM_TEST_SSL true
-#define TINY_GSM_TEST_CALL false
-#define TINY_GSM_TEST_SMS false
-#define TINY_GSM_TEST_USSD false
+#define TINY_GSM_TEST_CALL true
+#define TINY_GSM_TEST_SMS true
+#define TINY_GSM_TEST_USSD true
 #define TINY_GSM_TEST_BATTERY true
 #define TINY_GSM_TEST_TEMPERATURE true
-#define TINY_GSM_TEST_GSM_LOCATION false
-#define TINY_GSM_TEST_NTP false
-#define TINY_GSM_TEST_TIME false
-#define TINY_GSM_TEST_GPS false
+#define TINY_GSM_TEST_GSM_LOCATION true
+#define TINY_GSM_TEST_GPS true
+#define TINY_GSM_TEST_NTP true
+#define TINY_GSM_TEST_TIME true
 // disconnect and power down modem after tests
-#define TINY_GSM_POWERDOWN false
+#define TINY_GSM_POWERDOWN true
 
 // set GSM PIN, if any
 #define GSM_PIN ""
@@ -157,11 +158,25 @@ void loop() {
     return;
   }
 
+  String modemInfo = modem.getModemInfo();
+  DBG("Modem Info:", modemInfo);
+
   String name = modem.getModemName();
   DBG("Modem Name:", name);
 
-  String modemInfo = modem.getModemInfo();
-  DBG("Modem Info:", modemInfo);
+  String manufacturer = modem.getModemManufacturer();
+  DBG("Modem Manufacturer:", manufacturer);
+
+  String hw_ver = modem.getModemModel();
+  DBG("Modem Hardware Version:", hw_ver);
+
+  String fv_ver = modem.getModemRevision();
+  DBG("Modem Firware Version:", fv_ver);
+
+#if not defined(TINY_GSM_MODEM_ESP8266) && not defined(TINY_GSM_MODEM_ESP32)
+  String mod_sn = modem.getModemSerialNumber();
+  DBG("Modem Serial Number (may be SIM CCID):", mod_sn);
+#endif
 
 #if TINY_GSM_TEST_GPRS
   // Unlock your SIM card with a PIN if needed
@@ -213,6 +228,9 @@ void loop() {
   String cop = modem.getOperator();
   DBG("Operator:", cop);
 
+  String prov = modem.getProvider();
+  DBG("Provider:", prov);
+
   IPAddress local = modem.localIP();
   DBG("Local IP:", local);
 
@@ -268,6 +286,7 @@ void loop() {
 #endif
 
 #if TINY_GSM_TEST_SSL && defined TINY_GSM_MODEM_HAS_SSL
+  // TODO: Add test of adding certificcate
   TinyGsmClientSecure secureClient(modem, 1);
   const int           securePort = 443;
   DBG("Connecting securely to", server);
@@ -306,8 +325,8 @@ void loop() {
   }
 #endif
 
-#if TINY_GSM_TEST_CALL && defined TINY_GSM_MODEM_HAS_CALLING && \
-    defined                       CALL_TARGET
+#if TINY_GSM_TEST_CALL && defined(TINY_GSM_MODEM_HAS_CALLING) && \
+    defined(CALL_TARGET)
   DBG("Calling:", CALL_TARGET);
 
   // This is NOT supported on M590
diff --git a/examples/BlynkClient/BlynkClient.ino b/examples/BlynkClient/BlynkClient.ino
index 21a4b05..6be1eb3 100644
--- a/examples/BlynkClient/BlynkClient.ino
+++ b/examples/BlynkClient/BlynkClient.ino
@@ -55,6 +55,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/examples/FileDownload/FileDownload.ino b/examples/FileDownload/FileDownload.ino
index 2d96687..8d102e5 100644
--- a/examples/FileDownload/FileDownload.ino
+++ b/examples/FileDownload/FileDownload.ino
@@ -36,6 +36,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/examples/HttpClient/HttpClient.ino b/examples/HttpClient/HttpClient.ino
index 74f1c7c..f3d2e01 100644
--- a/examples/HttpClient/HttpClient.ino
+++ b/examples/HttpClient/HttpClient.ino
@@ -41,6 +41,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/examples/HttpsClient/HttpsClient.ino b/examples/HttpsClient/HttpsClient.ino
index 33092f2..95a107b 100644
--- a/examples/HttpsClient/HttpsClient.ino
+++ b/examples/HttpsClient/HttpsClient.ino
@@ -30,6 +30,7 @@
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/examples/MqttClient/MqttClient.ino b/examples/MqttClient/MqttClient.ino
index 327461a..797a52c 100644
--- a/examples/MqttClient/MqttClient.ino
+++ b/examples/MqttClient/MqttClient.ino
@@ -45,6 +45,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/examples/WebClient/WebClient.ino b/examples/WebClient/WebClient.ino
index 4708d22..3cb2703 100644
--- a/examples/WebClient/WebClient.ino
+++ b/examples/WebClient/WebClient.ino
@@ -31,6 +31,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/src/TinyGsmClient.h b/src/TinyGsmClient.h
index 470a2e0..cd2a98f 100644
--- a/src/TinyGsmClient.h
+++ b/src/TinyGsmClient.h
@@ -101,7 +101,7 @@ typedef TinyGsmM590::GsmClientM590 TinyGsmClient;
 typedef TinyGsmMC60                TinyGsm;
 typedef TinyGsmMC60::GsmClientMC60 TinyGsmClient;
 
-#elif defined(TINY_GSM_MODEM_ESP8266)
+#elif defined(TINY_GSM_MODEM_ESP8266) || defined(TINY_GSM_MODEM_ESP32)
 #define TINY_GSM_MODEM_HAS_WIFI
 #include "TinyGsmClientESP8266.h"
 typedef TinyGsmESP8266                         TinyGsm;

From 46d978255c3a8dedea7273650f1d286528f0b9d7 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Wed, 22 May 2024 19:21:57 -0400
Subject: [PATCH 080/100] Clean modem name functions, remove non-functional
 factory reset from SIM70xx

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA6.h               |  27 ++++---
 src/TinyGsmClientA7672x.h           |  27 +++----
 src/TinyGsmClientBG96.h             |  16 +++-
 src/TinyGsmClientESP8266.h          |  88 ++++++++++++--------
 src/TinyGsmClientM590.h             |  36 ++++++++-
 src/TinyGsmClientM95.h              |  12 ++-
 src/TinyGsmClientMC60.h             |  16 +++-
 src/TinyGsmClientSIM5360.h          |  39 ++++-----
 src/TinyGsmClientSIM7000.h          |   4 +-
 src/TinyGsmClientSIM7080.h          |  13 ---
 src/TinyGsmClientSIM70xx.h          |  52 ++++++------
 src/TinyGsmClientSIM7600.h          |  36 ++++-----
 src/TinyGsmClientSIM800.h           |  48 +++++------
 src/TinyGsmClientSaraR4.h           |  29 ++++---
 src/TinyGsmClientSaraR5.h           |  29 ++++---
 src/TinyGsmClientSequansMonarch.h   |  32 +++-----
 src/TinyGsmClientUBLOX.h            |  29 ++++---
 src/TinyGsmClientXBee.h             |  24 +++++-
 src/TinyGsmModem.tpp                | 119 ++++++++++++++--------------
 tools/AT_Debug/AT_Debug.ino         |   1 +
 tools/Diagnostics/Diagnostics.ino   |   1 +
 tools/FactoryReset/FactoryReset.ino |   6 +-
 22 files changed, 378 insertions(+), 306 deletions(-)

diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index 181bb1a..c7e2c19 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -17,7 +17,21 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Ai-Thinker"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_A7)
+#define MODEM_MODEL "A7"
+#else
+#define MODEM_MODEL "A6"
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -166,12 +180,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     sendAT(GF("GSN"));  // Not CGSN
     String res;
     if (waitResponse(1000L, res) != 1) { return ""; }
-    // Do the replaces twice so we cover both \r and \r\n type endings
-    res.replace("\r\nOK\r\n", "");
-    res.replace("\rOK\r", "");
-    res.replace("\r\n", " ");
-    res.replace("\r", " ");
-    res.trim();
+    cleanResponseString(res);
     return res;
   }
 
@@ -222,9 +231,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
     sendAT(GF("+CIFSR"));
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, "");
-    res.trim();
+    cleanResponseString(res);
     return res;
   }
 
diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index ca1dd7d..4992eb9 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -16,7 +16,17 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "SIMCom"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "A7672x"
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -210,21 +220,6 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     }
   }
 
-  String getModemNameImpl() {
-    String name = "A7672SA-LASE";
-
-    sendAT(GF("+CGMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.replace("_", " ");
-    res2.trim();
-
-    name = res2;
-    DBG("### Modem:", name);
-    return name;
-  }
-
   bool factoryDefaultImpl() {
     sendAT(GF("&F"));  // Factory + Reset
     waitResponse();
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index 5ad208c..dac7ea3 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -17,7 +17,21 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Quectel"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_BG95) || defined(TINY_GSM_MODEM_BG95SSL)
+#define MODEM_MODEL "BG95"
+#else
+#define MODEM_MODEL "BG96"
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
diff --git a/src/TinyGsmClientESP8266.h b/src/TinyGsmClientESP8266.h
index 24b37cc..85f352c 100644
--- a/src/TinyGsmClientESP8266.h
+++ b/src/TinyGsmClientESP8266.h
@@ -17,7 +17,21 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Espressif"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_ESP8266)
+#define MODEM_MODEL "ESP8266"
+#else
+#define MODEM_MODEL "ESP32"
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -164,29 +178,6 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     return true;
   }
 
-  String getModemNameImpl() {
-    return "ESP8266";
-  }
-
-  // Gets the modem serial number
-  String getModemSerialNumberImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
-  // Gets the modem hardware version
-  String getModemHardwareVersionImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
-
-  // Gets the modem firmware version
-  String getModemFirmwareVersionImpl() {
-    sendAT(GF("GMR"));  // GMR instead of CGMR
-    String res;
-    if (waitResponse(1000L, res) != 1) { return ""; }
-    // Do the replaces twice so we cover both \r and \r\n type endings
-    res.replace("\r\nOK\r\n", "");
-    res.replace("\rOK\r", "");
-    res.replace("\r\n", " ");
-    res.replace("\r", " ");
-    res.trim();
-    return res;
-  }
-
   bool setBaudImpl(uint32_t baud) {
     sendAT(GF("+UART_CUR="), baud, "8,1,0,0");
     if (waitResponse() != 1) {
@@ -201,21 +192,54 @@ class TinyGsmESP8266 : public TinyGsmModem<TinyGsmESP8266>,
     return false;
   }
 
-  bool factoryDefaultImpl() {
-    sendAT(GF("+RESTORE"));
-    return waitResponse() == 1;
-  }
-
   String getModemInfoImpl() {
     sendAT(GF("+GMR"));
     String res;
     if (waitResponse(1000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, " ");
-    res.trim();
+    cleanResponseString(res);
     return res;
   }
 
+  // Gets the modem hardware version
+  String getModemManufacturerImpl() {
+    return MODEM_MANUFACTURER;
+  }
+
+  // Gets the modem hardware version
+  String getModemModelImpl() {
+    String model = MODEM_MODEL;
+    sendAT(GF("+GMR"));
+    streamSkipUntil('\n');  // skip the AT version
+    streamSkipUntil('\n');  // skip the SDK version
+    streamSkipUntil('\n');  // skip the compile time
+    // read the hardware from the Bin version
+    streamSkipUntil('(');  // skip the text "Bin version"
+    String wroom = stream.readStringUntil(
+        ')');                        // read the WRoom version in the parethesis
+    streamSkipUntil('(');            // skip the bin version itself
+    if (waitResponse(1000L) == 1) {  // wait for the ending OK
+      return wroom;
+    }
+    return model;
+  }
+
+  // Gets the modem firmware version
+  String getModemRevisionImpl() {
+    sendAT(GF("GMR"));  // GMR instead of CGMR
+    String res;
+    if (waitResponse(1000L, res) != 1) { return ""; }
+    cleanResponseString(res);
+    return res;
+  }
+
+  // Gets the modem serial number
+  String getModemSerialNumberImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+
+  bool factoryDefaultImpl() {
+    sendAT(GF("+RESTORE"));
+    return waitResponse() == 1;
+  }
+
   /*
    * Power functions
    */
diff --git a/src/TinyGsmClientM590.h b/src/TinyGsmClientM590.h
index 33cd777..1458613 100644
--- a/src/TinyGsmClientM590.h
+++ b/src/TinyGsmClientM590.h
@@ -17,7 +17,17 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Neoway"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "M590"
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -161,9 +171,31 @@ class TinyGsmM590 : public TinyGsmModem<TinyGsmM590>,
     return factory + String(" ") + model;
   }
 
+  // This is extracted from the modem info
+  String getModemManufacturerImpl() {
+    sendAT(GF("I"));
+    String factory = stream.readStringUntil('\n');  // read the factory
+    factory.trim();
+    streamSkipUntil('\n');  // skip the model
+    streamSkipUntil('\n');  // skip the revision
+    if (waitResponse() == 1) { return factory; }
+    return MODEM_MANUFACTURER;
+  }
+
+  // This is extracted from the modem info
+  String getModemModelImpl() {
+    sendAT(GF("I"));
+    streamSkipUntil('\n');                        // skip the factory
+    String model = stream.readStringUntil('\n');  // read the model
+    model.trim();
+    streamSkipUntil('\n');  // skip the revision
+    if (waitResponse() == 1) { return model; }
+    return MODEM_MODEL;
+  }
+
   // Gets the modem firmware version
   // This is extracted from the modem info
-  String getModemFirmwareVersionImpl() {
+  String getModemRevisionImpl() {
     sendAT(GF("I"));
     streamSkipUntil('\n');                      // skip the factory
     streamSkipUntil('\n');                      // skip the model
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 130d956..0d2887a 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -18,7 +18,17 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Quectel"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "M95"
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index 5c869b6..1522e0d 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -20,7 +20,21 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Quectel"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_MC60E)
+#define MODEM_MODEL "MC60E"
+#else
+#define MODEM_MODEL "MC60"
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index cb397d6..95b20ed 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -17,7 +17,25 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "SIMCom"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_SIM5320)
+#define MODEM_MODEL "SIM5320";
+#elif defined(TINY_GSM_MODEM_SIM5300)
+#define MODEM_MODEL "SIM5300";
+#elif defined(TINY_GSM_MODEM_SIM7100)
+#define MODEM_MODEL "SIM7100";
+#else
+#define MODEM_MODEL "SIM5360";
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -174,21 +192,6 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     }
   }
 
-  String getModemNameImpl() {
-    String name = "SIMCom SIM5360";
-
-    sendAT(GF("+CGMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.replace("_", " ");
-    res2.trim();
-
-    name = res2;
-    DBG("### Modem:", name);
-    return name;
-  }
-
   bool factoryDefaultImpl() {  // these commands aren't supported
     return false;
   }
@@ -270,9 +273,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     // sendAT(GF("+CGPADDR=1"));  // Show PDP address
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, "");
-    res.trim();
+    cleanResponseString(res);
     return res;
   }
 
diff --git a/src/TinyGsmClientSIM7000.h b/src/TinyGsmClientSIM7000.h
index 33c4841..dc2ab41 100644
--- a/src/TinyGsmClientSIM7000.h
+++ b/src/TinyGsmClientSIM7000.h
@@ -168,9 +168,7 @@ class TinyGsmSim7000 : public TinyGsmSim70xx<TinyGsmSim7000>,
     sendAT(GF("+CIFSR;E0"));
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, "");
-    res.trim();
+    cleanResponseString(res);
     return res;
   }
 
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index f798385..bd32116 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -195,19 +195,6 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     while (stream.available()) { waitResponse(15, nullptr, nullptr); }
   }
 
-  bool factoryDefaultImpl() {
-    sendAT(GF("&FZE0"));  // Factory + Reset + Echo Off + Write
-    waitResponse();
-    sendAT(GF("+IPR=0"));  // Auto-baud
-    waitResponse();
-    sendAT(GF("+IFC=0,0"));  // No Flow Control
-    waitResponse();
-    sendAT(GF("+ICF=3,3"));  // 8 data 0 parity 1 stop
-    waitResponse();
-    sendAT(GF("+CSCLK=0"));  // Disable Slow Clock
-    return waitResponse() == 1;
-  }
-
   /*
    * Power functions
    */
diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index e4f3dca..fba11aa 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -14,7 +14,27 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "SIMCom"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_SIM7070)
+#define MODEM_MODEL "SIM7070";
+#elif defined(TINY_GSM_MODEM_SIM7080)
+#define MODEM_MODEL "SIM7080";
+#elif defined(TINY_GSM_MODEM_SIM7090)
+#define MODEM_MODEL "SIM7090";
+#elif defined(TINY_GSM_MODEM_SIM7000) || defined(TINY_GSM_MODEM_SIM7000SSL)
+#define MODEM_MODEL "SIM7000";
+#else
+#define MODEM_MODEL "SIM70xx";
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -60,34 +80,8 @@ class TinyGsmSim70xx : public TinyGsmModem<SIM70xxType>,
    * Basic functions
    */
  protected:
-  String getModemNameImpl() {
-    String name = "SIMCom SIM7000";
-
-    thisModem().sendAT(GF("+GMM"));
-    String res2;
-    if (thisModem().waitResponse(5000L, res2) != 1) { return name; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.replace("_", " ");
-    res2.trim();
-
-    name = res2;
-    DBG("### Modem:", name);
-    return name;
-  }
-
-  bool factoryDefaultImpl() {           // these commands aren't supported
-    thisModem().sendAT(GF("&FZE0&W"));  // Factory + Reset + Echo Off + Write
-    thisModem().waitResponse();
-    thisModem().sendAT(GF("+IPR=0"));  // Auto-baud
-    thisModem().waitResponse();
-    thisModem().sendAT(GF("+IFC=0,0"));  // No Flow Control
-    thisModem().waitResponse();
-    thisModem().sendAT(GF("+ICF=3,3"));  // 8 data 0 parity 1 stop
-    thisModem().waitResponse();
-    thisModem().sendAT(GF("+CSCLK=0"));  // Disable Slow Clock
-    thisModem().waitResponse();
-    thisModem().sendAT(GF("&W"));  // Write configuration
-    return thisModem().waitResponse() == 1;
+  bool factoryDefaultImpl() {
+    return false
   }
 
   /*
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 217a312..70fea0a 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -17,7 +17,23 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "SIMCom"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_SIM7500)
+#define MODEM_MODEL "SIM7500";
+#elif defined(TINY_GSM_MODEM_SIM7800)
+#define MODEM_MODEL "SIM7800";
+#else
+#define MODEM_MODEL "SIM7600";
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -178,21 +194,6 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     }
   }
 
-  String getModemNameImpl() {
-    String name = "SIMCom SIM7600";
-
-    sendAT(GF("+CGMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.replace("_", " ");
-    res2.trim();
-
-    name = res2;
-    DBG("### Modem:", name);
-    return name;
-  }
-
   bool factoryDefaultImpl() {  // these commands aren't supported
     return false;
   }
@@ -283,8 +284,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     // sendAT(GF("+CGPADDR=1"));  // Show PDP address
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, "");
+    cleanResponseString(res);
     res.trim();
     return res;
   }
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 3fac243..2dca293 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -18,7 +18,25 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "unknown"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#if defined(TINY_GSM_MODEM_SIM808)
+#define MODEM_MODEL "SIM808";
+#elif defined(TINY_GSM_MODEM_SIM868)
+#define MODEM_MODEL "SIM868";
+#elif defined(TINY_GSM_MODEM_SIM900)
+#define MODEM_MODEL "SIM900";
+#else
+#define MODEM_MODEL "SIM800";
+#endif
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -193,30 +211,6 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     }
   }
 
-  String getModemNameImpl() {
-    String name = "";
-#if defined(TINY_GSM_MODEM_SIM800)
-    name = "SIMCom SIM800";
-#elif defined(TINY_GSM_MODEM_SIM808)
-    name = "SIMCom SIM808";
-#elif defined(TINY_GSM_MODEM_SIM868)
-    name = "SIMCom SIM868";
-#elif defined(TINY_GSM_MODEM_SIM900)
-    name = "SIMCom SIM900";
-#endif
-
-    sendAT(GF("+GMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return name; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.replace("_", " ");
-    res2.trim();
-
-    name = res2;
-    DBG("### Modem:", name);
-    return name;
-  }
-
   bool factoryDefaultImpl() {
     sendAT(GF("&FZE0&W"));  // Factory + Reset + Echo Off + Write
     waitResponse();
@@ -299,9 +293,7 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     sendAT(GF("+CIFSR;E0"));
     String res;
     if (waitResponse(10000L, res) != 1) { return ""; }
-    res.replace(AT_NL "OK" AT_NL, "");
-    res.replace(AT_NL, "");
-    res.trim();
+    cleanResponseString(res);
     return res;
   }
 
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 4397470..9a8b805 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -17,7 +17,17 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "u-blox"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "SARA-R4"
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -261,25 +271,14 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
 
   // only difference in implementation is the warning on the wrong type
   String getModemNameImpl() {
-    sendAT(GF("+CGMI"));
-    String res1;
-    if (waitResponse(1000L, res1) != 1) { return "u-blox Cellular Modem"; }
-    res1.replace(AT_NL "OK" AT_NL, "");
-    res1.trim();
-
-    sendAT(GF("+GMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return "u-blox Cellular Modem"; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.trim();
-
-    String name = res1 + String(' ') + res2;
+    String manufacturer = getModemManufacturer();
+    String model        = getModemModel();
+    String name         = manufacturer + String(" ") + model;
     DBG("### Modem:", name);
     if (!name.startsWith("u-blox SARA-R4") &&
         !name.startsWith("u-blox SARA-N4")) {
       DBG("### WARNING:  You are using the wrong TinyGSM modem!");
     }
-
     return name;
   }
 
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index 9c536bd..4c7e47c 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -17,7 +17,17 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "u-blox"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "SARA-R5"
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -222,26 +232,15 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
 
   // only difference in implementation is the warning on the wrong type
   String getModemNameImpl() {
-    sendAT(GF("+CGMI"));
-    String res1;
-    if (waitResponse(1000L, res1) != 1) { return "u-blox Cellular Modem"; }
-    res1.replace(AT_NL "OK" AT_NL, "");
-    res1.trim();
-
-    sendAT(GF("+GMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return "u-blox Cellular Modem"; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.trim();
-
-    String name = res1 + String(' ') + res2;
+    String manufacturer = getModemManufacturer();
+    String model        = getModemModel();
+    String name         = manufacturer + String(" ") + model;
     if (name.startsWith("u-blox SARA-R4") ||
         name.startsWith("u-blox SARA-N4")) {
       DBG("### WARNING:  You are using the wrong TinyGSM modem!");
     } else if (name.startsWith("u-blox SARA-N2")) {
       DBG("### SARA N2 NB-IoT modems not supported!");
     }
-
     return name;
   }
 
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 3e240a4..2698008 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -16,7 +16,17 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Sequans"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "Monarch"
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -233,26 +243,6 @@ class TinyGsmSequansMonarch
     }
   }
 
-  String getModemNameImpl() {
-    sendAT(GF("+CGMI"));
-    String res1;
-    if (waitResponse(1000L, res1) != 1) { return "unknown"; }
-    res1.replace("\r\nOK\r\n", "");
-    res1.replace("\rOK\r", "");
-    res1.trim();
-
-    sendAT(GF("+CGMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return "unknown"; }
-    res2.replace("\r\nOK\r\n", "");
-    res2.replace("\rOK\r", "");
-    res2.trim();
-
-    String name = res1 + String(' ') + res2;
-    DBG("### Modem:", name);
-    return name;
-  }
-
   bool factoryDefaultImpl() {
     sendAT(GF("&F0"));  // Factory
     waitResponse();
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index 7eb6dda..ccbeb60 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -17,7 +17,17 @@
 #ifdef AT_NL
 #undef AT_NL
 #endif
-#define AT_NL "\r\n"  // NOTE:  define before including TinyGsmModem!
+#define AT_NL "\r\n"
+
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "u-blox"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "unknown"
 
 #include "TinyGsmModem.tpp"
 #include "TinyGsmTCP.tpp"
@@ -206,26 +216,15 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
 
   // only difference in implementation is the warning on the wrong type
   String getModemNameImpl() {
-    sendAT(GF("+CGMI"));
-    String res1;
-    if (waitResponse(1000L, res1) != 1) { return "u-blox Cellular Modem"; }
-    res1.replace(AT_NL "OK" AT_NL, "");
-    res1.trim();
-
-    sendAT(GF("+GMM"));
-    String res2;
-    if (waitResponse(1000L, res2) != 1) { return "u-blox Cellular Modem"; }
-    res2.replace(AT_NL "OK" AT_NL, "");
-    res2.trim();
-
-    String name = res1 + String(' ') + res2;
+    String manufacturer = getModemManufacturer();
+    String model        = getModemModel();
+    String name         = manufacturer + String(" ") + model;
     if (name.startsWith("u-blox SARA-R4") ||
         name.startsWith("u-blox SARA-N4")) {
       DBG("### WARNING:  You are using the wrong TinyGSM modem!");
     } else if (name.startsWith("u-blox SARA-N2")) {
       DBG("### SARA N2 NB-IoT modems not supported!");
     }
-
     return name;
   }
 
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 1859f30..aaead26 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -26,6 +26,16 @@
 #endif
 #define AT_NL "\r"
 
+#ifdef MODEM_MANUFACTURER
+#undef MODEM_MANUFACTURER
+#endif
+#define MODEM_MANUFACTURER "Digi"
+
+#ifdef MODEM_MODEL
+#undef MODEM_MODEL
+#endif
+#define MODEM_MODEL "XBee"
+
 #include "TinyGsmModem.tpp"
 #include "TinyGsmWifi.tpp"
 #include "TinyGsmGPRS.tpp"
@@ -383,6 +393,16 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return getBeeName();
   }
 
+  String getModemModelImpl() {
+    switch (beeType) {
+      case XBEE_S6B_WIFI: return "XBee Wi-Fi";
+      case XBEE_LTE1_VZN: return "XBee Cellular LTE Cat 1";
+      case XBEE_3G: return "XBee Cellular 3G";
+      case XBEE3_LTE1_ATT: return "XBee3 Cellular LTE CAT 1";
+      case XBEE3_LTEM_ATT: return "XBee3 Cellular LTE-M";
+      default: return "XBee Unknown";
+    }
+  }
   // Gets the modem serial number
   String getModemSerialNumberImpl() {
     String xbeeSnLow =
@@ -393,12 +413,12 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
   }
 
   // Gets the modem hardware version
-  String getModemHardwareVersionImpl() {
+  String getModemModelImpl() {
     return sendATGetString(GF("HV"));
   }
 
   // Gets the modem firmware version
-  String getModemFirmwareVersionImpl() {
+  String getModemRevisionImpl() {
     return sendATGetString(GF("VR"));
   }
 
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 37da2e3..d438bf2 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -33,6 +33,14 @@
 #endif
 #endif
 
+#ifndef MODEM_MANUFACTURER
+#define MODEM_MANUFACTURER "unknown"
+#endif
+
+#ifndef MODEM_MODEL
+#define MODEM_MODEL "unknown"
+#endif
+
 static const char GSM_OK[] TINY_GSM_PROGMEM    = AT_OK AT_NL;
 static const char GSM_ERROR[] TINY_GSM_PROGMEM = AT_ERROR AT_NL;
 
@@ -96,7 +104,7 @@ class TinyGsmModem {
     return waitResponse(1000L, r1, r2, r3, r4, r5, r6, r7);
   }
 
-  // Asks for modem information via the V.25TER standard ATI command
+  // Asks for modem information via the 3GPP TS 27.007 standard ATI command
   // NOTE:  The actual value and style of the response is quite varied
   String getModemInfo() {
     return thisModem().getModemInfoImpl();
@@ -105,18 +113,22 @@ class TinyGsmModem {
   String getModemName() {
     return thisModem().getModemNameImpl();
   }
+  // Gets the modem manufacturer
+  String getModemManufacturer() {
+    return thisModem().getModemManufacturerImpl();
+  }
+  // Gets the modem hardware version
+  String getModemModel() {
+    return thisModem().getModemModelImpl();
+  }
+  // Gets the modem firmware version
+  String getModemRevision() {
+    return thisModem().getModemRevisionImpl();
+  }
   // Gets the modem serial number
   String getModemSerialNumber() {
     return thisModem().getModemSerialNumberImpl();
   }
-  // Gets the modem hardware version
-  String getModemHardwareVersion() {
-    return thisModem().getModemHardwareVersionImpl();
-  }
-  // Gets the modem firmware version
-  String getModemFirmwareVersion() {
-    return thisModem().getModemFirmwareVersionImpl();
-  }
   bool factoryDefault() {
     return thisModem().factoryDefaultImpl();
   }
@@ -278,7 +290,15 @@ class TinyGsmModem {
     return false;
   }
 
- protected:
+  inline void cleanResponseString(String& res) {
+    // Do the replaces twice so we cover both \r and \r\n type endings
+    res.replace("\r\nOK\r\n", "");
+    res.replace("\rOK\r", "");
+    res.replace("\r\n", " ");
+    res.replace("\r", " ");
+    res.trim();
+  }
+
   static inline IPAddress TinyGsmIpFromString(const String& strIP) {
     int Parts[4] = {
         0,
@@ -411,77 +431,56 @@ class TinyGsmModem {
 
 
   String getModemInfoImpl() {
-    thisModem().sendAT(GF("I"));
+    thisModem().sendAT(GF("I"));  // 3GPP TS 27.007
     String res;
     if (thisModem().waitResponse(1000L, res) != 1) { return ""; }
-    // Do the replaces twice so we cover both \r and \r\n type endings
-    res.replace("\r\nOK\r\n", "");
-    res.replace("\rOK\r", "");
-    res.replace("\r\n", " ");
-    res.replace("\r", " ");
-    res.trim();
+    thisModem().cleanResponseString(res);
     return res;
   }
 
   String getModemNameImpl() {
-    thisModem().sendAT(GF("+CGMI"));
-    String res1;
-    if (thisModem().waitResponse(1000L, res1) != 1) { return "unknown"; }
-    res1.replace("\r\nOK\r\n", "");
-    res1.replace("\rOK\r", "");
-    res1.trim();
-
-    thisModem().sendAT(GF("+GMM"));
-    String res2;
-    if (thisModem().waitResponse(1000L, res2) != 1) { return "unknown"; }
-    res2.replace("\r\nOK\r\n", "");
-    res2.replace("\rOK\r", "");
-    res2.trim();
-
-    String name = res1 + String(' ') + res2;
+    String manufacturer = getModemManufacturer();
+    String model        = getModemModel();
+    String name         = manufacturer + String(" ") + model;
     DBG("### Modem:", name);
     return name;
   }
 
-  // Gets the modem serial number
-  String getModemSerialNumberImpl() {
-    thisModem().sendAT(GF("CGSN"));
+  // Gets the modem manufacturer
+  String getModemManufacturerImpl() {
+    String manufacturer = MODEM_MANUFACTURER;
+    thisModem().sendAT(GF("+CGMI"));  // 3GPP TS 27.007 standard
     String res;
-    if (thisModem().waitResponse(1000L, res) != 1) { return ""; }
-    // Do the replaces twice so we cover both \r and \r\n type endings
-    res.replace("\r\nOK\r\n", "");
-    res.replace("\rOK\r", "");
-    res.replace("\r\n", " ");
-    res.replace("\r", " ");
-    res.trim();
+    if (thisModem().waitResponse(1000L, res) != 1) { return manf; }
+    thisModem().cleanResponseString(res);
     return res;
   }
 
   // Gets the modem hardware version
-  String getModemHardwareVersionImpl() {
-    thisModem().sendAT(GF("CGMM"));
+  String getModemModelImpl() {
+    String model = MODEM_MODEL;
+    thisModem().sendAT(GF("+CGMM"));  // 3GPP TS 27.007 standard
     String res;
-    if (thisModem().waitResponse(1000L, res) != 1) { return ""; }
-    // Do the replaces twice so we cover both \r and \r\n type endings
-    res.replace("\r\nOK\r\n", "");
-    res.replace("\rOK\r", "");
-    res.replace("\r\n", " ");
-    res.replace("\r", " ");
-    res.trim();
+    if (thisModem().waitResponse(1000L, res) != 1) { return model; }
+    thisModem().cleanResponseString(res);
     return res;
   }
 
   // Gets the modem firmware version
-  String getModemFirmwareVersionImpl() {
-    thisModem().sendAT(GF("CGMR"));
+  String getModemRevisionImpl() {
+    thisModem().sendAT(GF("+CGMR"));  // 3GPP TS 27.007 standard
     String res;
-    if (thisModem().waitResponse(1000L, res) != 1) { return ""; }
-    // Do the replaces twice so we cover both \r and \r\n type endings
-    res.replace("\r\nOK\r\n", "");
-    res.replace("\rOK\r", "");
-    res.replace("\r\n", " ");
-    res.replace("\r", " ");
-    res.trim();
+    if (thisModem().waitResponse(1000L, res) != 1) { return "unknown"; }
+    thisModem().cleanResponseString(res);
+    return res;
+  }
+
+  // Gets the modem serial number
+  String getModemSerialNumberImpl() {
+    thisModem().sendAT(GF("+CGSN"));  // 3GPP TS 27.007 standard
+    String res;
+    if (thisModem().waitResponse(1000L, res) != 1) { return "unknown"; }
+    thisModem().cleanResponseString(res);
     return res;
   }
 
diff --git a/tools/AT_Debug/AT_Debug.ino b/tools/AT_Debug/AT_Debug.ino
index 65762e3..39d1a12 100644
--- a/tools/AT_Debug/AT_Debug.ino
+++ b/tools/AT_Debug/AT_Debug.ino
@@ -31,6 +31,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/tools/Diagnostics/Diagnostics.ino b/tools/Diagnostics/Diagnostics.ino
index 88e3a22..a601387 100644
--- a/tools/Diagnostics/Diagnostics.ino
+++ b/tools/Diagnostics/Diagnostics.ino
@@ -31,6 +31,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 
diff --git a/tools/FactoryReset/FactoryReset.ino b/tools/FactoryReset/FactoryReset.ino
index 27f137f..1bc8e7b 100644
--- a/tools/FactoryReset/FactoryReset.ino
+++ b/tools/FactoryReset/FactoryReset.ino
@@ -14,12 +14,7 @@
 // #define TINY_GSM_MODEM_SIM808
 // #define TINY_GSM_MODEM_SIM868
 // #define TINY_GSM_MODEM_SIM900
-// #define TINY_GSM_MODEM_SIM7000
-// #define TINY_GSM_MODEM_SIM7000SSL
-// #define TINY_GSM_MODEM_SIM7080
 // #define TINY_GSM_MODEM_SIM5360
-// #define TINY_GSM_MODEM_SIM7600
-// #define TINY_GSM_MODEM_A7672X
 // #define TINY_GSM_MODEM_UBLOX
 // #define TINY_GSM_MODEM_SARAR4
 // #define TINY_GSM_MODEM_M95
@@ -31,6 +26,7 @@
 // #define TINY_GSM_MODEM_MC60
 // #define TINY_GSM_MODEM_MC60E
 // #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_ESP32
 // #define TINY_GSM_MODEM_XBEE
 // #define TINY_GSM_MODEM_SEQUANS_MONARCH
 

From 6bb52e3ac858eac5db19577cbbe35f937bc393f3 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 09:38:29 -0400
Subject: [PATCH 081/100] Typo fix

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSIM70xx.h | 2 +-
 src/TinyGsmModem.tpp       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/TinyGsmClientSIM70xx.h b/src/TinyGsmClientSIM70xx.h
index fba11aa..568ffd0 100644
--- a/src/TinyGsmClientSIM70xx.h
+++ b/src/TinyGsmClientSIM70xx.h
@@ -81,7 +81,7 @@ class TinyGsmSim70xx : public TinyGsmModem<SIM70xxType>,
    */
  protected:
   bool factoryDefaultImpl() {
-    return false
+    return false;
   }
 
   /*
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index d438bf2..87d7093 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -451,7 +451,7 @@ class TinyGsmModem {
     String manufacturer = MODEM_MANUFACTURER;
     thisModem().sendAT(GF("+CGMI"));  // 3GPP TS 27.007 standard
     String res;
-    if (thisModem().waitResponse(1000L, res) != 1) { return manf; }
+    if (thisModem().waitResponse(1000L, res) != 1) { return manufacturer; }
     thisModem().cleanResponseString(res);
     return res;
   }

From 14f0975e035423823c76d74aa2c5e7eaa7d7bf78 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 11:11:39 -0400
Subject: [PATCH 082/100] Vebose read fix

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmModem.tpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 87d7093..1ebaf8b 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -394,15 +394,15 @@ class TinyGsmModem {
 #if defined TINY_GSM_DEBUG
         else if (data.endsWith(GFP(GSM_VERBOSE)) ||
                  data.endsWith(GFP(GSM_VERBOSE_2))) {
+          // check how long the new line is
+          // should be either 1 ('\r' or '\n') or 2 ("\r\n"))
+          int len_atnl = strnlen(AT_NL, 3);
+          // Read out the verbose message, until the last character of the new
+          // line
+          data += thisModem().stream.readStringUntil(AT_NL[len_atnl]);
 #ifdef TINY_GSM_DEBUG_DEEP
-          DBG(GF("Verbose details <<<"));
-#endif
-          // Read out the verbose message, until whichever type of new line
-          // comes first
-          thisModem().stream.findUntil(const_cast<char*>("\r"),
-                                       const_cast<char*>("\n"));
-#ifdef TINY_GSM_DEBUG_DEEP
-          DBG(GF(">>>"));
+          data.trim();
+          DBG(GF("Verbose details <<<"), data, GF(">>>"));
 #endif
           data = "";
         }

From 93d0adbfd8152a06447dad39f07566ff728a010f Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 12:09:07 -0400
Subject: [PATCH 083/100] Move down provider

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 examples/AllFunctions/AllFunctions.ino | 4 ++--
 src/TinyGsmClientA7672x.h              | 9 +++++++++
 src/TinyGsmClientBG96.h                | 9 +++++++++
 src/TinyGsmClientM95.h                 | 9 +++++++++
 src/TinyGsmClientMC60.h                | 9 +++++++++
 src/TinyGsmClientSIM5360.h             | 9 +++++++++
 src/TinyGsmClientSIM7600.h             | 9 +++++++++
 src/TinyGsmClientSIM800.h              | 9 +++++++++
 src/TinyGsmGPRS.tpp                    | 9 +--------
 9 files changed, 66 insertions(+), 10 deletions(-)

diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index bae2adb..01c5ce1 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -228,8 +228,8 @@ void loop() {
   String cop = modem.getOperator();
   DBG("Operator:", cop);
 
-  String prov = modem.getProvider();
-  DBG("Provider:", prov);
+  // String prov = modem.getProvider();
+  // DBG("Provider:", prov);
 
   IPAddress local = modem.localIP();
   DBG("Local IP:", local);
diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 4992eb9..47742da 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -378,6 +378,15 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return true;
   }
 
+  String getProviderImpl() {
+    sendAT(GF("+CSPN?"));
+    if (waitResponse(GF("+CSPN:")) != 1) { return ""; }
+    streamSkipUntil('"'); /* Skip mode and format */
+    String res = stream.readStringUntil('"');
+    waitResponse();
+    return res;
+  }
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmClientBG96.h b/src/TinyGsmClientBG96.h
index dac7ea3..7ee1959 100644
--- a/src/TinyGsmClientBG96.h
+++ b/src/TinyGsmClientBG96.h
@@ -316,6 +316,15 @@ class TinyGsmBG96 : public TinyGsmModem<TinyGsmBG96>,
     return true;
   }
 
+  String getProviderImpl() {
+    sendAT(GF("+QSPN?"));
+    if (waitResponse(GF("+QSPN:")) != 1) { return ""; }
+    streamSkipUntil('"');                      // Skip mode and format
+    String res = stream.readStringUntil('"');  // read the provider
+    waitResponse();                            // skip anything else
+    return res;
+  }
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmClientM95.h b/src/TinyGsmClientM95.h
index 0d2887a..0104392 100644
--- a/src/TinyGsmClientM95.h
+++ b/src/TinyGsmClientM95.h
@@ -334,6 +334,15 @@ class TinyGsmM95 : public TinyGsmModem<TinyGsmM95>,
     return waitResponse(60000L, GF("DEACT OK"), GF("ERROR")) == 1;
   }
 
+  String getProviderImpl() {
+    sendAT(GF("+QSPN?"));
+    if (waitResponse(GF("+QSPN:")) != 1) { return ""; }
+    streamSkipUntil('"');                      // Skip mode and format
+    String res = stream.readStringUntil('"');  // read the provider
+    waitResponse();                            // skip anything else
+    return res;
+  }
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmClientMC60.h b/src/TinyGsmClientMC60.h
index 1522e0d..1156068 100644
--- a/src/TinyGsmClientMC60.h
+++ b/src/TinyGsmClientMC60.h
@@ -307,6 +307,15 @@ class TinyGsmMC60 : public TinyGsmModem<TinyGsmMC60>,
     return waitResponse(60000L, GF("DEACT OK"), GF("ERROR")) == 1;
   }
 
+  String getProviderImpl() {
+    sendAT(GF("+QSPN?"));
+    if (waitResponse(GF("+QSPN:")) != 1) { return ""; }
+    streamSkipUntil('"');                      // Skip mode and format
+    String res = stream.readStringUntil('"');  // read the provider
+    waitResponse();                            // skip anything else
+    return res;
+  }
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 95b20ed..29970a9 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -400,6 +400,15 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
     return true;
   }
 
+  String getProviderImpl() {
+    sendAT(GF("+CSPN?"));
+    if (waitResponse(GF("+CSPN:")) != 1) { return ""; }
+    streamSkipUntil('"'); /* Skip mode and format */
+    String res = stream.readStringUntil('"');
+    waitResponse();
+    return res;
+  }
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index 70fea0a..d857eb2 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -389,6 +389,15 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
     return true;
   }
 
+  String getProviderImpl() {
+    sendAT(GF("+CSPN?"));
+    if (waitResponse(GF("+CSPN:")) != 1) { return ""; }
+    streamSkipUntil('"'); /* Skip mode and format */
+    String res = stream.readStringUntil('"');
+    waitResponse();
+    return res;
+  }
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmClientSIM800.h b/src/TinyGsmClientSIM800.h
index 2dca293..f3e3579 100644
--- a/src/TinyGsmClientSIM800.h
+++ b/src/TinyGsmClientSIM800.h
@@ -397,6 +397,15 @@ class TinyGsmSim800 : public TinyGsmModem<TinyGsmSim800>,
     return true;
   }
 
+  String getProviderImpl() {
+    sendAT(GF("+CSPN?"));
+    if (waitResponse(GF("+CSPN:")) != 1) { return ""; }
+    streamSkipUntil('"'); /* Skip mode and format */
+    String res = stream.readStringUntil('"');
+    waitResponse();
+    return res;
+  }
+
   /*
    * SIM card functions
    */
diff --git a/src/TinyGsmGPRS.tpp b/src/TinyGsmGPRS.tpp
index a657dc2..3535e8f 100644
--- a/src/TinyGsmGPRS.tpp
+++ b/src/TinyGsmGPRS.tpp
@@ -184,14 +184,7 @@ class TinyGsmGPRS {
     return res;
   }
 
-  String getProviderImpl() {
-    thisModem().sendAT(GF("+CSPN?"));
-    if (thisModem().waitResponse(GF("+CSPN:")) != 1) { return ""; }
-    thisModem().streamSkipUntil('"'); /* Skip mode and format */
-    String res = thisModem().stream.readStringUntil('"');
-    thisModem().waitResponse();
-    return res;
-  }
+  String getProviderImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
 };
 
 #endif  // SRC_TINYGSMGPRS_H_

From 2d87563106d835c84430595845b04bea21f53f35 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 12:11:07 -0400
Subject: [PATCH 084/100] Go to finish after verbose error output

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmModem.tpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 1ebaf8b..9dc535b 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -405,6 +405,7 @@ class TinyGsmModem {
           DBG(GF("Verbose details <<<"), data, GF(">>>"));
 #endif
           data = "";
+          goto finish;
         }
 #endif
         else if (thisModem().handleURCs(data)) {

From 6f0bb6e811db8b6e8e2a0ec2df5f48a899f16aed Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 12:37:50 -0400
Subject: [PATCH 085/100] Fix mix-up between PDP context identifier and
 connection identifier

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSIM7000SSL.h | 17 +++++++++++++----
 src/TinyGsmClientSIM7080.h    | 14 +++++++++++---
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/src/TinyGsmClientSIM7000SSL.h b/src/TinyGsmClientSIM7000SSL.h
index 0140e12..2170e49 100644
--- a/src/TinyGsmClientSIM7000SSL.h
+++ b/src/TinyGsmClientSIM7000SSL.h
@@ -372,7 +372,9 @@ class TinyGsmSim7000SSL
     if (ssl) {
       // set the ssl version
       // AT+CSSLCFG="SSLVERSION",<ctxindex>,<sslversion>
-      // <ctxindex> PDP context identifier
+      // <ctxindex> PDP context identifier - for reasons not understood by me,
+      //            use PDP context identifier of 0 for what we defined as 1 in
+      //            the gprsConnect function
       // <sslversion> 0: QAPI_NET_SSL_PROTOCOL_UNKNOWN
       //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
       //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
@@ -395,8 +397,11 @@ class TinyGsmSim7000SSL
     if (ssl) {
       // set the PDP context to apply SSL to
       // AT+CSSLCFG="CTXINDEX",<ctxindex>
-      // <ctxindex> PDP context identifier
-      // NOTE:  despite docs using caps, "ctxindex" must be in lower case
+      // <ctxindex> PDP context identifier - for reasons not understood by me,
+      //            use PDP context identifier of 0 for what we defined as 1 in
+      //            the gprsConnect function
+      // NOTE:  despite docs using "CRINDEX" in all caps, the module only
+      // accepts the command "ctxindex" and it must be in lower case
       sendAT(GF("+CSSLCFG=\"ctxindex\",0"));
       if (waitResponse(5000L, GF("+CSSLCFG:")) != 1) return false;
       streamSkipUntil('\n');  // read out the certificate information
@@ -418,8 +423,12 @@ class TinyGsmSim7000SSL
       waitResponse();
 
       // set the SSL SNI (server name indication)
+      // AT+CSSLCFG="SNI",<ctxindex>,<servername>
+      // <ctxindex> PDP context identifier - for reasons not understood by me,
+      //            use PDP context identifier of 0 for what we defined as 1 in
+      //            the gprsConnect function
       // NOTE:  despite docs using caps, "sni" must be in lower case
-      sendAT(GF("+CSSLCFG=\"sni\","), mux, ',', GF("\""), host, GF("\""));
+      sendAT(GF("+CSSLCFG=\"sni\",0,"), GF("\""), host, GF("\""));
       waitResponse();
     }
 
diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index bd32116..a3e52e4 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -425,7 +425,9 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     if (ssl) {
       // set the ssl version
       // AT+CSSLCFG="SSLVERSION",<ctxindex>,<sslversion>
-      // <ctxindex> PDP context identifier
+      // <ctxindex> PDP context identifier - for reasons not understood by me,
+      //            use PDP context identifier of 0 for what we defined as 1 in
+      //            the gprsConnect function
       // <sslversion> 0: QAPI_NET_SSL_PROTOCOL_UNKNOWN
       //              1: QAPI_NET_SSL_PROTOCOL_TLS_1_0
       //              2: QAPI_NET_SSL_PROTOCOL_TLS_1_1
@@ -448,7 +450,9 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     if (ssl) {
       // set the PDP context to apply SSL to
       // AT+CSSLCFG="CTXINDEX",<ctxindex>
-      // <ctxindex> PDP context identifier
+      // <ctxindex> PDP context identifier - for reasons not understood by me,
+      //            use PDP context identifier of 0 for what we defined as 1 in
+      //            the gprsConnect function
       // NOTE:  despite docs using "CRINDEX" in all caps, the module only
       // accepts the command "ctxindex" and it must be in lower case
       sendAT(GF("+CSSLCFG=\"ctxindex\",0"));
@@ -467,8 +471,12 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
       }
 
       // set the SSL SNI (server name indication)
+      // AT+CSSLCFG="SNI",<ctxindex>,<servername>
+      // <ctxindex> PDP context identifier - for reasons not understood by me,
+      //            use PDP context identifier of 0 for what we defined as 1 in
+      //            the gprsConnect function
       // NOTE:  despite docs using caps, "sni" must be in lower case
-      sendAT(GF("+CSSLCFG=\"sni\","), mux, ',', GF("\""), host, GF("\""));
+      sendAT(GF("+CSSLCFG=\"sni\",0,"), GF("\""), host, GF("\""));
       waitResponse();
     }
 

From c1bf5f0762d991e9a4ac8a0550d33a6856e26dd6 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 12:38:23 -0400
Subject: [PATCH 086/100] Try harder to turn off echo on 7080

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSIM7080.h | 40 ++++++++++++++++++++++++++++++++------
 1 file changed, 34 insertions(+), 6 deletions(-)

diff --git a/src/TinyGsmClientSIM7080.h b/src/TinyGsmClientSIM7080.h
index a3e52e4..8af5465 100644
--- a/src/TinyGsmClientSIM7080.h
+++ b/src/TinyGsmClientSIM7080.h
@@ -144,10 +144,22 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
     DBG(GF("### TinyGSM Version:"), TINYGSM_VERSION);
     DBG(GF("### TinyGSM Compiled Module:  TinyGsmClientSIM7080"));
 
-    if (!testAT()) { return false; }
-
-    sendAT(GF("E0"));  // Echo Off
-    if (waitResponse() != 1) { return false; }
+    bool gotATOK = false;
+    for (uint32_t start = millis(); millis() - start < 10000L;) {
+      sendAT(GF(""));
+      int8_t resp = waitResponse(200L, GFP(GSM_OK), GFP(GSM_ERROR), GF("AT"));
+      if (resp == 1) {
+        gotATOK = true;
+        break;
+      } else if (resp == 3) {
+        waitResponse(200L);  // get the OK
+        sendAT(GF("E0"));    // Echo Off
+        DBG(GF("## Turning off echo!"));
+        waitResponse(2000L);
+      }
+      delay(100);
+    }
+    if (!gotATOK) { return false; }
 
 #ifdef TINY_GSM_DEBUG
     sendAT(GF("+CMEE=2"));  // turn on verbose error codes
@@ -201,8 +213,24 @@ class TinyGsmSim7080 : public TinyGsmSim70xx<TinyGsmSim7080>,
  protected:
   bool restartImpl(const char* pin = nullptr) {
     bool success = true;
-    sendAT(GF("E0"));  // Echo Off
-    waitResponse();
+
+    bool gotATOK = false;
+    for (uint32_t start = millis(); millis() - start < 10000L;) {
+      sendAT(GF(""));
+      int8_t resp = waitResponse(200L, GFP(GSM_OK), GFP(GSM_ERROR), GF("AT"));
+      if (resp == 1) {
+        gotATOK = true;
+        break;
+      } else if (resp == 3) {
+        waitResponse(200L);  // get the OK
+        DBG(GF("## Turning off echo!"));
+        sendAT(GF("E0"));  // Echo Off
+        waitResponse(2000L);
+      }
+      delay(100);
+    }
+    if (!gotATOK) { return false; }
+
     sendAT(GF("+CREBOOT"));  // Reboot
     success &= waitResponse() == 1;
     waitResponse(30000L, GF("SMS Ready"));

From a72c8e37143e6f21fbed4208b3b4eb046b06a8da Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 12:40:14 -0400
Subject: [PATCH 087/100] Wrap

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 tools/Diagnostics/Diagnostics.ino | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/Diagnostics/Diagnostics.ino b/tools/Diagnostics/Diagnostics.ino
index a601387..d2b4849 100644
--- a/tools/Diagnostics/Diagnostics.ino
+++ b/tools/Diagnostics/Diagnostics.ino
@@ -159,7 +159,8 @@ void loop() {
     SerialMon.println(F(" Is your serial speed (baud rate) correct?"));
     SerialMon.println(F(" Is your modem powered on?"));
     SerialMon.println(F(" Do you use a good, stable power source?"));
-    SerialMon.println(F(" Try using File -> Examples -> TinyGSM -> tools -> AT_Debug to find correct configuration"));
+    SerialMon.println(F(" Try using File -> Examples -> TinyGSM -> tools -> "
+                        "AT_Debug to find correct configuration"));
     SerialMon.println(F("************************"));
     delay(10000);
     return;

From ada7cbc56590bbfef10538a1e0258fa9f82fe7a7 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 12:47:34 -0400
Subject: [PATCH 088/100] Revert bad override of A7672x setCertificates

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA7672x.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 47742da..0bc1dba 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -313,8 +313,8 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   // havetype like ".pem" or ".der".
   // The certificate like - const char ca_cert[] PROGMEM =  R"EOF(-----BEGIN...
   // len of certificate like - sizeof(ca_cert)
-  bool addCertificateImpl(const String& certificateName, const String& cert,
-                          const uint16_t len) {
+  bool addCertificate(const String& certificateName, const String& cert,
+                      const uint16_t len) {
     sendAT(GF("+CCERTDOWN="), certificateName, GF(","), len);
     if (waitResponse(GF(">")) != 1) { return 0; }
     stream.write(cert.c_str(), len);
@@ -322,7 +322,7 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
     return waitResponse() == 1;
   }
 
-  bool deleteCertificateImpl(const String& certificateName) {  // todo test
+  bool deleteCertificate(const String& certificateName) {  // todo test
     sendAT(GF("+CCERTDELE="), certificateName);
     return waitResponse() == 1;
   }

From 9111e6eabc6cb8abbe09c98dac3ef3b1eb534779 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 16:17:45 -0400
Subject: [PATCH 089/100] Fix test build

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 tools/test_build/test_build.ino | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/test_build/test_build.ino b/tools/test_build/test_build.ino
index ef5bcb6..1a9858d 100644
--- a/tools/test_build/test_build.ino
+++ b/tools/test_build/test_build.ino
@@ -166,7 +166,9 @@ void loop() {
 
 // Test the GPS functions
 #if defined(TINY_GSM_MODEM_HAS_GPS) && not defined(__AVR_ATmega32U4__)
+#if !defined(TINY_GSM_MODEM_SARAR5)  // not needed for this module
   modem.enableGPS();
+#endif
   modem.getGPSraw();
   float latitude  = -9999;
   float longitude = -9999;

From 66ec8ffac310b0778e8d74c4e867625c29ebbe3e Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 16:26:24 -0400
Subject: [PATCH 090/100] Fix get versions for XBee

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientXBee.h | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index aaead26..e35184f 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -413,15 +413,22 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
   }
 
   // Gets the modem hardware version
-  String getModemModelImpl() {
+  String getModemHardwareVersion() {
     return sendATGetString(GF("HV"));
   }
 
   // Gets the modem firmware version
-  String getModemRevisionImpl() {
+  String getModemFirmwareVersion() {
     return sendATGetString(GF("VR"));
   }
 
+  // Gets the modem combined version
+  String getModemRevisionImpl() {
+    String hw_ver = getModemHardwareVersion();
+    String fw_ver = getModemFirmwareVersion();
+    return hw_ver + String(" ") + fw_ver;
+  }
+
   bool setBaudImpl(uint32_t baud) {
     XBEE_COMMAND_START_DECORATOR(5, false)
     bool changesMade = false;

From 1addac7c7b16c36d9dc02484b8e7119e3b89d2fd Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Thu, 23 May 2024 16:42:18 -0400
Subject: [PATCH 091/100] No disable GPS on SARA-R5

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 tools/test_build/test_build.ino | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tools/test_build/test_build.ino b/tools/test_build/test_build.ino
index 1a9858d..a278ec2 100644
--- a/tools/test_build/test_build.ino
+++ b/tools/test_build/test_build.ino
@@ -166,7 +166,7 @@ void loop() {
 
 // Test the GPS functions
 #if defined(TINY_GSM_MODEM_HAS_GPS) && not defined(__AVR_ATmega32U4__)
-#if !defined(TINY_GSM_MODEM_SARAR5)  // not needed for this module
+#if !defined(TINY_GSM_MODEM_SARAR5)  // not available for this module
   modem.enableGPS();
 #endif
   modem.getGPSraw();
@@ -186,8 +186,10 @@ void loop() {
   modem.getGPS(&latitude, &longitude);
   modem.getGPS(&latitude, &longitude, &speed, &alt, &vsat, &usat, &acc, &year,
                &month, &day, &hour, &minute, &second);
+#if !defined(TINY_GSM_MODEM_SARAR5)  // not available for this module
   modem.disableGPS();
 #endif
+#endif
 
 // Test the Network time function
 #if defined(TINY_GSM_MODEM_HAS_NTP) && not defined(__AVR_ATmega32U4__)

From cdfe99a696cb2c28b1b43a35e8ea2bd9214091e0 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 24 May 2024 12:03:05 -0400
Subject: [PATCH 092/100] Certificate function input change

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientA7672x.h | 14 +++++++-------
 src/TinyGsmSSL.tpp        | 21 ++++++++++++++++++---
 2 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/src/TinyGsmClientA7672x.h b/src/TinyGsmClientA7672x.h
index 0bc1dba..b470ac4 100644
--- a/src/TinyGsmClientA7672x.h
+++ b/src/TinyGsmClientA7672x.h
@@ -142,16 +142,16 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
         : GsmClientA7672X(modem, mux) {}
 
    public:
-    bool addCertificate(const String& certificateName, const String& cert,
+    bool addCertificate(const char* certificateName, const char* cert,
                         const uint16_t len) {
       return at->addCertificate(certificateName, cert, len);
     }
 
-    bool setCertificate(const String& certificateName) {
+    bool setCertificate(const char* certificateName) {
       return at->setCertificate(certificateName, mux);
     }
 
-    bool deleteCertificate(const String& certificateName) {
+    bool deleteCertificate(const char* certificateName) {
       return at->deleteCertificate(certificateName);
     }
 
@@ -313,16 +313,16 @@ class TinyGsmA7672X : public TinyGsmModem<TinyGsmA7672X>,
   // havetype like ".pem" or ".der".
   // The certificate like - const char ca_cert[] PROGMEM =  R"EOF(-----BEGIN...
   // len of certificate like - sizeof(ca_cert)
-  bool addCertificate(const String& certificateName, const String& cert,
+  bool addCertificate(const char* certificateName, const char* cert,
                       const uint16_t len) {
     sendAT(GF("+CCERTDOWN="), certificateName, GF(","), len);
-    if (waitResponse(GF(">")) != 1) { return 0; }
-    stream.write(cert.c_str(), len);
+    if (waitResponse(GF(">")) != 1) { return false; }
+    stream.write(cert, len);
     stream.flush();
     return waitResponse() == 1;
   }
 
-  bool deleteCertificate(const String& certificateName) {  // todo test
+  bool deleteCertificate(const char* certificateName) {  // todo test
     sendAT(GF("+CCERTDELE="), certificateName);
     return waitResponse() == 1;
   }
diff --git a/src/TinyGsmSSL.tpp b/src/TinyGsmSSL.tpp
index 045f4bc..a0f8aa4 100644
--- a/src/TinyGsmSSL.tpp
+++ b/src/TinyGsmSSL.tpp
@@ -27,8 +27,20 @@ class TinyGsmSSL {
   bool addCertificate(const char* filename) {
     return thisModem().addCertificateImpl(filename);
   }
-  bool deleteCertificate() {
-    return thisModem().deleteCertificateImpl();
+  bool addCertificate(const String& filename) {
+    return addCertificate(filename.c_str());
+  }
+  bool addCertificate(const char* certificateName, const char* cert,
+                      const uint16_t len) {
+    return thisModem().addCertificateImpl(certificateName, cert, len);
+  }
+  bool addCertificate(const String& certificateName, const String& cert,
+                      const uint16_t len) {
+    return addCertificate(certificateName.c_str(), cert.c_str(), len);
+  }
+
+  bool deleteCertificate(const char* filename) {
+    return thisModem().deleteCertificateImpl(filename);
   }
 
   bool setCertificate(const String& certificateName, const uint8_t mux = 0) {
@@ -60,7 +72,10 @@ class TinyGsmSSL {
    */
  protected:
   bool addCertificateImpl(const char* filename) TINY_GSM_ATTR_NOT_IMPLEMENTED;
-  bool deleteCertificateImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  bool addCertificateImpl(const char* certificateName, const char* cert,
+                          const uint16_t len) TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  bool
+  deleteCertificateImpl(const char* filename) TINY_GSM_ATTR_NOT_IMPLEMENTED;
 
   String certificates[muxCount];
 };

From c1a0c4e3e182d41e53b8cfb4cb8870e884becd7f Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 24 May 2024 12:03:25 -0400
Subject: [PATCH 093/100] Fix some warnings

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientSIM5360.h        | 1 +
 src/TinyGsmClientSequansMonarch.h | 4 ++--
 src/TinyGsmTime.tpp               | 4 ++++
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index 29970a9..a0beded 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -526,6 +526,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
       if (alt != nullptr) *alt = ialt;
       if (vsat != nullptr) *vsat = ivsat;
       if (usat != nullptr) *usat = iusat;
+      if (accuracy != nullptr) *accuracy = -9999;
       if (iyear < 2000) iyear += 2000;
       if (year != nullptr) *year = iyear;
       if (month != nullptr) *month = imonth;
diff --git a/src/TinyGsmClientSequansMonarch.h b/src/TinyGsmClientSequansMonarch.h
index 2698008..b11358b 100644
--- a/src/TinyGsmClientSequansMonarch.h
+++ b/src/TinyGsmClientSequansMonarch.h
@@ -302,8 +302,8 @@ class TinyGsmSequansMonarch
     return waitResponse() == 1;
   }
 
-  bool setPhoneFunctionality(uint8_t fun,
-                             bool reset = false) TINY_GSM_ATTR_NOT_IMPLEMENTED;
+  bool setPhoneFunctionalityImpl(uint8_t fun, bool reset = false)
+      TINY_GSM_ATTR_NOT_IMPLEMENTED;
 
   /*
    * Generic network functions
diff --git a/src/TinyGsmTime.tpp b/src/TinyGsmTime.tpp
index e74742c..6b8d4b3 100644
--- a/src/TinyGsmTime.tpp
+++ b/src/TinyGsmTime.tpp
@@ -117,6 +117,10 @@ class TinyGsmTime {
     thisModem().waitResponse();
     return true;
   }
+
+  bool getNetworkUTCTimeImpl(int* year, int* month, int* day, int* hour,
+                             int* minute, int* second,
+                             float* timezone) TINY_GSM_ATTR_NOT_IMPLEMENTED;
 };
 
 #endif  // SRC_TINYGSMTIME_H_

From 27e14e6292672acccc4ea754d63f75e410146f65 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 24 May 2024 12:05:53 -0400
Subject: [PATCH 094/100] Update test build

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 examples/AllFunctions/AllFunctions.ino | 128 +++++++++++----------
 tools/test_build/test_build.ino        | 152 ++++++++++++++++---------
 2 files changed, 168 insertions(+), 112 deletions(-)

diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index 01c5ce1..ecd3156 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -139,7 +139,7 @@ void setup() {
   // !!!!!!!!!!!
 
   DBG("Wait...");
-  delay(6000);
+  delay(6000L);
 
   // Set GSM module baud rate
   TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
@@ -183,7 +183,7 @@ void loop() {
   if (GSM_PIN && modem.getSimStatus() != 3) { modem.simUnlock(GSM_PIN); }
 #endif
 
-#if TINY_GSM_TEST_WIFI
+#if TINY_GSM_TEST_WIFI && defined(TINY_GSM_MODEM_HAS_WIFI)
   DBG("Setting SSID/password...");
   if (!modem.networkConnect(wifiSSID, wifiPass)) {
     DBG(" fail");
@@ -193,7 +193,7 @@ void loop() {
   SerialMon.println(" success");
 #endif
 
-#if TINY_GSM_TEST_GPRS && defined TINY_GSM_MODEM_XBEE
+#if TINY_GSM_TEST_GPRS && defined(TINY_GSM_MODEM_XBEE)
   // The XBee must run the gprsConnect function BEFORE waiting for network!
   modem.gprsConnect(apn, gprsUser, gprsPass);
 #endif
@@ -349,6 +349,7 @@ void loop() {
   }
 #endif
 
+// Test the SMS functions
 #if TINY_GSM_TEST_SMS && defined TINY_GSM_MODEM_HAS_SMS && defined SMS_TARGET
   res = modem.sendSMS(SMS_TARGET, String("Hello from ") + imei);
   DBG("SMS:", res ? "OK" : "fail");
@@ -365,24 +366,27 @@ void loop() {
 
 #endif
 
+// Test the GSM location functions
 #if TINY_GSM_TEST_GSM_LOCATION && defined TINY_GSM_MODEM_HAS_GSM_LOCATION
-  float lat      = 0;
-  float lon      = 0;
-  float accuracy = 0;
-  int   year     = 0;
-  int   month    = 0;
-  int   day      = 0;
-  int   hour     = 0;
-  int   min      = 0;
-  int   sec      = 0;
+  float gsm_latitude  = 0;
+  float gsm_longitude = 0;
+  float gsm_accuracy  = 0;
+  int   gsm_year      = 0;
+  int   gsm_month     = 0;
+  int   gsm_day       = 0;
+  int   gsm_hour      = 0;
+  int   gsm_minute    = 0;
+  int   gsm_second    = 0;
   for (int8_t i = 15; i; i--) {
     DBG("Requesting current GSM location");
-    if (modem.getGsmLocation(&lat, &lon, &accuracy, &year, &month, &day, &hour,
-                             &min, &sec)) {
-      DBG("Latitude:", String(lat, 8), "\tLongitude:", String(lon, 8));
-      DBG("Accuracy:", accuracy);
-      DBG("Year:", year, "\tMonth:", month, "\tDay:", day);
-      DBG("Hour:", hour, "\tMinute:", min, "\tSecond:", sec);
+    if (modem.getGsmLocation(&gsm_latitude, &gsm_longitude, &gsm_accuracy,
+                             &gsm_year, &gsm_month, &gsm_day, &gsm_hour,
+                             &gsm_minute, &gsm_second)) {
+      DBG("Latitude:", String(gsm_latitude, 8),
+          "\tLongitude:", String(gsm_longitude, 8));
+      DBG("Accuracy:", gsm_accuracy);
+      DBG("Year:", gsm_year, "\tMonth:", gsm_month, "\tDay:", gsm_day);
+      DBG("Hour:", gsm_hour, "\tMinute:", gsm_minute, "\tSecond:", gsm_second);
       break;
     } else {
       DBG("Couldn't get GSM location, retrying in 15s.");
@@ -394,35 +398,38 @@ void loop() {
   DBG("GSM Based Location String:", location);
 #endif
 
+// Test the GPS functions
 #if TINY_GSM_TEST_GPS && defined TINY_GSM_MODEM_HAS_GPS
   DBG("Enabling GPS/GNSS/GLONASS and waiting 15s for warm-up");
-#if !defined(TINY_GSM_MODEM_SARAR5)
+#if !defined(TINY_GSM_MODEM_SARAR5)  // not needed for this module
   modem.enableGPS();
 #endif
   delay(15000L);
-  float lat2      = 0;
-  float lon2      = 0;
-  float speed2    = 0;
-  float alt2      = 0;
-  int   vsat2     = 0;
-  int   usat2     = 0;
-  float accuracy2 = 0;
-  int   year2     = 0;
-  int   month2    = 0;
-  int   day2      = 0;
-  int   hour2     = 0;
-  int   min2      = 0;
-  int   sec2      = 0;
+  float gps_latitude  = 0;
+  float gps_longitude = 0;
+  float gps_speed     = 0;
+  float gps_altitude  = 0;
+  int   gps_vsat      = 0;
+  int   gps_usat      = 0;
+  float gps_accuracy  = 0;
+  int   gps_year      = 0;
+  int   gps_month     = 0;
+  int   gps_day       = 0;
+  int   gps_hour      = 0;
+  int   gps_minute    = 0;
+  int   gps_second    = 0;
   for (int8_t i = 15; i; i--) {
     DBG("Requesting current GPS/GNSS/GLONASS location");
-    if (modem.getGPS(&lat2, &lon2, &speed2, &alt2, &vsat2, &usat2, &accuracy2,
-                     &year2, &month2, &day2, &hour2, &min2, &sec2)) {
-      DBG("Latitude:", String(lat2, 8), "\tLongitude:", String(lon2, 8));
-      DBG("Speed:", speed2, "\tAltitude:", alt2);
-      DBG("Visible Satellites:", vsat2, "\tUsed Satellites:", usat2);
-      DBG("Accuracy:", accuracy2);
-      DBG("Year:", year2, "\tMonth:", month2, "\tDay:", day2);
-      DBG("Hour:", hour2, "\tMinute:", min2, "\tSecond:", sec2);
+    if (modem.getGPS(&gps_latitude, &gps_longitude, &gps_speed, &gps_altitude,
+                     &gps_vsat, &gps_usat, &gps_accuracy, &gps_year, &gps_month,
+                     &gps_day, &gps_hour, &gps_minute, &gps_second)) {
+      DBG("Latitude:", String(gps_latitude, 8),
+          "\tLongitude:", String(gps_longitude, 8));
+      DBG("Speed:", gps_speed, "\tAltitude:", gps_altitude);
+      DBG("Visible Satellites:", gps_vsat, "\tUsed Satellites:", gps_usat);
+      DBG("Accuracy:", gps_accuracy);
+      DBG("Year:", gps_year, "\tMonth:", gps_month, "\tDay:", gps_day);
+      DBG("Hour:", gps_hour, "\tMinute:", gps_minute, "\tSecond:", gps_second);
       break;
     } else {
       DBG("Couldn't get GPS/GNSS/GLONASS location, retrying in 15s.");
@@ -431,31 +438,34 @@ void loop() {
   }
   DBG("Retrieving GPS/GNSS/GLONASS location again as a string");
   String gps_raw = modem.getGPSraw();
+#if !defined(TINY_GSM_MODEM_SARAR5)  // not available for this module
   DBG("GPS/GNSS Based Location String:", gps_raw);
   DBG("Disabling GPS");
   modem.disableGPS();
 #endif
+#endif
 
+// Test the Network time functions
 #if TINY_GSM_TEST_NTP && defined TINY_GSM_MODEM_HAS_NTP
   DBG("Asking modem to sync with NTP");
-  modem.NTPServerSync("132.163.96.5", 20);
+  modem.NTPServerSync("pool.ntp.org", 20);
 #endif
 
 #if TINY_GSM_TEST_TIME && defined TINY_GSM_MODEM_HAS_TIME
-  int   year3    = 0;
-  int   month3   = 0;
-  int   day3     = 0;
-  int   hour3    = 0;
-  int   min3     = 0;
-  int   sec3     = 0;
-  float timezone = 0;
+  int   ntp_year     = 0;
+  int   ntp_month    = 0;
+  int   ntp_day      = 0;
+  int   ntp_hour     = 0;
+  int   ntp_min      = 0;
+  int   ntp_sec      = 0;
+  float ntp_timezone = 0;
   for (int8_t i = 5; i; i--) {
     DBG("Requesting current network time");
-    if (modem.getNetworkTime(&year3, &month3, &day3, &hour3, &min3, &sec3,
-                             &timezone)) {
-      DBG("Year:", year3, "\tMonth:", month3, "\tDay:", day3);
-      DBG("Hour:", hour3, "\tMinute:", min3, "\tSecond:", sec3);
-      DBG("Timezone:", timezone);
+    if (modem.getNetworkTime(&ntp_year, &ntp_month, &ntp_day, &ntp_hour,
+                             &ntp_min, &ntp_sec, &ntp_timezone)) {
+      DBG("Year:", ntp_year, "\tMonth:", ntp_month, "\tDay:", ntp_day);
+      DBG("Hour:", ntp_hour, "\tMinute:", ntp_min, "\tSecond:", ntp_sec);
+      DBG("Timezone:", ntp_timezone);
       break;
     } else {
       DBG("Couldn't get network time, retrying in 15s.");
@@ -467,16 +477,18 @@ void loop() {
   DBG("Current Network Time:", time);
 #endif
 
+// Test Battery functions
 #if TINY_GSM_TEST_BATTERY && defined TINY_GSM_MODEM_HAS_BATTERY
-  uint8_t  chargeState = -99;
-  int8_t   percent     = -99;
-  uint16_t milliVolts  = -9999;
-  modem.getBattStats(chargeState, percent, milliVolts);
+  uint8_t  chargeState   = -99;
+  int8_t   chargePercent = -99;
+  uint16_t milliVolts    = -9999;
+  modem.getBattStats(chargeState, chargePercent, milliVolts);
   DBG("Battery charge state:", chargeState);
-  DBG("Battery charge 'percent':", percent);
+  DBG("Battery charge 'percent':", chargePercent);
   DBG("Battery voltage:", milliVolts / 1000.0F);
 #endif
 
+// Test temperature functions
 #if TINY_GSM_TEST_TEMPERATURE && defined TINY_GSM_MODEM_HAS_TEMPERATURE
   float temp = modem.getTemperature();
   DBG("Chip temperature:", temp);
diff --git a/tools/test_build/test_build.ino b/tools/test_build/test_build.ino
index a278ec2..b0e37de 100644
--- a/tools/test_build/test_build.ino
+++ b/tools/test_build/test_build.ino
@@ -24,13 +24,21 @@ void loop() {
 
   modem.getModemInfo();
   modem.getModemName();
+  modem.getModemManufacturer();
+  modem.getModemModel();
+  modem.getModemRevision();
   modem.factoryDefault();
 
+#if not defined(TINY_GSM_MODEM_ESP8266) && not defined(TINY_GSM_MODEM_ESP32)
+  modem.getModemSerialNumber();
+#endif
+
   // Test Power functions
   modem.restart();
   // modem.sleepEnable();  // Not available for all modems
-  // modem.radioOff();  // Not available for all modems
+  // modem.radioOff();     // Not available for all modems
   modem.poweroff();
+  // modem.setPhoneFunctionality(1, 1);  // Not available for all modems
 
   // Test generic network functions
   modem.getRegistrationStatus();
@@ -42,25 +50,27 @@ void loop() {
   modem.getLocalIP();
   modem.localIP();
 
+// Test WiFi Functions
+#if defined(TINY_GSM_MODEM_HAS_WIFI)
+  modem.networkConnect("mySSID", "mySSIDPassword");
+  modem.networkDisconnect();
+#endif
+
 // Test the GPRS and SIM card functions
 #if defined(TINY_GSM_MODEM_HAS_GPRS)
   modem.simUnlock("1234");
-  modem.getSimCCID();
-  modem.getIMEI();
-  modem.getIMSI();
   modem.getSimStatus();
 
   modem.gprsConnect("myAPN");
   modem.gprsConnect("myAPN", "myUser");
   modem.gprsConnect("myAPN", "myAPNUser", "myAPNPass");
   modem.gprsDisconnect();
-  modem.getOperator();
-#endif
 
-// Test WiFi Functions
-#if defined(TINY_GSM_MODEM_HAS_WIFI)
-  modem.networkConnect("mySSID", "mySSIDPassword");
-  modem.networkDisconnect();
+  modem.getSimCCID();
+  modem.getIMEI();
+  modem.getIMSI();
+  modem.getOperator();
+  // modem.getProvider();  // Not available for all modems
 #endif
 
   char server[]   = "somewhere";
@@ -92,8 +102,19 @@ void loop() {
   client.stop();
 
 #if defined(TINY_GSM_MODEM_HAS_SSL)
-  // modem.addCertificate();  // not yet impemented
-  // modem.deleteCertificate();  // not yet impemented
+  // modem.addCertificate("certificateName");  // Not available for all modems
+  // modem.addCertificate(
+  //     String("certificateName"));  // Not available for all modems
+  // modem.addCertificate("certificateName", "certificate_content",
+  //                      20);  // Not available for all modems
+  // modem.addCertificate(String("certificateName"),
+  // String("certificate_content"),
+  //                      20);                    // Not available for all
+  //                      modems
+  // modem.deleteCertificate("certificateName");  // Not available for all
+  // modems
+  modem.setCertificate("certificateName", 0);
+  modem.setCertificate(String("certificateName"), 0);
   TinyGsmClientSecure client_secure(modem);
   TinyGsmClientSecure client_secure2(modem);
   TinyGsmClientSecure client_secure3(modem, 1);
@@ -149,75 +170,98 @@ void loop() {
 #if defined(TINY_GSM_MODEM_HAS_GSM_LOCATION) && not defined(__AVR_ATmega32U4__)
   modem.getGsmLocationRaw();
   modem.getGsmLocation();
-  float glatitude  = -9999;
-  float glongitude = -9999;
-  float gacc       = 0;
-  int   gyear      = 0;
-  int   gmonth     = 0;
-  int   gday       = 0;
-  int   ghour      = 0;
-  int   gmin       = 0;
-  int   gsec       = 0;
-  modem.getGsmLocation(&glatitude, &glongitude);
-  modem.getGsmLocation(&glatitude, &glongitude, &gacc, &gyear, &gmonth, &gday,
-                       &ghour, &gmin, &gsec);
-  modem.getGsmLocationTime(&gyear, &gmonth, &gday, &ghour, &gmin, &gsec);
+  float gsm_latitude  = 0;
+  float gsm_longitude = 0;
+  float gsm_accuracy  = 0;
+  int   gsm_year      = 0;
+  int   gsm_month     = 0;
+  int   gsm_day       = 0;
+  int   gsm_hour      = 0;
+  int   gsm_minute    = 0;
+  int   gsm_second    = 0;
+  modem.getGsmLocation(&gsm_latitude, &gsm_longitude);
+  modem.getGsmLocation(&gsm_latitude, &gsm_longitude, &gsm_accuracy, &gsm_year,
+                       &gsm_month, &gsm_day, &gsm_hour, &gsm_minute,
+                       &gsm_second);
+  modem.getGsmLocationTime(&gsm_year, &gsm_month, &gsm_day, &gsm_hour,
+                           &gsm_minute, &gsm_second);
+  modem.getGsmLocation();
 #endif
 
 // Test the GPS functions
 #if defined(TINY_GSM_MODEM_HAS_GPS) && not defined(__AVR_ATmega32U4__)
+  // modem.setGNSSMode(1, true);        // Not available for all modems
+  // modem.getGNSSMode();               // Not available for all modems
 #if !defined(TINY_GSM_MODEM_SARAR5)  // not available for this module
   modem.enableGPS();
 #endif
+  float gps_latitude  = 0;
+  float gps_longitude = 0;
+  float gps_speed     = 0;
+  float gps_altitude  = 0;
+  int   gps_vsat      = 0;
+  int   gps_usat      = 0;
+  float gps_accuracy  = 0;
+  int   gps_year      = 0;
+  int   gps_month     = 0;
+  int   gps_day       = 0;
+  int   gps_hour      = 0;
+  int   gps_minute    = 0;
+  int   gps_second    = 0;
+  modem.getGPS(&gps_latitude, &gps_longitude);
+  modem.getGPS(&gps_latitude, &gps_longitude, &gps_speed, &gps_altitude,
+               &gps_vsat, &gps_usat, &gps_accuracy, &gps_year, &gps_month,
+               &gps_day, &gps_hour, &gps_minute, &gps_second);
   modem.getGPSraw();
-  float latitude  = -9999;
-  float longitude = -9999;
-  float speed     = 0;
-  float alt       = 0;
-  int   vsat      = 0;
-  int   usat      = 0;
-  float acc       = 0;
-  int   year      = 0;
-  int   month     = 0;
-  int   day       = 0;
-  int   hour      = 0;
-  int   minute    = 0;
-  int   second    = 0;
-  modem.getGPS(&latitude, &longitude);
-  modem.getGPS(&latitude, &longitude, &speed, &alt, &vsat, &usat, &acc, &year,
-               &month, &day, &hour, &minute, &second);
 #if !defined(TINY_GSM_MODEM_SARAR5)  // not available for this module
   modem.disableGPS();
 #endif
 #endif
 
-// Test the Network time function
+// Test the Network time functions
 #if defined(TINY_GSM_MODEM_HAS_NTP) && not defined(__AVR_ATmega32U4__)
   modem.NTPServerSync("pool.ntp.org", 3);
+  // modem.ShowNTPError(1);  // Not available for all modems
 #endif
 
 // Test the Network time function
 #if defined(TINY_GSM_MODEM_HAS_TIME) && not defined(__AVR_ATmega32U4__)
   modem.getGSMDateTime(DATE_FULL);
-  int   year3    = 0;
-  int   month3   = 0;
-  int   day3     = 0;
-  int   hour3    = 0;
-  int   min3     = 0;
-  int   sec3     = 0;
-  float timezone = 0;
-  modem.getNetworkTime(&year3, &month3, &day3, &hour3, &min3, &sec3, &timezone);
+  int   ntp_year     = 0;
+  int   ntp_month    = 0;
+  int   ntp_day      = 0;
+  int   ntp_hour     = 0;
+  int   ntp_min      = 0;
+  int   ntp_sec      = 0;
+  float ntp_timezone = 0;
+  modem.getNetworkTime(&ntp_year, &ntp_month, &ntp_day, &ntp_hour, &ntp_min,
+                       &ntp_sec, &ntp_timezone);
+  // modem.getNetworkUTCTime(&ntp_year, &ntp_month, &ntp_day, &ntp_hour,
+  // &ntp_min,
+  //                         &ntp_sec,
+  //                         &ntp_timezone);  // Not available for all modems
+#endif
+
+// Test bluetooth functions
+#if defined(TINY_GSM_MODEM_HAS_BLUETOOTH)
+  modem.enableBluetooth();
+  modem.disableBluetooth();
+  modem.setBluetoothVisibility(true);
+  modem.setBluetoothHostName("bluetooth");
 #endif
 
 // Test Battery functions
 #if defined(TINY_GSM_MODEM_HAS_BATTERY)
-  uint8_t  chargeState   = 0;
-  int8_t   chargePercent = 0;
-  uint16_t milliVolts    = 0;
+  // modem.getBattVoltage();      // Not available for all modems
+  // modem.getBattPercent();      // Not available for all modems
+  // modem.getBattChargeState();  // Not available for all modems
+  uint8_t  chargeState   = -99;
+  int8_t   chargePercent = -99;
+  uint16_t milliVolts    = -9999;
   modem.getBattStats(chargeState, chargePercent, milliVolts);
 #endif
 
-// Test the temperature function
+// Test temperature functions
 #if defined(TINY_GSM_MODEM_HAS_TEMPERATURE)
   modem.getTemperature();
 #endif

From b982d17b947a4e23498bd363b5a930133326f0fb Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 24 May 2024 12:40:46 -0400
Subject: [PATCH 095/100] Bump version, add a ChangeLog

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .github/ISSUE_TEMPLATE.md |  2 +-
 ChangeLog.md              | 59 +++++++++++++++++++++++++++++++++++++++
 README.md                 | 13 +++++++--
 library.json              |  2 +-
 library.properties        |  2 +-
 src/TinyGsmCommon.h       |  5 +++-
 6 files changed, 76 insertions(+), 7 deletions(-)
 create mode 100644 ChangeLog.md

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index f98ab0f..a011a11 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -25,7 +25,7 @@ with your board before submitting any issues.
 
 Modem: <!-- Brand, model, variant, firmware version, ie Quectel BG96 Revision: BG96MAR02A07M1G -->
 Main processor board: <!-- Uno, Zero, ESP32, Particle, etc -->
-TinyGSM version: <!-- always try to use the latest (0.11.8) -->
+TinyGSM version: <!-- always try to use the latest (0.12.0) -->
 Code: <!-- Example name or paste in your code -->
 
 ### Scenario, steps to reproduce
diff --git a/ChangeLog.md b/ChangeLog.md
new file mode 100644
index 0000000..20272e5
--- /dev/null
+++ b/ChangeLog.md
@@ -0,0 +1,59 @@
+# ChangeLog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and its stricter, better defined, brother [Common Changelog](https://common-changelog.org/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+***
+
+
+## [Unreleased]
+****
+### Changed
+
+### Added
+
+### Removed
+
+### Fixed
+
+***
+
+
+## [v0.12.0]
+
+### Changed
+- Moved bulk of waitResponse function to modem template and gave modems handleURCs fxn
+- Moved option in waitResponse for verbose outputs.
+- setBaud now returns a bool
+- Replace new line consts with defines and renamed to AT_NL
+- Renamed all RegStatus enums to be unique
+- Replaced `NULL` with `nullptr` and replaced c-style casts.
+- Moved setCertificates function and the certificate name matrix to the SSL template.
+- Changed inputs for (unimplemented) SSL certificate functions.
+- All modems will now return the pre-defined manufacturer and model in the name if the function to get the internal name fails.
+- Cleaned up code for getting modem names.
+
+### Added
+- Added support for SSL for the Quentcel BG95 and BG96 from [Aurelien BOUIN](https://github.com/aurelihein) and [George O'Connor](https://github.com/georgeman93)
+- Added support for UBLOX SARA-R5 from [Sebastian Bergner](https://github.com/sebastianbergner)
+- Added support for SIMCOM A7672X from [Giovanni de Rosso Unruh](https://github.com/giovannirosso)
+- Added SIM5320 GPS location from [Bengarman](https://github.com/Bengarman)
+- Added functions `getModemSerialNumber`, `getModemModel`, and `getModemRevision`.
+- Added deep debugging option
+- Added documentation to the FIFO class
+
+### Removed
+- Removed non-functional factory reset from SIM70xx series
+
+### Fixed
+- Removed extra wait on SIM7000 from [Mikael Fredriksson](https://github.com/Gelemikke)
+- Fix status returns on ESP8266/ESP32 AT commands
+- Fix length of HEX for Sequans Monarch
+- Fix SIM7600 password then user when cid is set from [github0013](https://github.com/github0013)
+- Fix cardinal points in location by gps for SIM7600 from [Juxn3](https://github.com/Juxn3)
+- Fix NTP server sync for SIM70xx models from [Gonzalo Brusco](https://github.com/gonzabrusco)
+- Fixed SIM70xx inheritance
+
+***
diff --git a/README.md b/README.md
index 90cfafb..4b45b8e 100644
--- a/README.md
+++ b/README.md
@@ -84,12 +84,15 @@ TinyGSM also pulls data gently from the modem (whenever possible), so it can ope
 - Quectel MC60 ***(alpha)***
 
 ### Supported boards/modules
+- EnviroDIY LTE Bee, WiFi Bee
 - Arduino MKR GSM 1400
-- GPRSbee
+- Sodaq GPRSbee, uBee
 - Microduino GSM
-- Adafruit FONA (Mini Cellular GSM Breakout)
-- Adafruit FONA 800/808 Shield
+- Adafruit FONA Mini Cellular GSM Breakout, 800/808 Shield, FONA 3G
 - Industruino GSM
+- Dragino NB-IoT Bee
+- Digi XBee S6B, XBee LTE Cat 1, XBee3 LTE Cat 1, XBee3 CatM
+- Nimbelink Skywire/Airgain NL-SW-LTE-QBG96, NL-SW-LTE-QBG95
 - RAK WisLTE ***(alpha)***
 - ... other modules, based on supported modems. Some boards require [**special configuration**](https://github.com/vshymanskyy/TinyGSM/wiki/Board-configuration).
 
@@ -173,6 +176,10 @@ Watch this repo for new updates! And of course, contributions are welcome ;)
     - [V1pr](https://github.com/V1pr)
 - Quectel M95
     - [replicadeltd](https://github.com/replicadeltd)
+- UBLOX SARA-R5
+  - [Sebastian Bergner](https://github.com/sebastianbergner)
+- SIMCOM A7672X
+  - [Giovanni de Rosso Unruh](https://github.com/giovannirosso)
 - Other Contributors:
     - https://github.com/vshymanskyy/TinyGSM/graphs/contributors
 
diff --git a/library.json b/library.json
index 7df379d..031a15f 100644
--- a/library.json
+++ b/library.json
@@ -1,6 +1,6 @@
 {
   "name": "TinyGSM",
-  "version": "0.11.8",
+  "version": "0.12.0",
   "description": "A small Arduino library for GPRS modules, that just works. Includes examples for Blynk, MQTT, File Download, and Web Client. Supports many GSM, LTE, and WiFi modules with AT command interfaces.",
   "keywords": "GSM, AT commands, AT, SIM800, SIM900, A6, A7, M590, ESP8266, SIM7000, SIM800A, SIM800C, SIM800L, SIM800H, SIM808, SIM868, SIM900A, SIM900D, SIM908, SIM968, M95, MC60, MC60E, BG96, BG95, ublox, Quectel, SIMCOM, AI Thinker, LTE, LTE-M",
   "authors": [
diff --git a/library.properties b/library.properties
index 6b1ae5e..ef29574 100644
--- a/library.properties
+++ b/library.properties
@@ -1,5 +1,5 @@
 name=TinyGSM
-version=0.11.8
+version=0.12.0
 author=Volodymyr Shymanskyy
 maintainer=Volodymyr Shymanskyy
 sentence=A small Arduino library for GPRS modules, that just works.
diff --git a/src/TinyGsmCommon.h b/src/TinyGsmCommon.h
index bb790a4..449b528 100644
--- a/src/TinyGsmCommon.h
+++ b/src/TinyGsmCommon.h
@@ -10,7 +10,7 @@
 #define SRC_TINYGSMCOMMON_H_
 
 // The current library version number
-#define TINYGSM_VERSION "0.11.8"
+#define TINYGSM_VERSION "0.12.0"
 
 #if defined(SPARK) || defined(PARTICLE)
 #include "Particle.h"
@@ -90,6 +90,9 @@ const T& TinyGsmMax(const T& a, const T& b) {
   return (b < a) ? a : b;
 }
 
+/*
+ * Automatically find baud rate
+ */
 template <class T>
 uint32_t TinyGsmAutoBaud(T& SerialAT, uint32_t minimum = 9600,
                          uint32_t maximum = 115200) {

From 6ea2d44594cab03f59a70223d8e84e38181394ab Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 24 May 2024 13:17:00 -0400
Subject: [PATCH 096/100] Made battery return types signed

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 ChangeLog.md                           |  1 +
 examples/AllFunctions/AllFunctions.ino |  6 +++---
 src/TinyGsmBattery.tpp                 | 15 +++++++--------
 src/TinyGsmClientA6.h                  |  6 +++---
 src/TinyGsmClientSIM5360.h             |  6 +++---
 src/TinyGsmClientSIM7600.h             |  8 ++++----
 src/TinyGsmClientSaraR4.h              |  8 ++++----
 src/TinyGsmClientSaraR5.h              |  8 ++++----
 src/TinyGsmClientUBLOX.h               |  8 ++++----
 src/TinyGsmClientXBee.h                | 10 +++++-----
 tools/test_build/test_build.ino        |  6 +++---
 11 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/ChangeLog.md b/ChangeLog.md
index 20272e5..474ca1c 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -34,6 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Changed inputs for (unimplemented) SSL certificate functions.
 - All modems will now return the pre-defined manufacturer and model in the name if the function to get the internal name fails.
 - Cleaned up code for getting modem names.
+- Made battery return types signed.
 
 ### Added
 - Added support for SSL for the Quentcel BG95 and BG96 from [Aurelien BOUIN](https://github.com/aurelihein) and [George O'Connor](https://github.com/georgeman93)
diff --git a/examples/AllFunctions/AllFunctions.ino b/examples/AllFunctions/AllFunctions.ino
index ecd3156..df183fc 100644
--- a/examples/AllFunctions/AllFunctions.ino
+++ b/examples/AllFunctions/AllFunctions.ino
@@ -479,9 +479,9 @@ void loop() {
 
 // Test Battery functions
 #if TINY_GSM_TEST_BATTERY && defined TINY_GSM_MODEM_HAS_BATTERY
-  uint8_t  chargeState   = -99;
-  int8_t   chargePercent = -99;
-  uint16_t milliVolts    = -9999;
+  int8_t  chargeState   = -99;
+  int8_t  chargePercent = -99;
+  int16_t milliVolts    = -9999;
   modem.getBattStats(chargeState, chargePercent, milliVolts);
   DBG("Battery charge state:", chargeState);
   DBG("Battery charge 'percent':", chargePercent);
diff --git a/src/TinyGsmBattery.tpp b/src/TinyGsmBattery.tpp
index 1979d8d..2b8c8e3 100644
--- a/src/TinyGsmBattery.tpp
+++ b/src/TinyGsmBattery.tpp
@@ -24,17 +24,16 @@ class TinyGsmBattery {
   /*
    * Battery functions
    */
-  uint16_t getBattVoltage() {
+  int16_t getBattVoltage() {
     return thisModem().getBattVoltageImpl();
   }
   int8_t getBattPercent() {
     return thisModem().getBattPercentImpl();
   }
-  uint8_t getBattChargeState() {
+  int8_t getBattChargeState() {
     return thisModem().getBattChargeStateImpl();
   }
-  bool getBattStats(uint8_t& chargeState, int8_t& percent,
-                    uint16_t& milliVolts) {
+  bool getBattStats(int8_t& chargeState, int8_t& percent, int16_t& milliVolts) {
     return thisModem().getBattStatsImpl(chargeState, percent, milliVolts);
   }
 
@@ -61,7 +60,7 @@ class TinyGsmBattery {
    */
  protected:
   // Use: float vBatt = modem.getBattVoltage() / 1000.0;
-  uint16_t getBattVoltageImpl() {
+  int16_t getBattVoltageImpl() {
     thisModem().sendAT(GF("+CBC"));
     if (thisModem().waitResponse(GF("+CBC:")) != 1) { return 0; }
     thisModem().streamSkipUntil(',');  // Skip battery charge status
@@ -84,7 +83,7 @@ class TinyGsmBattery {
     return res;
   }
 
-  uint8_t getBattChargeStateImpl() {
+  int8_t getBattChargeStateImpl() {
     thisModem().sendAT(GF("+CBC"));
     if (thisModem().waitResponse(GF("+CBC:")) != 1) { return false; }
     // Read battery charge status
@@ -94,8 +93,8 @@ class TinyGsmBattery {
     return res;
   }
 
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     thisModem().sendAT(GF("+CBC"));
     if (thisModem().waitResponse(GF("+CBC:")) != 1) { return false; }
     chargeState = thisModem().streamGetIntBefore(',');
diff --git a/src/TinyGsmClientA6.h b/src/TinyGsmClientA6.h
index c7e2c19..f486b46 100644
--- a/src/TinyGsmClientA6.h
+++ b/src/TinyGsmClientA6.h
@@ -435,7 +435,7 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
    * Battery functions
    */
  protected:
-  uint16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
   // Needs a '?' after CBC, unlike most
   int8_t getBattPercentImpl() {
@@ -450,8 +450,8 @@ class TinyGsmA6 : public TinyGsmModem<TinyGsmA6>,
   }
 
   // Needs a '?' after CBC, unlike most
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     sendAT(GF("+CBC?"));
     if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return false; }
     chargeState = streamGetIntBefore(',');
diff --git a/src/TinyGsmClientSIM5360.h b/src/TinyGsmClientSIM5360.h
index a0beded..14e9d86 100644
--- a/src/TinyGsmClientSIM5360.h
+++ b/src/TinyGsmClientSIM5360.h
@@ -563,7 +563,7 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
    */
  protected:
   // SRGD Note:  Returns voltage in VOLTS instead of millivolts
-  uint16_t getBattVoltageImpl() {
+  int16_t getBattVoltageImpl() {
     sendAT(GF("+CBC"));
     if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return 0; }
     streamSkipUntil(',');  // Skip battery charge status
@@ -578,8 +578,8 @@ class TinyGsmSim5360 : public TinyGsmModem<TinyGsmSim5360>,
   }
 
   // SRGD Note:  Returns voltage in VOLTS instead of millivolts
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     sendAT(GF("+CBC"));
     if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return false; }
     chargeState = streamGetIntBefore(',');
diff --git a/src/TinyGsmClientSIM7600.h b/src/TinyGsmClientSIM7600.h
index d857eb2..0a27f23 100644
--- a/src/TinyGsmClientSIM7600.h
+++ b/src/TinyGsmClientSIM7600.h
@@ -590,7 +590,7 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
    */
  protected:
   // returns volts, multiply by 1000 to get mV
-  uint16_t getBattVoltageImpl() {
+  int16_t getBattVoltageImpl() {
     sendAT(GF("+CBC"));
     if (waitResponse(GF(AT_NL "+CBC:")) != 1) { return 0; }
 
@@ -605,10 +605,10 @@ class TinyGsmSim7600 : public TinyGsmModem<TinyGsmSim7600>,
 
   int8_t getBattPercentImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
-  uint8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     chargeState = 0;
     percent     = 0;
     milliVolts  = getBattVoltage();
diff --git a/src/TinyGsmClientSaraR4.h b/src/TinyGsmClientSaraR4.h
index 9a8b805..ee0d3dd 100644
--- a/src/TinyGsmClientSaraR4.h
+++ b/src/TinyGsmClientSaraR4.h
@@ -628,7 +628,7 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
    * Battery functions
    */
  protected:
-  uint16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
   int8_t getBattPercentImpl() {
     sendAT(GF("+CIND?"));
@@ -641,10 +641,10 @@ class TinyGsmSaraR4 : public TinyGsmModem<TinyGsmSaraR4>,
     return percent;
   }
 
-  uint8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     chargeState = 0;
     percent     = getBattPercent();
     milliVolts  = 0;
diff --git a/src/TinyGsmClientSaraR5.h b/src/TinyGsmClientSaraR5.h
index 4c7e47c..b14c8e9 100644
--- a/src/TinyGsmClientSaraR5.h
+++ b/src/TinyGsmClientSaraR5.h
@@ -621,7 +621,7 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
    * Battery functions
    */
  protected:
-  uint16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
   int8_t getBattPercentImpl() {
     sendAT(GF("+CIND?"));
@@ -634,10 +634,10 @@ class TinyGsmSaraR5 : public TinyGsmModem<TinyGsmSaraR5>,
     return percent;
   }
 
-  uint8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     chargeState = 0;
     percent     = getBattPercent();
     milliVolts  = 0;
diff --git a/src/TinyGsmClientUBLOX.h b/src/TinyGsmClientUBLOX.h
index ccbeb60..f2804cd 100644
--- a/src/TinyGsmClientUBLOX.h
+++ b/src/TinyGsmClientUBLOX.h
@@ -609,7 +609,7 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
    * Battery functions
    */
  protected:
-  uint16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int16_t getBattVoltageImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
   int8_t getBattPercentImpl() {
     sendAT(GF("+CIND?"));
@@ -622,10 +622,10 @@ class TinyGsmUBLOX : public TinyGsmModem<TinyGsmUBLOX>,
     return percent;
   }
 
-  uint8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     chargeState = 0;
     percent     = getBattPercent();
     milliVolts  = 0;
diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index e35184f..1ee77f9 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -1088,7 +1088,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
    */
  protected:
   // Use: float vBatt = modem.getBattVoltage() / 1000.0;
-  uint16_t getBattVoltageImpl() {
+  int16_t getBattVoltageImpl() {
     int16_t intRes = 0;
     XBEE_COMMAND_START_DECORATOR(5, false)
     if (beeType == XBEE_UNKNOWN) getSeries();
@@ -1100,11 +1100,11 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return intRes;
   }
 
-  int8_t  getBattPercentImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
-  uint8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int8_t getBattPercentImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
+  int8_t getBattChargeStateImpl() TINY_GSM_ATTR_NOT_AVAILABLE;
 
-  bool getBattStatsImpl(uint8_t& chargeState, int8_t& percent,
-                        uint16_t& milliVolts) {
+  bool getBattStatsImpl(int8_t& chargeState, int8_t& percent,
+                        int16_t& milliVolts) {
     chargeState = 0;
     percent     = 0;
     milliVolts  = getBattVoltage();
diff --git a/tools/test_build/test_build.ino b/tools/test_build/test_build.ino
index b0e37de..d344197 100644
--- a/tools/test_build/test_build.ino
+++ b/tools/test_build/test_build.ino
@@ -255,9 +255,9 @@ void loop() {
   // modem.getBattVoltage();      // Not available for all modems
   // modem.getBattPercent();      // Not available for all modems
   // modem.getBattChargeState();  // Not available for all modems
-  uint8_t  chargeState   = -99;
-  int8_t   chargePercent = -99;
-  uint16_t milliVolts    = -9999;
+  int8_t  chargeState   = -99;
+  int8_t  chargePercent = -99;
+  int16_t milliVolts    = -9999;
   modem.getBattStats(chargeState, chargePercent, milliVolts);
 #endif
 

From b0f7b3644a6487e1d6db8daa4f795d7d48184f56 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Fri, 24 May 2024 14:02:55 -0400
Subject: [PATCH 097/100] Empty init impl

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmCommon.h  | 3 +++
 src/TinyGsmModem.tpp | 3 ++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/TinyGsmCommon.h b/src/TinyGsmCommon.h
index 449b528..83e7a33 100644
--- a/src/TinyGsmCommon.h
+++ b/src/TinyGsmCommon.h
@@ -80,6 +80,9 @@ static void DBG(Args... args) {
 #define DBG(...)
 #endif
 
+/*
+ * Min/Max Helpers
+ */
 template <class T>
 const T& TinyGsmMin(const T& a, const T& b) {
   return (b < a) ? b : a;
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 9dc535b..2b7b97a 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -330,6 +330,8 @@ class TinyGsmModem {
    * Basic functions
    */
  protected:
+  bool initImpl() TINY_GSM_ATTR_NOT_IMPLEMENTED;
+
   bool setBaudImpl(uint32_t baud) {
     thisModem().sendAT(GF("+IPR="), baud);
     return thisModem().waitResponse() == 1;
@@ -344,7 +346,6 @@ class TinyGsmModem {
     return false;
   }
 
-
   // TODO(vshymanskyy): Optimize this!
   int8_t waitResponseImpl(uint32_t timeout_ms, String& data,
                           GsmConstStr r1 = GFP(GSM_OK),

From f86aa13c085c088afb860171a5c3ec257a87fc19 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 28 May 2024 13:57:34 -0400
Subject: [PATCH 098/100] Add some documentation

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmBattery.tpp     |  37 +++++
 src/TinyGsmBluetooth.tpp   |  31 ++++
 src/TinyGsmCalling.tpp     |  31 ++++
 src/TinyGsmCommon.h        |  17 +++
 src/TinyGsmModem.tpp       | 283 ++++++++++++++++++++++++++++++++++---
 src/TinyGsmTemperature.tpp |   6 +
 src/TinyGsmTime.tpp        |  39 +++++
 7 files changed, 423 insertions(+), 21 deletions(-)

diff --git a/src/TinyGsmBattery.tpp b/src/TinyGsmBattery.tpp
index 2b8c8e3..767ae78 100644
--- a/src/TinyGsmBattery.tpp
+++ b/src/TinyGsmBattery.tpp
@@ -24,15 +24,52 @@ class TinyGsmBattery {
   /*
    * Battery functions
    */
+
+  /**
+   * @brief Get the current battery voltage.
+   *
+   * @note Unless you have a battery directly connected to your modem module,
+   * this will be the input voltage going to the module from your main processor
+   * board, not the battery voltage of your main processor.
+   *
+   * @return *int16_t*  The battery voltage measured by the modem module.
+   */
   int16_t getBattVoltage() {
     return thisModem().getBattVoltageImpl();
   }
+
+  /**
+   * @brief Get the current battery percent.
+   *
+   * @note Unless you have a battery directly connected to your modem module,
+   * this will be the percent from the input voltage going to the module from
+   * your main processor board, not the battery percent of your main processor.
+   *
+   * @return *int8_t*  The current battery percent.
+   */
   int8_t getBattPercent() {
     return thisModem().getBattPercentImpl();
   }
+
+  /**
+   * @brief Get the battery charging state.
+   *
+   * @return *int8_t* The battery charge state.
+   */
   int8_t getBattChargeState() {
     return thisModem().getBattChargeStateImpl();
   }
+
+  /**
+   * @brief Get the all battery state
+   *
+   * @param chargeState A reference to an int to set to the battery charge state
+   * @param percent A reference to an int to set to the battery percent
+   * @param milliVolts A reference to an int to set to the battery voltage
+   * @return *true* The battery stats were updated by the module.
+   * @return *false* There was a failure in updating the battery stats from the
+   * module.
+   */
   bool getBattStats(int8_t& chargeState, int8_t& percent, int16_t& milliVolts) {
     return thisModem().getBattStatsImpl(chargeState, percent, milliVolts);
   }
diff --git a/src/TinyGsmBluetooth.tpp b/src/TinyGsmBluetooth.tpp
index a6164fd..b3913d9 100644
--- a/src/TinyGsmBluetooth.tpp
+++ b/src/TinyGsmBluetooth.tpp
@@ -24,15 +24,46 @@ class TinyGsmBluetooth {
   /*
    * Bluetooth functions
    */
+
+  /**
+   * @brief Enable module Bluetooth
+   *
+   * @return *true* Bluetooth was succcessfully enabled
+   * @return *false* Bluetooth failed to enable
+   */
   bool enableBluetooth() {
     return thisModem().enableBluetoothImpl();
   }
+
+  /**
+   * @brief Disable module Bluetooth
+   *
+   * @return *true* Bluetooth was succcessfully disabled
+   * @return *false* Bluetooth failed to disable
+   */
   bool disableBluetooth() {
     return thisModem().disableBluetoothImpl();
   }
+
+  /**
+   * @brief Set the Bluetooth visibility
+   *
+   * @param visible True to make the modem visible over Bluetooth, false to make
+   * it invisible.
+   * @return *true* Bluetooth visibility was successfully changed.
+   * @return *false* Bluetooth visibility failed to change
+   */
   bool setBluetoothVisibility(bool visible) {
     return thisModem().setBluetoothVisibilityImpl(visible);
   }
+
+  /**
+   * @brief Set the Bluetooth host name
+   *
+   * @param name The name visible to other Bluetooth objects
+   * @return *true* Bluetooth host name was successfully changed.
+   * @return *false* Bluetooth host name failed to change
+   */
   bool setBluetoothHostName(const char* name) {
     return thisModem().setBluetoothHostNameImpl(name);
   }
diff --git a/src/TinyGsmCalling.tpp b/src/TinyGsmCalling.tpp
index 8494f04..59525fd 100644
--- a/src/TinyGsmCalling.tpp
+++ b/src/TinyGsmCalling.tpp
@@ -24,15 +24,46 @@ class TinyGsmCalling {
   /*
    * Phone Call functions
    */
+
+  /**
+   * @brief Answer an incoming phone call
+   *
+   * @return *true* The call was answered.
+   * @return *false* The call was not answered.
+   */
   bool callAnswer() {
     return thisModem().callAnswerImpl();
   }
+
+  /**
+   * @brief Make a phone call
+   *
+   * @param number The number to call
+   * @return *true* The call was successfully made
+   * @return *false* The call wasn't made
+   */
   bool callNumber(const String& number) {
     return thisModem().callNumberImpl(number);
   }
+
+  /**
+   * @brief Hang up an in-progress phone call
+   *
+   * @return *true* The call was hung up.
+   * @return *false* The call was not hung up.
+   */
   bool callHangup() {
     return thisModem().callHangupImpl();
   }
+
+  /**
+   * @brief Sent a DTMF (dual tone multi frequency) message over a phone call.
+   *
+   * @param cmd The command to send
+   * @param duration_ms The tone duration
+   * @return *true* The message was sent
+   * @return *false* The message failed to send
+   */
   bool dtmfSend(char cmd, int duration_ms = 100) {
     return thisModem().dtmfSendImpl(cmd, duration_ms);
   }
diff --git a/src/TinyGsmCommon.h b/src/TinyGsmCommon.h
index 83e7a33..ace5bd3 100644
--- a/src/TinyGsmCommon.h
+++ b/src/TinyGsmCommon.h
@@ -80,6 +80,23 @@ static void DBG(Args... args) {
 #define DBG(...)
 #endif
 
+/*
+ * CRTP Helper
+ */
+template <typename modemType, template <typename> class crtpType>
+struct tinygsm_crtp {
+  modemType& thisModem() {
+    return static_cast<modemType&>(*this);
+  }
+  modemType const& thisModem() const {
+    return static_cast<modemType const&>(*this);
+  }
+
+ private:
+  tinygsm_crtp() {}
+  friend crtpType<modemType>;
+};
+
 /*
  * Min/Max Helpers
  */
diff --git a/src/TinyGsmModem.tpp b/src/TinyGsmModem.tpp
index 2b7b97a..ff4c368 100644
--- a/src/TinyGsmModem.tpp
+++ b/src/TinyGsmModem.tpp
@@ -57,29 +57,88 @@ class TinyGsmModem {
    * Define the interface
    */
  public:
-  /*
-   * Basic functions
+  /**
+   * @anchor basic_functions
+   * @name Basic functions
+   */
+  /**@{*/
+
+  /**
+   * @brief Sets up the GSM module
+   *
+   * @param pin A pin code to unlock the SIM, if necessary
+   *
+   * @return *true* The module was set up as expected
+   * @return *false* Something failed in module set up
    */
   bool begin(const char* pin = nullptr) {
     return thisModem().initImpl(pin);
   }
+  /**
+   * @copydoc TinyGsmModem::begin()
+   */
   bool init(const char* pin = nullptr) {
     return thisModem().initImpl(pin);
   }
+
+  /**
+   * @brief Recursive variadic template to send AT commands
+   *
+   * @tparam Args
+   * @param cmd The commands to send
+   */
   template <typename... Args>
   inline void sendAT(Args... cmd) {
     thisModem().streamWrite("AT", cmd..., AT_NL);
     thisModem().stream.flush();
     TINY_GSM_YIELD(); /* DBG("### AT:", cmd...); */
   }
+
+  /**
+   * @brief Set the module baud rate
+   *
+   * @param baud The baud rate the use
+   *
+   * @note After setting and applying the new baud rate, you will have to end()
+   * and begin() the serial object.
+   */
   bool setBaud(uint32_t baud) {
     return thisModem().setBaudImpl(baud);
   }
-  // Test response to AT commands
+
+  /**
+   * @brief Test response to AT commands
+   *
+   * @param timeout_ms The the amount of time to test for; optional with a
+   * default value of 10s.
+   * @return *true*  The module responeded to AT commands
+   * @return *false*  The module failed to respond
+   */
   bool testAT(uint32_t timeout_ms = 10000L) {
     return thisModem().testATImpl(timeout_ms);
   }
-  // Listen for responses to commands and handle URCs
+
+  /**
+   * @brief Listen for responses to commands and handle URCs
+   *
+   * @param timeout_ms The time to wait for a response
+   * @param data A string of data to fill in with response results
+   * @param r1 The first output to test against, optional with a default value
+   * of "OK"
+   * @param r2 The second output to test against, optional with a default value
+   * of "ERROR"
+   * @param r3 The third output to test against, optional with a default value
+   * of NULL
+   * @param r4 The fourth output to test against, optional with a default value
+   * of NULL
+   * @param r5 The fifth output to test against, optional with a default value
+   * of NULL
+   * @param r6 The sixth output to test against, optional with a default value
+   * of NULL
+   * @param r7 The seventh output to test against, optional with a default value
+   * of NULL
+   * @return *int8_t* the index of the response input
+   */
   int8_t waitResponse(uint32_t timeout_ms, String& data,
                       GsmConstStr r1 = GFP(GSM_OK),
                       GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = nullptr,
@@ -89,6 +148,26 @@ class TinyGsmModem {
                                         r6, r7);
   }
 
+  /**
+   * @brief Listen for responses to commands and handle URCs
+   *
+   * @param timeout_ms The time to wait for a response
+   * @param r1 The first output to test against, optional with a default value
+   * of "OK"
+   * @param r2 The second output to test against, optional with a default value
+   * of "ERROR"
+   * @param r3 The third output to test against, optional with a default value
+   * of NULL
+   * @param r4 The fourth output to test against, optional with a default value
+   * of NULL
+   * @param r5 The fifth output to test against, optional with a default value
+   * of NULL
+   * @param r6 The sixth output to test against, optional with a default value
+   * of NULL
+   * @param r7 The seventh output to test against, optional with a default value
+   * of NULL
+   * @return *int8_t* the index of the response input
+   */
   int8_t waitResponse(uint32_t timeout_ms, GsmConstStr r1 = GFP(GSM_OK),
                       GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = nullptr,
                       GsmConstStr r4 = nullptr, GsmConstStr r5 = nullptr,
@@ -97,6 +176,26 @@ class TinyGsmModem {
     return waitResponse(timeout_ms, data, r1, r2, r3, r4, r5, r6, r7);
   }
 
+  /**
+   * @brief Listen for responses to commands and handle URCs; listening for 1
+   * second.
+   *
+   * @param r1 The first output to test against, optional with a default value
+   * of "OK"
+   * @param r2 The second output to test against, optional with a default value
+   * of "ERROR"
+   * @param r3 The third output to test against, optional with a default value
+   * of NULL
+   * @param r4 The fourth output to test against, optional with a default value
+   * of NULL
+   * @param r5 The fifth output to test against, optional with a default value
+   * of NULL
+   * @param r6 The sixth output to test against, optional with a default value
+   * of NULL
+   * @param r7 The seventh output to test against, optional with a default value
+   * of NULL
+   * @return *int8_t* the index of the response input
+   */
   int8_t waitResponse(GsmConstStr r1 = GFP(GSM_OK),
                       GsmConstStr r2 = GFP(GSM_ERROR), GsmConstStr r3 = nullptr,
                       GsmConstStr r4 = nullptr, GsmConstStr r5 = nullptr,
@@ -104,79 +203,216 @@ class TinyGsmModem {
     return waitResponse(1000L, r1, r2, r3, r4, r5, r6, r7);
   }
 
-  // Asks for modem information via the 3GPP TS 27.007 standard ATI command
-  // NOTE:  The actual value and style of the response is quite varied
+  /**
+   * @brief Asks for modem information via the 3GPP TS 27.007 standard ATI
+   * command
+   *
+   * @note  The actual value and style of the response is quite varied
+   * @return *String* Some info about the GSM module.
+   */
   String getModemInfo() {
     return thisModem().getModemInfoImpl();
   }
-  // Gets the modem name (as it calls itself)
+
+  /**
+   * @brief Get the modem name - a combination of the manufacturer and model, as
+   * the modem calls itself
+   *
+   * @return *String*  The modem name
+   */
   String getModemName() {
     return thisModem().getModemNameImpl();
   }
-  // Gets the modem manufacturer
+
+  /**
+   * @brief Get the modem manufacturer
+   *
+   * @return *String* The modem manufacturer
+   */
   String getModemManufacturer() {
     return thisModem().getModemManufacturerImpl();
   }
-  // Gets the modem hardware version
+
+  /**
+   * @brief Get the modem model
+   *
+   * @return *String* The modem model, as it calls itself
+   */
   String getModemModel() {
     return thisModem().getModemModelImpl();
   }
-  // Gets the modem firmware version
+
+  /**
+   * @brief Get the modem revision information.
+   *
+   * What is returned as the revision may be either a hardware or a firmware
+   * version or some combination of both.
+   *
+   * @return *String* The modem revision information
+   */
   String getModemRevision() {
     return thisModem().getModemRevisionImpl();
   }
-  // Gets the modem serial number
+
+  /**
+   * @brief Get the modem serial number
+   *
+   * @return *String* The modem serial number
+   */
   String getModemSerialNumber() {
     return thisModem().getModemSerialNumberImpl();
   }
+
+  /**
+   * @brief Reset the module to factory defaults.
+   *
+   * This generally restarts the module as well.
+   *
+   * @return *true* The module successfully reset to default.
+   * @return *false* The module failed to reset to default.
+   */
   bool factoryDefault() {
     return thisModem().factoryDefaultImpl();
   }
+  /**@}*/
 
-  /*
-   * Power functions
+  /**
+   * @anchor power_functions
+   * @name Power functions
+   */
+  /**@{*/
+
+  /**
+   * @brief Restart the module
+   *
+   * @param pin A pin code to unlock the SIM, if necessary
+   *
+   * @return *true* The module was successfully restarted.
+   * @return *false* There was an error in restarting the module.
    */
   bool restart(const char* pin = nullptr) {
     return thisModem().restartImpl(pin);
   }
+  /**
+   * @brief Power off the module
+   *
+   * @return *true* The module was successfully powered down.
+   * @return *false* There was an error in powering down module.
+   */
   bool poweroff() {
     return thisModem().powerOffImpl();
   }
+  /**
+   * @brief Turn off the module radio
+   *
+   * @return *true* The module radio was successfully turned off.
+   * @return *false* There was an error in turning off the radio.
+   */
   bool radioOff() {
     return thisModem().radioOffImpl();
   }
+
+  /**
+   * @brief Enable sleep on the module.
+   *
+   * For some modules this immediately puts
+   * the module to sleep, for others this sets them to be able to sleep based on
+   * pin levels.
+   *
+   * @param enable True to enable sleep, false to disable
+   * @return *true* Sleep was successfully enabled or disabled
+   * @return *false* There was a problem setting sleep
+   */
   bool sleepEnable(bool enable = true) {
     return thisModem().sleepEnableImpl(enable);
   }
+
+  /**
+   * @brief Set the phone functionality
+   *
+   * @param fun The phone functionality setting. The value and meaning of this
+   * varies by module; check your documentation.
+   * @param reset True to reset the module before changing the functionality.
+   * @return *true* The phone functionalilty was successfully changed.
+   * @return *false* There was a problem changing the functionality.
+   */
   bool setPhoneFunctionality(uint8_t fun, bool reset = false) {
     return thisModem().setPhoneFunctionalityImpl(fun, reset);
   }
+  /**@}*/
 
-  /*
-   * Generic network functions
+  /**
+   * @anchor network_functions
+   * @name Generic Network Functions
    */
+  /**@{*/
+
   // RegStatus getRegistrationStatus() {}
+
+  /**
+   * @brief Confirm whether the module is currently connected to the
+   * GSM/GPRS/LTE network.
+   *
+   * @return *true* The module is connected to the network
+   * @return *false* The module is not connected to the network
+   */
   bool isNetworkConnected() {
     return thisModem().isNetworkConnectedImpl();
   }
-  // Waits for network attachment
+
+  /**
+   * @brief Wait until the module has connected to the network
+   *
+   * @param timeout_ms The time to wait for attachment in milliseconds. Optional
+   * with a default value of 1 minute.
+   * @param check_signal True to alternate between checking for connection and
+   * checking the signal strength.
+   * @return *true* The module is now connected to the network.
+   * @return *false* The module did not connect to the network even after
+   * waiting.
+   */
   bool waitForNetwork(uint32_t timeout_ms = 60000L, bool check_signal = false) {
     return thisModem().waitForNetworkImpl(timeout_ms, check_signal);
   }
-  // Gets signal quality report
+
+  /**
+   * @brief Get the signal quality report
+   *
+   * This is often a "CSQ" value ranging from 0 to 32, but may be an RSSI or a
+   * percent.
+   *
+   * @return *int16_t* The signal quality
+   */
   int16_t getSignalQuality() {
     return thisModem().getSignalQualityImpl();
   }
+
+  /**
+   * @brief Get the Local IP address assigned to the module by the network as a
+   * String
+   *
+   * @return *String* The local IP address
+   */
   String getLocalIP() {
     return thisModem().getLocalIPImpl();
   }
+
+  /**
+   * @brief Get the Local IP address assigned to the module by the network as an
+   * IPAddress object.
+   *
+   * @return *IPAddress* The local IP address
+   */
   IPAddress localIP() {
     return thisModem().TinyGsmIpFromString(thisModem().getLocalIP());
   }
+  /**@}*/
 
-  /*
-   * CRTP Helper
+  /**
+   * @anchor crtp_helper
+   * @name CRTP Helper
    */
+  /**@{*/
  protected:
   inline const modemType& thisModem() const {
     return static_cast<const modemType&>(*this);
@@ -184,11 +420,15 @@ class TinyGsmModem {
   inline modemType& thisModem() {
     return static_cast<modemType&>(*this);
   }
+  /**@}*/
   ~TinyGsmModem() {}
 
-  /*
-   Utilities
+
+  /**
+   * @anchor modem_utilities
+   * @name Utilities
    */
+  /**@{*/
  public:
   // Utility templates for writing/skipping characters on a stream
   template <typename T>
@@ -319,6 +559,7 @@ class TinyGsmModem {
     }
     return IPAddress(Parts[0], Parts[1], Parts[2], Parts[3]);
   }
+  /**@}*/
 
   /* =========================================== */
   /* =========================================== */
diff --git a/src/TinyGsmTemperature.tpp b/src/TinyGsmTemperature.tpp
index aa6b85a..7dcd67c 100644
--- a/src/TinyGsmTemperature.tpp
+++ b/src/TinyGsmTemperature.tpp
@@ -24,6 +24,12 @@ class TinyGsmTemperature {
   /*
    * Temperature functions
    */
+
+  /**
+   * @brief Get the modem chip temperature in degrees celsius.
+   *
+   * @return *float* The modem chip temperature in degrees celsius.
+   */
   float getTemperature() {
     return thisModem().getTemperatureImpl();
   }
diff --git a/src/TinyGsmTime.tpp b/src/TinyGsmTime.tpp
index 6b8d4b3..10fbb12 100644
--- a/src/TinyGsmTime.tpp
+++ b/src/TinyGsmTime.tpp
@@ -26,14 +26,52 @@ class TinyGsmTime {
   /*
    * Time functions
    */
+
+  /**
+   * @brief Get the Date Time as a String
+   *
+   * @param format The date or time part to get: DATE_FULL,
+   * DATE_TIME, or DATE_DATE
+   * @return *String*  The date and/or time from the module
+   */
   String getGSMDateTime(TinyGSMDateTimeFormat format) {
     return thisModem().getGSMDateTimeImpl(format);
   }
+
+  /**
+   * @brief Get the date and time as parts
+   *
+   * @param year Reference to an int for the year
+   * @param month Reference to an int for the month
+   * @param day Reference to an int for the day
+   * @param hour Reference to an int for the hour
+   * @param minute Reference to an int for the minute
+   * @param second Reference to an int for the second
+   * @param timezone Reference to a float for the timezone
+   * @return *true*  The references have been filled with valid values from the
+   * GSM module.
+   * @return *false*  There was a problem getting the time from the module.
+   */
   bool getNetworkTime(int* year, int* month, int* day, int* hour, int* minute,
                       int* second, float* timezone) {
     return thisModem().getNetworkTimeImpl(year, month, day, hour, minute,
                                           second, timezone);
   }
+
+  /**
+   * @brief Get the date and time as parts in UTC
+   *
+   * @param year Reference to an int for the year
+   * @param month Reference to an int for the month
+   * @param day Reference to an int for the day
+   * @param hour Reference to an int for the hour
+   * @param minute Reference to an int for the minute
+   * @param second Reference to an int for the second
+   * @param timezone Reference to a float for the timezone
+   * @return *true*  The references have been filled with valid values from the
+   * GSM module.
+   * @return *false*  There was a problem getting the time from the module.
+   */
   bool getNetworkUTCTime(int* year, int* month, int* day, int* hour,
                          int* minute, int* second, float* timezone) {
     return thisModem().getNetworkUTCTimeImpl(year, month, day, hour, minute,
@@ -57,6 +95,7 @@ class TinyGsmTime {
   /*
    * Define the default function implementations
    */
+
   /*
    * Time functions
    */

From 1cbbe684a437c6abd8d06d5c72b916184eab0c2d Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 28 May 2024 14:12:42 -0400
Subject: [PATCH 099/100] Revert comment reflow

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 src/TinyGsmClientXBee.h | 70 ++++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 40 deletions(-)

diff --git a/src/TinyGsmClientXBee.h b/src/TinyGsmClientXBee.h
index 1ee77f9..f755648 100644
--- a/src/TinyGsmClientXBee.h
+++ b/src/TinyGsmClientXBee.h
@@ -698,7 +698,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
           case 0x23:  // 0x23 SSID not configured.
             stat = REG_UNREGISTERED;
             break;
-          case 0x24:  // 0x24 Encryption key invalid (either nullptr or invalid
+          case 0x24:  // 0x24 Encryption key invalid (either NULL or invalid
                       // length for WEP).
           case 0x27:  // 0x27 SSID was found, but join failed.
             stat = REG_DENIED;
@@ -885,8 +885,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         changesMade = true;
       }
     } else {
-      changesMade |= changeSettingIfNeeded(GF("EE"),
-                                           0x0);  // Set No security
+      changesMade |= changeSettingIfNeeded(GF("EE"), 0x0);  // Set No security
     }
 
     if (changesMade) { retVal &= writeChanges(); }
@@ -936,8 +935,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         changesMade = true;
       }
     }
-    changesMade |= changeSettingIfNeeded(GF("AN"),
-                                         String(apn));  // Set the APN
+    changesMade |= changeSettingIfNeeded(GF("AN"), String(apn));  // Set the APN
 
     changesMade |= changeSettingIfNeeded(GF("AM"), 0x0,
                                          5000L);  // Airplane mode off
@@ -1123,9 +1121,9 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         0,
     };
     res.toCharArray(buf, 5);
-    int8_t intRes = (int8_t)strtol(buf, 0,
-                                   16);  // degrees Celsius displayed in
-                                         // 8-bit two's complement format.
+    int8_t intRes = (int8_t)strtol(
+        buf, 0,
+        16);  // degrees Celsius displayed in 8-bit two's complement format.
     XBEE_COMMAND_END_DECORATOR
     return static_cast<float>(intRes);
   }
@@ -1166,9 +1164,9 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     uint32_t timeout_ms  = ((uint32_t)timeout_s) * 1000;
     bool     gotIP       = false;
     XBEE_COMMAND_START_DECORATOR(5, IPAddress(0, 0, 0, 0))
-    // XBee's require a numeric IP address for connection, but do provide
-    // the functionality to look up the IP address from a fully qualified
-    // domain name
+    // XBee's require a numeric IP address for connection, but do provide the
+    // functionality to look up the IP address from a fully qualified domain
+    // name
     // NOTE: the lookup can take a while
     while ((millis() - startMillis) < timeout_ms) {
       sendAT(GF("LA"), host);
@@ -1198,8 +1196,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     bool retVal = false;
     XBEE_COMMAND_START_DECORATOR(5, false)
 
-    // If this is a new host name, replace the saved host and wipe out the
-    // saved host IP
+    // If this is a new host name, replace the saved host and wipe out the saved
+    // host IP
     if (this->savedHost != String(host)) {
       this->savedHost = String(host);
       savedHostIP     = IPAddress(0, 0, 0, 0);
@@ -1269,8 +1267,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
       if (changesMade) { success &= writeChanges(); }
     }
 
-    // confirm the XBee type if needed so we know if we can know if
-    // connected
+    // confirm the XBee type if needed so we know if we can know if connected
     if (beeType == XBEE_UNKNOWN) { getSeries(); }
     // we'll accept either unknown or connected
     if (beeType != XBEE_S6B_WIFI) {
@@ -1300,10 +1297,9 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
       sendAT(GF("TM"));
       String timeoutUsed = readResponseString(5000L);
 
-      // For cellular models, per documentation: If you write the TM
-      // (socket timeout) value while in Transparent Mode, the current
-      // connection is immediately closed - this works even if the TM
-      // values is unchanged
+      // For cellular models, per documentation: If you write the TM (socket
+      // timeout) value while in Transparent Mode, the current connection is
+      // immediately closed - this works even if the TM values is unchanged
       sendAT(GF("TM"), timeoutUsed);  // Re-set socket timeout
       waitResponse(maxWaitMs);        // This response can be slow
     }
@@ -1325,8 +1321,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
         modemGetConnected(0);
       } else if (len > 5) {
         // After sending several characters, also re-check
-        // NOTE:  I'm intentionally not checking after every single
-        // character!
+        // NOTE:  I'm intentionally not checking after every single character!
         modemGetConnected(0);
       }
     }
@@ -1334,11 +1329,10 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     return len;
   }
 
-  // NOTE:  The CI command returns the status of the TCP connection as
-  // open only after data has been sent on the socket.  If it returns 0xFF
-  // the socket may really be open, but no data has yet been sent.  We
-  // return this unknown value as true so there's a possibility it's
-  // wrong.
+  // NOTE:  The CI command returns the status of the TCP connection as open only
+  // after data has been sent on the socket.  If it returns 0xFF the socket may
+  // really be open, but no data has yet been sent.  We return this unknown
+  // value as true so there's a possibility it's wrong.
   bool modemGetConnected(uint8_t) {
     // If the IP address is 0, it's not valid so we can't be connected
     if (savedIP == IPAddress(0, 0, 0, 0)) { return false; }
@@ -1379,12 +1373,11 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
           }
 
           // 0x28 = "Unknown."
-          // 0xFF = No known status - always returned prior to sending
-          // data
+          // 0xFF = No known status - always returned prior to sending data
           case 0x28:
           case 0xFF: {
-            // If we previously had an operating destination and we no
-            // longer do, the socket must have closed
+            // If we previously had an operating destination and we no longer
+            // do, the socket must have closed
             if (od == IPAddress(0, 0, 0, 0) &&
                 savedOperatingIP != IPAddress(0, 0, 0, 0)) {
               savedOperatingIP           = od;
@@ -1396,14 +1389,13 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
               sockets[0]->stop();
               return false;
             } else if (od != IPAddress(0, 0, 0, 0) && od == savedIP) {
-              // else if the operating destination exists and matches,
-              // we're good to go
+              // else if the operating destination exists and matches, we're
+              // good to go
               savedOperatingIP = od;
               return true;
             } else {
-              // If we never had an operating destination, then sock may
-              // be open but data never sent - this is the dreaded "we
-              // don't know"
+              // If we never had an operating destination, then sock may be open
+              // but data never sent - this is the dreaded "we don't know"
               savedOperatingIP = od;
               return true;
             }
@@ -1447,8 +1439,7 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
 
           // 0x02 = Invalid parameters (bad IP/host)
           // 0x12 = DNS query lookup failure
-          // 0x25 = Unknown server - DNS lookup failed (0x22 for UDP
-          // socket!)
+          // 0x25 = Unknown server - DNS lookup failed (0x22 for UDP socket!)
           // fall through
           case 0x02:
           case 0x12:
@@ -1497,9 +1488,8 @@ class TinyGsmXBee : public TinyGsmModem<TinyGsmXBee>,
     streamClear();  // Empty everything in the buffer before starting
 
     while (!success && triesMade < retries) {
-      // Cannot send anything for 1 "guard time" before entering command
-      // mode Default guard time is 1s, but the init fxn decreases it to
-      // 100 ms
+      // Cannot send anything for 1 "guard time" before entering command mode
+      // Default guard time is 1s, but the init fxn decreases it to 100 ms
       delay(guardTime + 10);
       streamWrite(GF("+++"));  // enter command mode
 

From ae39914987ecf1540419d77c3c9c708024939562 Mon Sep 17 00:00:00 2001
From: Sara Damiano <sdamiano@stroudcenter.org>
Date: Tue, 28 May 2024 14:46:41 -0400
Subject: [PATCH 100/100] Fix CI lib install source

Signed-off-by: Sara Damiano <sdamiano@stroudcenter.org>
---
 .../workflows/build_examples_platformio.yaml  | 63 +++++++++++++++++--
 1 file changed, 58 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build_examples_platformio.yaml b/.github/workflows/build_examples_platformio.yaml
index 0a5b148..01c5eee 100644
--- a/.github/workflows/build_examples_platformio.yaml
+++ b/.github/workflows/build_examples_platformio.yaml
@@ -8,9 +8,62 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  build:
+  determine_library_source:
+    name: determine_library_source
     runs-on: ubuntu-latest
     if: "!contains(github.event.head_commit.message, 'ci skip')"
+    outputs:
+      library_install_zip: ${{ steps.store_vars.outputs.library_install_zip }}
+      library_install_git: ${{ steps.store_vars.outputs.library_install_git }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set environment variables for pushes to any branch
+        if: github.event_name == 'push'
+        run: |
+          echo "Push to commit ${GITHUB_SHA}"
+          echo "LIBRARY_INSTALL_ZIP=https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.zip" >> $GITHUB_ENV
+          echo "LIBRARY_INSTALL_GIT=https://github.com/${GITHUB_REPOSITORY}.git#${GITHUB_SHA}" >> $GITHUB_ENV
+
+      - name: Set environment variable for PR's from any branch
+        if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.name == github.repository
+        run: |
+          echo "Pull Request from the ${GITHUB_HEAD_REF} branch"
+          echo "LIBRARY_INSTALL_ZIP=https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_HEAD_REF}.zip" >> $GITHUB_ENV
+          echo "LIBRARY_INSTALL_GIT=https://github.com/${GITHUB_REPOSITORY}.git#${GITHUB_HEAD_REF}" >> $GITHUB_ENV
+
+      - name: Set environment variable for PR's from any branch
+        if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.name != github.repository
+        run: |
+          echo "Pull Request from the fork ${{ github.event.pull_request.head.repo.full_name }} at ${{ github.event.pull_request.head.ref }}"
+          echo "LIBRARY_INSTALL_ZIP=https://github.com/${{ github.event.pull_request.head.repo.full_name }}/archive/${{ github.event.pull_request.head.ref }}.zip" >> $GITHUB_ENV
+          echo "LIBRARY_INSTALL_GIT=https://github.com/${{ github.event.pull_request.head.repo.full_name }}.git#${{ github.event.pull_request.head.ref }}" >> $GITHUB_ENV
+
+      - name: store enviroment variables as output
+        id: store_vars
+        run: |
+          echo "library_install_zip=${{ env.LIBRARY_INSTALL_ZIP }}" >> $GITHUB_OUTPUT
+          echo "library_install_git=${{ env.LIBRARY_INSTALL_GIT }}" >> $GITHUB_OUTPUT
+
+  print_library_source:
+    name: print_library_source
+    runs-on: ubuntu-latest
+    needs: determine_library_source
+    steps:
+      - name: Check the library installation source
+        run: |
+          echo "Link to zip for Arduino CLI testing install:"
+          echo "${{ needs.determine_library_source.outputs.library_install_zip }}"
+          echo
+          echo "Git reference for PlatformIO testing install"
+          echo "${{ needs.determine_library_source.outputs.library_install_git }}"
+
+  build_pio:
+    runs-on: ubuntu-latest
+    needs: [determine_library_source]
+    env:
+      LIBRARY_INSTALL_GIT: ${{ needs.determine_library_source.outputs.library_install_git }}
 
     strategy:
       matrix:
@@ -70,7 +123,7 @@ jobs:
           python -m pip install --upgrade pip
           pip install --upgrade platformio
 
-      - name: Restore or Cache Platforms and Libraries
+      - name: Restore or Cache PlatformIO Platforms and Libraries
         uses: actions/cache@v4
         id: cache_pio
         with:
@@ -81,7 +134,7 @@ jobs:
           key: ${{ hashFiles('./examples/example_dependencies.json') }}
 
       # Install cores and library dependencies for the Arduino CLI, iff no cache
-      - name: Install the Arduino libraries
+      - name: Install the Arduino libraries for PlatformIO
         if: steps.cache_pio.outputs.cache-hit != 'true'
         run: pio lib --global install 89 415 1202 1286
 
@@ -90,8 +143,8 @@ jobs:
           PLATFORMIO_CI_SRC: ${{ matrix.example }}
           TINYGSM_MODEM_TO_USE: ${{ matrix.modem }}
         run: |
-          echo "${{ env.LIBRARY_INSTALL_SOURCE }}"
-          pio lib --global install ${{ env.LIBRARY_INSTALL_SOURCE }}
+          echo "${{ env.LIBRARY_INSTALL_GIT }}"
+          pio pkg install -g --library ${{ env.LIBRARY_INSTALL_GIT }}
           sed -i 's/\/\/ #define TINY_GSM_MODEM_SIM800/#define TINY_GSM_MODEM_SIM800/g' ${{ matrix.example }}/*
           platformio ci --project-option='build_flags=-D ${{ env.TINYGSM_MODEM_TO_USE }}' --project-option='framework=arduino' --board=uno --board=leonardo --board=yun --board=megaatmega2560 --board=genuino101 --board=mkr1000USB --board=zero --board=teensy31 --board=bluepill_f103c8 --board=uno_pic32 --board=esp01 --board=nodemcuv2 --board=esp32dev
           pio lib --global uninstall TinyGSM