添加反射率定标

.pio/libdeps/esp32dev/ArduinoHttpClient/.gitignore

@@ -0,0 +1,5 @@
+.development
+examples/node_test_server/node_modules/
+*.DS_Store
+*/.DS_Store
+examples/.DS_Store

.pio/libdeps/esp32dev/ArduinoHttpClient/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "ArduinoHttpClient", "version": "0.4.0", "spec": {"owner": "arduino-libraries", "id": 798, "name": "ArduinoHttpClient", "requirements": null, "uri": null}}

.pio/libdeps/esp32dev/ArduinoHttpClient/CHANGELOG.md

@@ -0,0 +1,33 @@
+## ArduinoHttpClient 0.4.0 - 2019.04.09
+
+* Added URLEncoder helper
+
+## ArduinoHttpClient 0.3.2 - 2019.02.04
+
+* Changed Flush return value resulting in compilation error. Thanks @forGGe
+
+## ArduinoHttpClient 0.3.1 - 2017.09.25
+
+* Changed examples to support Arduino Create secret tabs
+* Increase WebSocket secrect-key length to 24 characters
+
+## ArduinoHttpClient 0.3.0 - 2017.04.20
+
+* Added support for PATCH operations
+* Added support for chunked response bodies
+* Added new beginBody API
+
+## ArduinoHttpClient 0.2.0 - 2017.01.12
+
+* Added PATCH method
+* Added basic auth example
+* Added custom header example
+
+## ArduinoHttpClient 0.1.1 - 2016.12.16
+
+* More robust response parser
+
+## ArduinoHttpClient 0.1.0 - 2016.07.05
+
+* Initial release
+

.pio/libdeps/esp32dev/ArduinoHttpClient/README.md

@@ -0,0 +1,25 @@
+# ArduinoHttpClient
+
+ArduinoHttpClient is a library to make it easier to interact with web servers from Arduino.
+
+Derived from [Adrian McEwen's HttpClient library](https://github.com/amcewen/HttpClient)
+
+## Dependencies
+
+- Requires a networking hardware and a library that provides transport specific `Client` instance, such as:
+  - [WiFiNINA](https://github.com/arduino-libraries/WiFiNINA)
+  - [WiFi101](https://github.com/arduino-libraries/WiFi101)
+  - [Ethernet](https://github.com/arduino-libraries/Ethernet)
+  - [MKRGSM](https://github.com/arduino-libraries/MKRGSM)
+  - [MKRNB](https://github.com/arduino-libraries/MKRNB)
+  - [WiFi](https://github.com/arduino-libraries/WiFi)
+  - [GSM](https://github.com/arduino-libraries/GSM)
+
+## Usage
+
+In normal usage, handles the outgoing request and Host header.  The returned status code is parsed for you, as is the Content-Length header (if present).
+
+Because it expects an object of type Client, you can use it with any of the networking classes that derive from that.  Which means it will work with WiFiClient, EthernetClient and GSMClient.
+
+See the examples for more detail on how the library is used.
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/BasicAuthGet/BasicAuthGet.ino

@@ -0,0 +1,66 @@
+/*
+  GET client with HTTP basic authentication for ArduinoHttpClient library
+  Connects to server once every five seconds, sends a GET request
+
+  created 14 Feb 2016
+  by Tom Igoe
+  modified 3 Jan 2017 to add HTTP basic authentication
+  by Sandeep Mistry
+  modified 22 Jan 2019
+  by Tom Igoe
+  
+  this example is in the public domain
+ */
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+#include "arduino_secrets.h"
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+char serverAddress[] = "192.168.0.3";  // server address
+int port = 8080;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("making GET request with HTTP basic authentication");
+  client.beginRequest();
+  client.get("/secure");
+  client.sendBasicAuth("username", "password"); // send the username and password for authentication
+  client.endRequest();
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+  Serial.println("Wait five seconds");
+  delay(5000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/BasicAuthGet/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/CustomHeader/CustomHeader.ino

@@ -0,0 +1,91 @@
+/*
+  Custom request header example for the ArduinoHttpClient
+  library. This example sends a GET and a POST request with a custom header every 5 seconds.
+
+  based on SimpleGet example by Tom Igoe
+  header modifications by Todd Treece
+  modified 22 Jan 2019
+  by Tom Igoe
+
+  this example is in the public domain
+*/
+
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+
+#include "arduino_secrets.h"
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+char serverAddress[] = "192.168.0.3";  // server address
+int port = 8080;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("making GET request");
+  client.beginRequest();
+  client.get("/");
+  client.sendHeader("X-CUSTOM-HEADER", "custom_value");
+  client.endRequest();
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("GET Status code: ");
+  Serial.println(statusCode);
+  Serial.print("GET Response: ");
+  Serial.println(response);
+
+  Serial.println("Wait five seconds");
+  delay(5000);
+
+  Serial.println("making POST request");
+  String postData = "name=Alice&age=12";
+  client.beginRequest();
+  client.post("/");
+  client.sendHeader(HTTP_HEADER_CONTENT_TYPE, "application/x-www-form-urlencoded");
+  client.sendHeader(HTTP_HEADER_CONTENT_LENGTH, postData.length());
+  client.sendHeader("X-CUSTOM-HEADER", "custom_value");
+  client.endRequest();
+  client.write((const byte*)postData.c_str(), postData.length());
+  // note: the above line can also be achieved with the simpler line below:
+  //client.print(postData);
+
+  // read the status code and body of the response
+  statusCode = client.responseStatusCode();
+  response = client.responseBody();
+
+  Serial.print("POST Status code: ");
+  Serial.println(statusCode);
+  Serial.print("POST Response: ");
+  Serial.println(response);
+
+  Serial.println("Wait five seconds");
+  delay(5000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/CustomHeader/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/DweetGet/DweetGet.ino

@@ -0,0 +1,103 @@
+/*
+  Dweet.io GET client for ArduinoHttpClient library
+  Connects to dweet.io once every ten seconds,
+  sends a GET request and a request body. Uses SSL
+
+  Shows how to use Strings to assemble path and parse content
+  from response. dweet.io expects:
+  https://dweet.io/get/latest/dweet/for/thingName
+
+  For more on dweet.io, see https://dweet.io/play/
+
+  created 15 Feb 2016
+  updated 22 Jan 2019
+  by Tom Igoe
+
+  this example is in the public domain
+*/
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+
+#include "arduino_secrets.h"
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+const char serverAddress[] = "dweet.io";  // server address
+int port = 80;
+String dweetName = "scandalous-cheese-hoarder"; // use your own thing name here
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);     // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  // assemble the path for the GET message:
+  String path = "/get/latest/dweet/for/" + dweetName;
+
+  // send the GET request
+  Serial.println("making GET request");
+  client.get(path);
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+
+  /*
+    Typical response is:
+    {"this":"succeeded",
+    "by":"getting",
+    "the":"dweets",
+    "with":[{"thing":"my-thing-name",
+      "created":"2016-02-16T05:10:36.589Z",
+      "content":{"sensorValue":456}}]}
+
+    You want "content": numberValue
+  */
+  // now parse the response looking for "content":
+  int labelStart = response.indexOf("content\":");
+  // find the first { after "content":
+  int contentStart = response.indexOf("{", labelStart);
+  // find the following } and get what's between the braces:
+  int contentEnd = response.indexOf("}", labelStart);
+  String content = response.substring(contentStart + 1, contentEnd);
+  Serial.println(content);
+
+  // now get the value after the colon, and convert to an int:
+  int valueStart = content.indexOf(":");
+  String valueString = content.substring(valueStart + 1);
+  int number = valueString.toInt();
+  Serial.print("Value string: ");
+  Serial.println(valueString);
+  Serial.print("Actual value: ");
+  Serial.println(number);
+
+  Serial.println("Wait ten seconds\n");
+  delay(10000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/DweetGet/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/DweetPost/DweetPost.ino

@@ -0,0 +1,79 @@
+/*
+  Dweet.io POST client for ArduinoHttpClient library
+  Connects to dweet.io once every ten seconds,
+  sends a POST request and a request body.
+
+  Shows how to use Strings to assemble path and body
+
+  created 15 Feb 2016
+  modified 22 Jan 2019
+  by Tom Igoe
+
+  this example is in the public domain
+*/
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+
+#include "arduino_secrets.h"
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+const char serverAddress[] = "dweet.io";  // server address
+int port = 80;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while(!Serial);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  // assemble the path for the POST message:
+  String dweetName = "scandalous-cheese-hoarder";
+  String path = "/dweet/for/" + dweetName;
+  String contentType = "application/json";
+
+  // assemble the body of the POST message:
+  int sensorValue = analogRead(A0);
+  String postData = "{\"sensorValue\":\""; 
+  postData += sensorValue;
+  postData += "\"}";
+
+  Serial.println("making POST request");
+
+  // send the POST request
+  client.post(path, contentType, postData);
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+
+  Serial.println("Wait ten seconds\n");
+  delay(10000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/DweetPost/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/HueBlink/HueBlink.ino

@@ -0,0 +1,98 @@
+/* HueBlink example for ArduinoHttpClient library
+
+   Uses ArduinoHttpClient library to control Philips Hue
+   For more on Hue developer API see http://developer.meethue.com
+
+  To control a light, the Hue expects a HTTP PUT request to:
+
+  http://hue.hub.address/api/hueUserName/lights/lightNumber/state
+
+  The body of the PUT request looks like this:
+  {"on": true} or {"on":false}
+
+  This example  shows how to concatenate Strings to assemble the
+  PUT request and the body of the request.
+
+   modified 15 Feb 2016 
+   by Tom Igoe (tigoe) to match new API
+*/
+
+#include <SPI.h>
+#include <WiFi101.h>
+#include <ArduinoHttpClient.h>
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+int status = WL_IDLE_STATUS;      // the Wifi radio's status
+
+char hueHubIP[] = "192.168.0.3";  // IP address of the HUE bridge
+String hueUserName = "huebridgeusername"; // hue bridge username
+
+// make a wifi instance and a HttpClient instance:
+WiFiClient wifi;
+HttpClient httpClient = HttpClient(wifi, hueHubIP);
+
+
+void setup() {
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial); // wait for serial port to connect.
+
+  // attempt to connect to Wifi network:
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to WPA SSID: ");
+    Serial.println(ssid);
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // you're connected now, so print out the data:
+  Serial.print("You're connected to the network IP = ");
+  IPAddress ip = WiFi.localIP();
+  Serial.println(ip);
+}
+
+void loop() {
+  sendRequest(3, "on", "true");   // turn light on
+  delay(2000);                    // wait 2 seconds
+  sendRequest(3, "on", "false");  // turn light off
+  delay(2000);                    // wait 2 seconds
+}
+
+void sendRequest(int light, String cmd, String value) {
+  // make a String for the HTTP request path:
+  String request = "/api/" + hueUserName;
+  request += "/lights/";
+  request += light;
+  request += "/state/";
+
+  String contentType = "application/json";
+
+  // make a string for the JSON command:
+  String hueCmd = "{\"" + cmd;
+  hueCmd += "\":";
+  hueCmd += value;
+  hueCmd += "}";
+  // see what you assembled to send:
+  Serial.print("PUT request to server: ");
+  Serial.println(request);
+  Serial.print("JSON command to server: ");
+
+  // make the PUT request to the hub:
+  httpClient.put(request, contentType, hueCmd);
+  
+  // read the status code and body of the response
+  int statusCode = httpClient.responseStatusCode();
+  String response = httpClient.responseBody();
+
+  Serial.println(hueCmd);
+  Serial.print("Status code from server: ");
+  Serial.println(statusCode);
+  Serial.print("Server response: ");
+  Serial.println(response);
+  Serial.println();
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/HueBlink/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/PostWithHeaders/PostWithHeaders.ino

@@ -0,0 +1,77 @@
+/*
+  POST with headers client for ArduinoHttpClient library
+  Connects to server once every five seconds, sends a POST request
+  with custome headers and a request body
+
+  created 14 Feb 2016
+  by Tom Igoe
+  modified 18 Mar 2017
+  by Sandeep Mistry
+  modified 22 Jan 2019
+  by Tom Igoe
+  
+  this example is in the public domain
+ */
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+
+char serverAddress[] = "192.168.0.3";  // server address
+int port = 8080;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("making POST request");
+  String postData = "name=Alice&age=12";
+
+  client.beginRequest();
+  client.post("/");
+  client.sendHeader("Content-Type", "application/x-www-form-urlencoded");
+  client.sendHeader("Content-Length", postData.length());
+  client.sendHeader("X-Custom-Header", "custom-header-value");
+  client.beginBody();
+  client.print(postData);
+  client.endRequest();
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+
+  Serial.println("Wait five seconds");
+  delay(5000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/PostWithHeaders/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleDelete/SimpleDelete.ino

@@ -0,0 +1,68 @@
+/*
+  Simple DELETE client for ArduinoHttpClient library
+  Connects to server once every five seconds, sends a DELETE request
+  and a request body
+
+  created 14 Feb 2016
+  modified 22 Jan 2019
+  by Tom Igoe
+  
+  this example is in the public domain
+ */
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+
+char serverAddress[] = "192.168.0.3";  // server address
+int port = 8080;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("making DELETE request");
+  String contentType = "application/x-www-form-urlencoded";
+  String delData = "name=light&age=46";
+
+  client.del("/", contentType, delData);
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+
+  Serial.println("Wait five seconds");
+  delay(5000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleDelete/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleGet/SimpleGet.ino

@@ -0,0 +1,62 @@
+/*
+  Simple GET client for ArduinoHttpClient library
+  Connects to server once every five seconds, sends a GET request
+
+  created 14 Feb 2016
+  modified 22 Jan 2019
+  by Tom Igoe
+  
+  this example is in the public domain
+ */
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+char serverAddress[] = "192.168.0.3";  // server address
+int port = 8080;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("making GET request");
+  client.get("/");
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+  Serial.println("Wait five seconds");
+  delay(5000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleGet/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleHttpExample/SimpleHttpExample.ino

@@ -0,0 +1,133 @@
+// (c) Copyright 2010-2012 MCQN Ltd.
+// Released under Apache License, version 2.0
+//
+// Simple example to show how to use the HttpClient library
+// Get's the web page given at http://<kHostname><kPath> and
+// outputs the content to the serial port
+
+#include <SPI.h>
+#include <WiFi101.h>
+#include <ArduinoHttpClient.h>
+
+// This example downloads the URL "http://arduino.cc/"
+
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+
+
+// Name of the server we want to connect to
+const char kHostname[] = "arduino.cc";
+// Path to download (this is the bit after the hostname in the URL
+// that you want to download
+const char kPath[] = "/";
+
+// Number of milliseconds to wait without receiving any data before we give up
+const int kNetworkTimeout = 30*1000;
+// Number of milliseconds to wait if no data is available before trying again
+const int kNetworkDelay = 1000;
+
+WiFiClient c;
+HttpClient http(c, kHostname);
+
+void setup()
+{
+  //Initialize serial and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+  // attempt to connect to Wifi network:
+  Serial.print("Attempting to connect to WPA SSID: ");
+  Serial.println(ssid);
+  while (WiFi.begin(ssid, pass) != WL_CONNECTED) {
+    // unsuccessful, retry in 4 seconds
+    Serial.print("failed ... ");
+    delay(4000);
+    Serial.print("retrying ... ");
+  }
+
+  Serial.println("connected");
+}
+
+void loop()
+{
+  int err =0;
+  
+  err = http.get(kPath);
+  if (err == 0)
+  {
+    Serial.println("startedRequest ok");
+
+    err = http.responseStatusCode();
+    if (err >= 0)
+    {
+      Serial.print("Got status code: ");
+      Serial.println(err);
+
+      // Usually you'd check that the response code is 200 or a
+      // similar "success" code (200-299) before carrying on,
+      // but we'll print out whatever response we get
+
+      // If you are interesting in the response headers, you
+      // can read them here:
+      //while(http.headerAvailable())
+      //{
+      //  String headerName = http.readHeaderName();
+      //  String headerValue = http.readHeaderValue();
+      //}
+
+      int bodyLen = http.contentLength();
+      Serial.print("Content length is: ");
+      Serial.println(bodyLen);
+      Serial.println();
+      Serial.println("Body returned follows:");
+    
+      // Now we've got to the body, so we can print it out
+      unsigned long timeoutStart = millis();
+      char c;
+      // Whilst we haven't timed out & haven't reached the end of the body
+      while ( (http.connected() || http.available()) &&
+             (!http.endOfBodyReached()) &&
+             ((millis() - timeoutStart) < kNetworkTimeout) )
+      {
+          if (http.available())
+          {
+              c = http.read();
+              // Print out this character
+              Serial.print(c);
+             
+              // We read something, reset the timeout counter
+              timeoutStart = millis();
+          }
+          else
+          {
+              // We haven't got any data, so let's pause to allow some to
+              // arrive
+              delay(kNetworkDelay);
+          }
+      }
+    }
+    else
+    {    
+      Serial.print("Getting response failed: ");
+      Serial.println(err);
+    }
+  }
+  else
+  {
+    Serial.print("Connect failed: ");
+    Serial.println(err);
+  }
+  http.stop();
+
+  // And just stop, now that we've tried a download
+  while(1);
+}
+
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleHttpExample/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimplePost/SimplePost.ino

@@ -0,0 +1,66 @@
+/*
+  Simple POST client for ArduinoHttpClient library
+  Connects to server once every five seconds, sends a POST request
+  and a request body
+
+  created 14 Feb 2016
+  modified 22 Jan 2019
+  by Tom Igoe
+  
+  this example is in the public domain
+ */
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+char serverAddress[] = "192.168.0.3";  // server address
+int port = 8080;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("making POST request");
+  String contentType = "application/x-www-form-urlencoded";
+  String postData = "name=Alice&age=12";
+
+  client.post("/", contentType, postData);
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+
+  Serial.println("Wait five seconds");
+  delay(5000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimplePost/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimplePut/SimplePut.ino

@@ -0,0 +1,66 @@
+/*
+  Simple PUT client for ArduinoHttpClient library
+  Connects to server once every five seconds, sends a PUT request
+  and a request body
+
+  created 14 Feb 2016
+  modified 22 Jan 2019
+  by Tom Igoe
+  
+  this example is in the public domain
+ */
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+char serverAddress[] = "192.168.0.3";  // server address
+int port = 8080;
+
+WiFiClient wifi;
+HttpClient client = HttpClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("making PUT request");
+  String contentType = "application/x-www-form-urlencoded";
+  String putData = "name=light&age=46";
+
+  client.put("/", contentType, putData);
+
+  // read the status code and body of the response
+  int statusCode = client.responseStatusCode();
+  String response = client.responseBody();
+
+  Serial.print("Status code: ");
+  Serial.println(statusCode);
+  Serial.print("Response: ");
+  Serial.println(response);
+
+  Serial.println("Wait five seconds");
+  delay(5000);
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimplePut/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleWebSocket/SimpleWebSocket.ino

@@ -0,0 +1,80 @@
+/*
+  Simple WebSocket client for ArduinoHttpClient library
+  Connects to the WebSocket server, and sends a hello
+  message every 5 seconds
+
+  created 28 Jun 2016
+  by Sandeep Mistry
+  modified 22 Jan 2019
+  by Tom Igoe
+
+  this example is in the public domain
+*/
+#include <ArduinoHttpClient.h>
+#include <WiFi101.h>
+#include "arduino_secrets.h"
+
+///////please enter your sensitive data in the Secret tab/arduino_secrets.h
+/////// Wifi Settings ///////
+char ssid[] = SECRET_SSID;
+char pass[] = SECRET_PASS;
+
+char serverAddress[] = "echo.websocket.org";  // server address
+int port = 80;
+
+WiFiClient wifi;
+WebSocketClient client = WebSocketClient(wifi, serverAddress, port);
+int status = WL_IDLE_STATUS;
+int count = 0;
+
+void setup() {
+  Serial.begin(9600);
+  while ( status != WL_CONNECTED) {
+    Serial.print("Attempting to connect to Network named: ");
+    Serial.println(ssid);                   // print the network name (SSID);
+
+    // Connect to WPA/WPA2 network:
+    status = WiFi.begin(ssid, pass);
+  }
+
+  // print the SSID of the network you're attached to:
+  Serial.print("SSID: ");
+  Serial.println(WiFi.SSID());
+
+  // print your WiFi shield's IP address:
+  IPAddress ip = WiFi.localIP();
+  Serial.print("IP Address: ");
+  Serial.println(ip);
+}
+
+void loop() {
+  Serial.println("starting WebSocket client");
+  client.begin();
+
+  while (client.connected()) {
+    Serial.print("Sending hello ");
+    Serial.println(count);
+
+    // send a hello #
+    client.beginMessage(TYPE_TEXT);
+    client.print("hello ");
+    client.print(count);
+    client.endMessage();
+
+    // increment count for next message
+    count++;
+
+    // check if a message is available to be received
+    int messageSize = client.parseMessage();
+
+    if (messageSize > 0) {
+      Serial.println("Received a message:");
+      Serial.println(client.readString());
+    }
+
+    // wait 5 seconds
+    delay(5000);
+  }
+
+  Serial.println("disconnected");
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/SimpleWebSocket/arduino_secrets.h

@@ -0,0 +1,3 @@
+#define SECRET_SSID ""
+#define SECRET_PASS ""
+

.pio/libdeps/esp32dev/ArduinoHttpClient/examples/node_test_server/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "node_test_server",
+  "version": "0.0.1",
+  "author": {
+    "name": "Tom Igoe"
+  },
+  "dependencies": {
+    "body-parser": ">=1.11.0",
+    "express": ">=4.0.0",
+    "multer": "*",
+    "ws": "^1.1.1"
+  }
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/keywords.txt

@@ -0,0 +1,67 @@
+#######################################
+# Syntax Coloring Map For HttpClient
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+ArduinoHttpClient	KEYWORD1
+HttpClient	KEYWORD1
+WebSocketClient	KEYWORD1
+URLEncoder	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+get	KEYWORD2
+post	KEYWORD2
+put	KEYWORD2
+patch	KEYWORD2
+startRequest	KEYWORD2
+beginRequest	KEYWORD2
+beginBody	KEYWORD2
+sendHeader	KEYWORD2
+sendBasicAuth	KEYWORD2
+endRequest	KEYWORD2
+responseStatusCode	KEYWORD2
+readHeader	KEYWORD2
+skipResponseHeaders	KEYWORD2
+endOfHeadersReached	KEYWORD2
+endOfBodyReached	KEYWORD2
+completed	KEYWORD2
+contentLength	KEYWORD2
+isResponseChunked	KEYWORD2
+connectionKeepAlive	KEYWORD2
+noDefaultRequestHeaders	KEYWORD2
+headerAvailable	KEYWORD2
+readHeaderName	KEYWORD2
+readHeaderValue	KEYWORD2
+responseBody	KEYWORD2
+
+beginMessage	KEYWORD2
+endMessage	KEYWORD2
+parseMessage	KEYWORD2
+messageType	KEYWORD2
+isFinal	KEYWORD2
+readString	KEYWORD2
+ping	KEYWORD2
+
+encode	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+HTTP_SUCCESS	LITERAL1
+HTTP_ERROR_CONNECTION_FAILED	LITERAL1
+HTTP_ERROR_API	LITERAL1
+HTTP_ERROR_TIMED_OUT	LITERAL1
+HTTP_ERROR_INVALID_RESPONSE	LITERAL1
+
+TYPE_CONTINUATION	LITERAL1
+TYPE_TEXT	LITERAL1
+TYPE_BINARY	LITERAL1
+TYPE_CONNECTION_CLOSE	LITERAL1
+TYPE_PING	LITERAL1
+TYPE_PONG	LITERAL1

.pio/libdeps/esp32dev/ArduinoHttpClient/library.json

@@ -0,0 +1,12 @@
+{
+    "name": "ArduinoHttpClient",
+    "keywords": "http, web, client, ethernet, wifi, GSM",
+    "description": "Easily interact with web servers from Arduino, using HTTP and WebSocket's.",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/arduino-libraries/ArduinoHttpClient.git"
+    },
+    "frameworks": "arduino",
+    "platforms": "*",
+    "version": "0.4.0"
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/library.properties

@@ -0,0 +1,10 @@
+name=ArduinoHttpClient
+version=0.4.0
+author=Arduino
+maintainer=Arduino <info@arduino.cc>
+sentence=[EXPERIMENTAL] Easily interact with web servers from Arduino, using HTTP and WebSocket's.
+paragraph=This library can be used for HTTP (GET, POST, PUT, DELETE) requests to a web server. It also supports exchanging messages with WebSocket servers. Based on Adrian McEwen's HttpClient library.
+category=Communication
+url=https://github.com/arduino-libraries/ArduinoHttpClient
+architectures=*
+includes=ArduinoHttpClient.h

.pio/libdeps/esp32dev/ArduinoHttpClient/src/ArduinoHttpClient.h

@@ -0,0 +1,12 @@
+// Library to simplify HTTP fetching on Arduino
+// (c) Copyright Arduino. 2016
+// Released under Apache License, version 2.0
+
+#ifndef ArduinoHttpClient_h
+#define ArduinoHttpClient_h
+
+#include "HttpClient.h"
+#include "WebSocketClient.h"
+#include "URLEncoder.h"
+
+#endif

.pio/libdeps/esp32dev/ArduinoHttpClient/src/HttpClient.cpp

@@ -0,0 +1,862 @@
+// Class to simplify HTTP fetching on Arduino
+// (c) Copyright 2010-2011 MCQN Ltd
+// Released under Apache License, version 2.0
+
+#include "HttpClient.h"
+#include "b64.h"
+
+// Initialize constants
+const char* HttpClient::kUserAgent = "Arduino/2.2.0";
+const char* HttpClient::kContentLengthPrefix = HTTP_HEADER_CONTENT_LENGTH ": ";
+const char* HttpClient::kTransferEncodingChunked = HTTP_HEADER_TRANSFER_ENCODING ": " HTTP_HEADER_VALUE_CHUNKED;
+
+HttpClient::HttpClient(Client& aClient, const char* aServerName, uint16_t aServerPort)
+ : iClient(&aClient), iServerName(aServerName), iServerAddress(), iServerPort(aServerPort),
+   iConnectionClose(true), iSendDefaultRequestHeaders(true)
+{
+  resetState();
+}
+
+HttpClient::HttpClient(Client& aClient, const String& aServerName, uint16_t aServerPort)
+ : HttpClient(aClient, aServerName.c_str(), aServerPort)
+{
+}
+
+HttpClient::HttpClient(Client& aClient, const IPAddress& aServerAddress, uint16_t aServerPort)
+ : iClient(&aClient), iServerName(NULL), iServerAddress(aServerAddress), iServerPort(aServerPort),
+   iConnectionClose(true), iSendDefaultRequestHeaders(true)
+{
+  resetState();
+}
+
+void HttpClient::resetState()
+{
+  iState = eIdle;
+  iStatusCode = 0;
+  iContentLength = kNoContentLengthHeader;
+  iBodyLengthConsumed = 0;
+  iContentLengthPtr = kContentLengthPrefix;
+  iTransferEncodingChunkedPtr = kTransferEncodingChunked;
+  iIsChunked = false;
+  iChunkLength = 0;
+  iHttpResponseTimeout = kHttpResponseTimeout;
+}
+
+void HttpClient::stop()
+{
+  iClient->stop();
+  resetState();
+}
+
+void HttpClient::connectionKeepAlive()
+{
+  iConnectionClose = false;
+}
+
+void HttpClient::noDefaultRequestHeaders()
+{
+  iSendDefaultRequestHeaders = false;
+}
+
+void HttpClient::beginRequest()
+{
+  iState = eRequestStarted;
+}
+
+int HttpClient::startRequest(const char* aURLPath, const char* aHttpMethod, 
+                                const char* aContentType, int aContentLength, const byte aBody[])
+{
+    if (iState == eReadingBody || iState == eReadingChunkLength || iState == eReadingBodyChunk)
+    {
+        flushClientRx();
+
+        resetState();
+    }
+
+    tHttpState initialState = iState;
+
+    if ((eIdle != iState) && (eRequestStarted != iState))
+    {
+        return HTTP_ERROR_API;
+    }
+
+    if (iConnectionClose || !iClient->connected())
+    {
+        if (iServerName)
+        {
+            if (!iClient->connect(iServerName, iServerPort) > 0)
+            {
+#ifdef LOGGING
+                Serial.println("Connection failed");
+#endif
+                return HTTP_ERROR_CONNECTION_FAILED;
+            }
+        }
+        else
+        {
+            if (!iClient->connect(iServerAddress, iServerPort) > 0)
+            {
+#ifdef LOGGING
+                Serial.println("Connection failed");
+#endif
+                return HTTP_ERROR_CONNECTION_FAILED;
+            }    
+        }
+    }
+    else
+    {
+#ifdef LOGGING
+        Serial.println("Connection already open");
+#endif
+    }
+
+    // Now we're connected, send the first part of the request
+    int ret = sendInitialHeaders(aURLPath, aHttpMethod);
+
+    if (HTTP_SUCCESS == ret)
+    {
+        if (aContentType)
+        {
+            sendHeader(HTTP_HEADER_CONTENT_TYPE, aContentType);
+        }
+
+        if (aContentLength > 0)
+        {
+            sendHeader(HTTP_HEADER_CONTENT_LENGTH, aContentLength);
+        }
+
+        bool hasBody = (aBody && aContentLength > 0);
+
+        if (initialState == eIdle || hasBody)
+        {
+            // This was a simple version of the API, so terminate the headers now
+            finishHeaders();
+        }
+        // else we'll call it in endRequest or in the first call to print, etc.
+
+        if (hasBody)
+        {
+                write(aBody, aContentLength);
+        }
+    }
+
+    return ret;
+}
+
+int HttpClient::sendInitialHeaders(const char* aURLPath, const char* aHttpMethod)
+{
+#ifdef LOGGING
+    Serial.println("Connected");
+#endif
+    // Send the HTTP command, i.e. "GET /somepath/ HTTP/1.0"
+    iClient->print(aHttpMethod);
+    iClient->print(" ");
+
+    iClient->print(aURLPath);
+    iClient->println(" HTTP/1.1");
+    if (iSendDefaultRequestHeaders)
+    {
+        // The host header, if required
+        if (iServerName)
+        {
+            iClient->print("Host: ");
+            iClient->print(iServerName);
+            if (iServerPort != kHttpPort)
+            {
+              iClient->print(":");
+              iClient->print(iServerPort);
+            }
+            iClient->println();
+        }
+        // And user-agent string
+        sendHeader(HTTP_HEADER_USER_AGENT, kUserAgent);
+    }
+
+    if (iConnectionClose)
+    {
+        // Tell the server to
+        // close this connection after we're done
+        sendHeader(HTTP_HEADER_CONNECTION, "close");
+    }
+
+    // Everything has gone well
+    iState = eRequestStarted;
+    return HTTP_SUCCESS;
+}
+
+void HttpClient::sendHeader(const char* aHeader)
+{
+    iClient->println(aHeader);
+}
+
+void HttpClient::sendHeader(const char* aHeaderName, const char* aHeaderValue)
+{
+    iClient->print(aHeaderName);
+    iClient->print(": ");
+    iClient->println(aHeaderValue);
+}
+
+void HttpClient::sendHeader(const char* aHeaderName, const int aHeaderValue)
+{
+    iClient->print(aHeaderName);
+    iClient->print(": ");
+    iClient->println(aHeaderValue);
+}
+
+void HttpClient::sendBasicAuth(const char* aUser, const char* aPassword)
+{
+    // Send the initial part of this header line
+    iClient->print("Authorization: Basic ");
+    // Now Base64 encode "aUser:aPassword" and send that
+    // This seems trickier than it should be but it's mostly to avoid either
+    // (a) some arbitrarily sized buffer which hopes to be big enough, or
+    // (b) allocating and freeing memory
+    // ...so we'll loop through 3 bytes at a time, outputting the results as we
+    // go.
+    // In Base64, each 3 bytes of unencoded data become 4 bytes of encoded data
+    unsigned char input[3];
+    unsigned char output[5]; // Leave space for a '\0' terminator so we can easily print
+    int userLen = strlen(aUser);
+    int passwordLen = strlen(aPassword);
+    int inputOffset = 0;
+    for (int i = 0; i < (userLen+1+passwordLen); i++)
+    {
+        // Copy the relevant input byte into the input
+        if (i < userLen)
+        {
+            input[inputOffset++] = aUser[i];
+        }
+        else if (i == userLen)
+        {
+            input[inputOffset++] = ':';
+        }
+        else
+        {
+            input[inputOffset++] = aPassword[i-(userLen+1)];
+        }
+        // See if we've got a chunk to encode
+        if ( (inputOffset == 3) || (i == userLen+passwordLen) )
+        {
+            // We've either got to a 3-byte boundary, or we've reached then end
+            b64_encode(input, inputOffset, output, 4);
+            // NUL-terminate the output string
+            output[4] = '\0';
+            // And write it out
+            iClient->print((char*)output);
+// FIXME We might want to fill output with '=' characters if b64_encode doesn't
+// FIXME do it for us when we're encoding the final chunk
+            inputOffset = 0;
+        }
+    }
+    // And end the header we've sent
+    iClient->println();
+}
+
+void HttpClient::finishHeaders()
+{
+    iClient->println();
+    iState = eRequestSent;
+}
+
+void HttpClient::flushClientRx()
+{
+    while (iClient->available())
+    {
+        iClient->read();
+    }
+}
+
+void HttpClient::endRequest()
+{
+    beginBody();
+}
+
+void HttpClient::beginBody()
+{
+    if (iState < eRequestSent)
+    {
+        // We still need to finish off the headers
+        finishHeaders();
+    }
+    // else the end of headers has already been sent, so nothing to do here
+}
+
+int HttpClient::get(const char* aURLPath)
+{
+    return startRequest(aURLPath, HTTP_METHOD_GET);
+}
+
+int HttpClient::get(const String& aURLPath)
+{
+    return get(aURLPath.c_str());
+}
+
+int HttpClient::post(const char* aURLPath)
+{
+    return startRequest(aURLPath, HTTP_METHOD_POST);
+}
+
+int HttpClient::post(const String& aURLPath)
+{
+    return post(aURLPath.c_str());
+}
+
+int HttpClient::post(const char* aURLPath, const char* aContentType, const char* aBody)
+{
+    return post(aURLPath, aContentType, strlen(aBody), (const byte*)aBody);
+}
+
+int HttpClient::post(const String& aURLPath, const String& aContentType, const String& aBody)
+{
+    return post(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
+}
+
+int HttpClient::post(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
+{
+    return startRequest(aURLPath, HTTP_METHOD_POST, aContentType, aContentLength, aBody);
+}
+
+int HttpClient::put(const char* aURLPath)
+{
+    return startRequest(aURLPath, HTTP_METHOD_PUT);
+}
+
+int HttpClient::put(const String& aURLPath)
+{
+    return put(aURLPath.c_str());
+}
+
+int HttpClient::put(const char* aURLPath, const char* aContentType, const char* aBody)
+{
+    return put(aURLPath, aContentType, strlen(aBody),  (const byte*)aBody);
+}
+
+int HttpClient::put(const String& aURLPath, const String& aContentType, const String& aBody)
+{
+    return put(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
+}
+
+int HttpClient::put(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
+{
+    return startRequest(aURLPath, HTTP_METHOD_PUT, aContentType, aContentLength, aBody);
+}
+
+int HttpClient::patch(const char* aURLPath)
+{
+    return startRequest(aURLPath, HTTP_METHOD_PATCH);
+}
+
+int HttpClient::patch(const String& aURLPath)
+{
+    return patch(aURLPath.c_str());
+}
+
+int HttpClient::patch(const char* aURLPath, const char* aContentType, const char* aBody)
+{
+    return patch(aURLPath, aContentType, strlen(aBody),  (const byte*)aBody);
+}
+
+int HttpClient::patch(const String& aURLPath, const String& aContentType, const String& aBody)
+{
+    return patch(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
+}
+
+int HttpClient::patch(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
+{
+    return startRequest(aURLPath, HTTP_METHOD_PATCH, aContentType, aContentLength, aBody);
+}
+
+int HttpClient::del(const char* aURLPath)
+{
+    return startRequest(aURLPath, HTTP_METHOD_DELETE);
+}
+
+int HttpClient::del(const String& aURLPath)
+{
+    return del(aURLPath.c_str());
+}
+
+int HttpClient::del(const char* aURLPath, const char* aContentType, const char* aBody)
+{
+    return del(aURLPath, aContentType, strlen(aBody),  (const byte*)aBody);
+}
+
+int HttpClient::del(const String& aURLPath, const String& aContentType, const String& aBody)
+{
+    return del(aURLPath.c_str(), aContentType.c_str(), aBody.length(), (const byte*)aBody.c_str());
+}
+
+int HttpClient::del(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[])
+{
+    return startRequest(aURLPath, HTTP_METHOD_DELETE, aContentType, aContentLength, aBody);
+}
+
+int HttpClient::responseStatusCode()
+{
+    if (iState < eRequestSent)
+    {
+        return HTTP_ERROR_API;
+    }
+    // The first line will be of the form Status-Line:
+    //   HTTP-Version SP Status-Code SP Reason-Phrase CRLF
+    // Where HTTP-Version is of the form:
+    //   HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT
+
+    int c = '\0';
+    do
+    {
+        // Make sure the status code is reset, and likewise the state.  This
+        // lets us easily cope with 1xx informational responses by just
+        // ignoring them really, and reading the next line for a proper response
+        iStatusCode = 0;
+        iState = eRequestSent;
+
+        unsigned long timeoutStart = millis();
+        // Psuedo-regexp we're expecting before the status-code
+        const char* statusPrefix = "HTTP/*.* ";
+        const char* statusPtr = statusPrefix;
+        // Whilst we haven't timed out & haven't reached the end of the headers
+        while ((c != '\n') && 
+               ( (millis() - timeoutStart) < iHttpResponseTimeout ))
+        {
+            if (available())
+            {
+                c = read();
+                if (c != -1)
+                {
+                    switch(iState)
+                    {
+                    case eRequestSent:
+                        // We haven't reached the status code yet
+                        if ( (*statusPtr == '*') || (*statusPtr == c) )
+                        {
+                            // This character matches, just move along
+                            statusPtr++;
+                            if (*statusPtr == '\0')
+                            {
+                                // We've reached the end of the prefix
+                                iState = eReadingStatusCode;
+                            }
+                        }
+                        else
+                        {
+                            return HTTP_ERROR_INVALID_RESPONSE;
+                        }
+                        break;
+                    case eReadingStatusCode:
+                        if (isdigit(c))
+                        {
+                            // This assumes we won't get more than the 3 digits we
+                            // want
+                            iStatusCode = iStatusCode*10 + (c - '0');
+                        }
+                        else
+                        {
+                            // We've reached the end of the status code
+                            // We could sanity check it here or double-check for ' '
+                            // rather than anything else, but let's be lenient
+                            iState = eStatusCodeRead;
+                        }
+                        break;
+                    case eStatusCodeRead:
+                        // We're just waiting for the end of the line now
+                        break;
+
+                    default:
+                        break;
+                    };
+                    // We read something, reset the timeout counter
+                    timeoutStart = millis();
+                }
+            }
+            else
+            {
+                // We haven't got any data, so let's pause to allow some to
+                // arrive
+                delay(kHttpWaitForDataDelay);
+            }
+        }
+        if ( (c == '\n') && (iStatusCode < 200 && iStatusCode != 101) )
+        {
+            // We've reached the end of an informational status line
+            c = '\0'; // Clear c so we'll go back into the data reading loop
+        }
+    }
+    // If we've read a status code successfully but it's informational (1xx)
+    // loop back to the start
+    while ( (iState == eStatusCodeRead) && (iStatusCode < 200 && iStatusCode != 101) );
+
+    if ( (c == '\n') && (iState == eStatusCodeRead) )
+    {
+        // We've read the status-line successfully
+        return iStatusCode;
+    }
+    else if (c != '\n')
+    {
+        // We must've timed out before we reached the end of the line
+        return HTTP_ERROR_TIMED_OUT;
+    }
+    else
+    {
+        // This wasn't a properly formed status line, or at least not one we
+        // could understand
+        return HTTP_ERROR_INVALID_RESPONSE;
+    }
+}
+
+int HttpClient::skipResponseHeaders()
+{
+    // Just keep reading until we finish reading the headers or time out
+    unsigned long timeoutStart = millis();
+    // Whilst we haven't timed out & haven't reached the end of the headers
+    while ((!endOfHeadersReached()) && 
+           ( (millis() - timeoutStart) < iHttpResponseTimeout ))
+    {
+        if (available())
+        {
+            (void)readHeader();
+            // We read something, reset the timeout counter
+            timeoutStart = millis();
+        }
+        else
+        {
+            // We haven't got any data, so let's pause to allow some to
+            // arrive
+            delay(kHttpWaitForDataDelay);
+        }
+    }
+    if (endOfHeadersReached())
+    {
+        // Success
+        return HTTP_SUCCESS;
+    }
+    else
+    {
+        // We must've timed out
+        return HTTP_ERROR_TIMED_OUT;
+    }
+}
+
+bool HttpClient::endOfHeadersReached()
+{
+    return (iState == eReadingBody || iState == eReadingChunkLength || iState == eReadingBodyChunk);
+};
+
+int HttpClient::contentLength()
+{
+    // skip the response headers, if they haven't been read already 
+    if (!endOfHeadersReached())
+    {
+        skipResponseHeaders();
+    }
+
+    return iContentLength;
+}
+
+String HttpClient::responseBody()
+{
+    int bodyLength = contentLength();
+    String response;
+
+    if (bodyLength > 0)
+    {
+        // try to reserve bodyLength bytes
+        if (response.reserve(bodyLength) == 0) {
+            // String reserve failed
+            return String((const char*)NULL);
+        }
+    }
+
+    // keep on timedRead'ing, until:
+    //  - we have a content length: body length equals consumed or no bytes
+    //                              available
+    //  - no content length:        no bytes are available
+    while (iBodyLengthConsumed != bodyLength)
+    {
+        int c = timedRead();
+
+        if (c == -1) {
+            // read timed out, done
+            break;
+        }
+
+        if (!response.concat((char)c)) {
+            // adding char failed
+            return String((const char*)NULL);
+        }
+    }
+
+    if (bodyLength > 0 && (unsigned int)bodyLength != response.length()) {
+        // failure, we did not read in reponse content length bytes
+        return String((const char*)NULL);
+    }
+
+    return response;
+}
+
+bool HttpClient::endOfBodyReached()
+{
+    if (endOfHeadersReached() && (contentLength() != kNoContentLengthHeader))
+    {
+        // We've got to the body and we know how long it will be
+        return (iBodyLengthConsumed >= contentLength());
+    }
+    return false;
+}
+
+int HttpClient::available()
+{
+    if (iState == eReadingChunkLength)
+    {
+        while (iClient->available())
+        {
+            char c = iClient->read();
+
+            if (c == '\n')
+            {
+                iState = eReadingBodyChunk;
+                break;
+            }
+            else if (c == '\r')
+            {
+                // no-op
+            }
+            else if (isHexadecimalDigit(c))
+            {
+                char digit[2] = {c, '\0'};
+
+                iChunkLength = (iChunkLength * 16) + strtol(digit, NULL, 16);
+            }
+        }
+    }
+
+    if (iState == eReadingBodyChunk && iChunkLength == 0)
+    {
+        iState = eReadingChunkLength;
+    }
+    
+    if (iState == eReadingChunkLength)
+    {
+        return 0;
+    }
+    
+    int clientAvailable = iClient->available();
+
+    if (iState == eReadingBodyChunk)
+    {
+        return min(clientAvailable, iChunkLength);
+    }
+    else
+    {
+        return clientAvailable;
+    }
+}
+
+
+int HttpClient::read()
+{
+    if (iIsChunked && !available())
+    {
+        return -1;
+    }
+
+    int ret = iClient->read();
+    if (ret >= 0)
+    {
+        if (endOfHeadersReached() && iContentLength > 0)
+        {
+            // We're outputting the body now and we've seen a Content-Length header
+            // So keep track of how many bytes are left
+            iBodyLengthConsumed++;
+        }
+
+        if (iState == eReadingBodyChunk)
+        {
+            iChunkLength--;
+
+            if (iChunkLength == 0)
+            {
+                iState = eReadingChunkLength;
+            }
+        }
+    }
+    return ret;
+}
+
+bool HttpClient::headerAvailable()
+{
+    // clear the currently store header line
+    iHeaderLine = "";
+
+    while (!endOfHeadersReached())
+    {
+        // read a byte from the header
+        int c = readHeader();
+
+        if (c == '\r' || c == '\n')
+        {
+            if (iHeaderLine.length())
+            {
+                // end of the line, all done
+                break;
+            } 
+            else
+            {
+                // ignore any CR or LF characters
+                continue;
+            }
+        }
+
+        // append byte to header line
+        iHeaderLine += (char)c;
+    }
+
+    return (iHeaderLine.length() > 0);
+}
+
+String HttpClient::readHeaderName()
+{
+    int colonIndex = iHeaderLine.indexOf(':');
+
+    if (colonIndex == -1)
+    {
+        return "";
+    }
+
+    return iHeaderLine.substring(0, colonIndex);
+}
+
+String HttpClient::readHeaderValue()
+{
+    int colonIndex = iHeaderLine.indexOf(':');
+    int startIndex = colonIndex + 1;
+
+    if (colonIndex == -1)
+    {
+        return "";
+    }
+
+    // trim any leading whitespace
+    while (startIndex < (int)iHeaderLine.length() && isSpace(iHeaderLine[startIndex]))
+    {
+        startIndex++;
+    }
+
+    return iHeaderLine.substring(startIndex);
+}
+
+int HttpClient::read(uint8_t *buf, size_t size)
+{
+    int ret =iClient->read(buf, size);
+    if (endOfHeadersReached() && iContentLength > 0)
+    {
+        // We're outputting the body now and we've seen a Content-Length header
+        // So keep track of how many bytes are left
+        if (ret >= 0)
+        {
+            iBodyLengthConsumed += ret;
+        }
+    }
+    return ret;
+}
+
+int HttpClient::readHeader()
+{
+    char c = read();
+
+    if (endOfHeadersReached())
+    {
+        // We've passed the headers, but rather than return an error, we'll just
+        // act as a slightly less efficient version of read()
+        return c;
+    }
+
+    // Whilst reading out the headers to whoever wants them, we'll keep an
+    // eye out for the "Content-Length" header
+    switch(iState)
+    {
+    case eStatusCodeRead:
+        // We're at the start of a line, or somewhere in the middle of reading
+        // the Content-Length prefix
+        if (*iContentLengthPtr == c)
+        {
+            // This character matches, just move along
+            iContentLengthPtr++;
+            if (*iContentLengthPtr == '\0')
+            {
+                // We've reached the end of the prefix
+                iState = eReadingContentLength;
+                // Just in case we get multiple Content-Length headers, this
+                // will ensure we just get the value of the last one
+                iContentLength = 0;
+                iBodyLengthConsumed = 0;
+            }
+        }
+        else if (*iTransferEncodingChunkedPtr == c)
+        {
+            // This character matches, just move along
+            iTransferEncodingChunkedPtr++;
+            if (*iTransferEncodingChunkedPtr == '\0')
+            {
+                // We've reached the end of the Transfer Encoding: chunked header
+                iIsChunked = true;
+                iState = eSkipToEndOfHeader;
+            }
+        }
+        else if (((iContentLengthPtr == kContentLengthPrefix) && (iTransferEncodingChunkedPtr == kTransferEncodingChunked)) && (c == '\r'))
+        {
+            // We've found a '\r' at the start of a line, so this is probably
+            // the end of the headers
+            iState = eLineStartingCRFound;
+        }
+        else
+        {
+            // This isn't the Content-Length or Transfer Encoding chunked header, skip to the end of the line
+            iState = eSkipToEndOfHeader;
+        }
+        break;
+    case eReadingContentLength:
+        if (isdigit(c))
+        {
+            iContentLength = iContentLength*10 + (c - '0');
+        }
+        else
+        {
+            // We've reached the end of the content length
+            // We could sanity check it here or double-check for "\r\n"
+            // rather than anything else, but let's be lenient
+            iState = eSkipToEndOfHeader;
+        }
+        break;
+    case eLineStartingCRFound:
+        if (c == '\n')
+        {
+            if (iIsChunked)
+            {
+                iState = eReadingChunkLength;
+                iChunkLength = 0;
+            }
+            else
+            {
+                iState = eReadingBody;
+            }
+        }
+        break;
+    default:
+        // We're just waiting for the end of the line now
+        break;
+    };
+
+    if ( (c == '\n') && !endOfHeadersReached() )
+    {
+        // We've got to the end of this line, start processing again
+        iState = eStatusCodeRead;
+        iContentLengthPtr = kContentLengthPrefix;
+        iTransferEncodingChunkedPtr = kTransferEncodingChunked;
+    }
+    // And return the character read to whoever wants it
+    return c;
+}
+
+
+

.pio/libdeps/esp32dev/ArduinoHttpClient/src/HttpClient.h

@@ -0,0 +1,392 @@
+// Class to simplify HTTP fetching on Arduino
+// (c) Copyright MCQN Ltd. 2010-2012
+// Released under Apache License, version 2.0
+
+#ifndef HttpClient_h
+#define HttpClient_h
+
+#include <Arduino.h>
+#include <IPAddress.h>
+#include "Client.h"
+
+static const int HTTP_SUCCESS =0;
+// The end of the headers has been reached.  This consumes the '\n'
+// Could not connect to the server
+static const int HTTP_ERROR_CONNECTION_FAILED =-1;
+// This call was made when the HttpClient class wasn't expecting it
+// to be called.  Usually indicates your code is using the class
+// incorrectly
+static const int HTTP_ERROR_API =-2;
+// Spent too long waiting for a reply
+static const int HTTP_ERROR_TIMED_OUT =-3;
+// The response from the server is invalid, is it definitely an HTTP
+// server?
+static const int HTTP_ERROR_INVALID_RESPONSE =-4;
+
+// Define some of the common methods and headers here
+// That lets other code reuse them without having to declare another copy
+// of them, so saves code space and RAM
+#define HTTP_METHOD_GET    "GET"
+#define HTTP_METHOD_POST   "POST"
+#define HTTP_METHOD_PUT    "PUT"
+#define HTTP_METHOD_PATCH  "PATCH"
+#define HTTP_METHOD_DELETE "DELETE"
+#define HTTP_HEADER_CONTENT_LENGTH "Content-Length"
+#define HTTP_HEADER_CONTENT_TYPE   "Content-Type"
+#define HTTP_HEADER_CONNECTION     "Connection"
+#define HTTP_HEADER_TRANSFER_ENCODING "Transfer-Encoding"
+#define HTTP_HEADER_USER_AGENT     "User-Agent"
+#define HTTP_HEADER_VALUE_CHUNKED  "chunked"
+
+class HttpClient : public Client
+{
+public:
+    static const int kNoContentLengthHeader =-1;
+    static const int kHttpPort =80;
+    static const char* kUserAgent;
+
+// FIXME Write longer API request, using port and user-agent, example
+// FIXME Update tempToPachube example to calculate Content-Length correctly
+
+    HttpClient(Client& aClient, const char* aServerName, uint16_t aServerPort = kHttpPort);
+    HttpClient(Client& aClient, const String& aServerName, uint16_t aServerPort = kHttpPort);
+    HttpClient(Client& aClient, const IPAddress& aServerAddress, uint16_t aServerPort = kHttpPort);
+
+    /** Start a more complex request.
+        Use this when you need to send additional headers in the request,
+        but you will also need to call endRequest() when you are finished.
+    */
+    void beginRequest();
+
+    /** End a more complex request.
+        Use this when you need to have sent additional headers in the request,
+        but you will also need to call beginRequest() at the start.
+    */
+    void endRequest();
+
+    /** Start the body of a more complex request.
+        Use this when you need to send the body after additional headers
+        in the request, but can optionally call endRequest() when
+        you are finished.
+    */
+    void beginBody();
+
+    /** Connect to the server and start to send a GET request.
+      @param aURLPath     Url to request
+      @return 0 if successful, else error
+    */
+    int get(const char* aURLPath);
+    int get(const String& aURLPath);
+
+    /** Connect to the server and start to send a POST request.
+      @param aURLPath     Url to request
+      @return 0 if successful, else error
+    */
+    int post(const char* aURLPath);
+    int post(const String& aURLPath);
+
+    /** Connect to the server and send a POST request
+        with body and content type
+      @param aURLPath     Url to request
+      @param aContentType Content type of request body
+      @param aBody        Body of the request
+      @return 0 if successful, else error
+    */
+    int post(const char* aURLPath, const char* aContentType, const char* aBody);
+    int post(const String& aURLPath, const String& aContentType, const String& aBody);
+    int post(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
+
+    /** Connect to the server and start to send a PUT request.
+      @param aURLPath     Url to request
+      @return 0 if successful, else error
+    */
+    int put(const char* aURLPath);
+    int put(const String& aURLPath);
+
+    /** Connect to the server and send a PUT request
+        with body and content type
+      @param aURLPath     Url to request
+      @param aContentType Content type of request body
+      @param aBody        Body of the request
+      @return 0 if successful, else error
+    */
+    int put(const char* aURLPath, const char* aContentType, const char* aBody);
+    int put(const String& aURLPath, const String& aContentType, const String& aBody);
+    int put(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
+
+    /** Connect to the server and start to send a PATCH request.
+      @param aURLPath     Url to request
+      @return 0 if successful, else error
+    */
+    int patch(const char* aURLPath);
+    int patch(const String& aURLPath);
+
+    /** Connect to the server and send a PATCH request
+        with body and content type
+      @param aURLPath     Url to request
+      @param aContentType Content type of request body
+      @param aBody        Body of the request
+      @return 0 if successful, else error
+    */
+    int patch(const char* aURLPath, const char* aContentType, const char* aBody);
+    int patch(const String& aURLPath, const String& aContentType, const String& aBody);
+    int patch(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
+
+    /** Connect to the server and start to send a DELETE request.
+      @param aURLPath     Url to request
+      @return 0 if successful, else error
+    */
+    int del(const char* aURLPath);
+    int del(const String& aURLPath);
+
+    /** Connect to the server and send a DELETE request
+        with body and content type
+      @param aURLPath     Url to request
+      @param aContentType Content type of request body
+      @param aBody        Body of the request
+      @return 0 if successful, else error
+    */
+    int del(const char* aURLPath, const char* aContentType, const char* aBody);
+    int del(const String& aURLPath, const String& aContentType, const String& aBody);
+    int del(const char* aURLPath, const char* aContentType, int aContentLength, const byte aBody[]);
+
+    /** Connect to the server and start to send the request.
+        If a body is provided, the entire request (including headers and body) will be sent
+      @param aURLPath        Url to request
+      @param aHttpMethod     Type of HTTP request to make, e.g. "GET", "POST", etc.
+      @param aContentType    Content type of request body (optional)
+      @param aContentLength  Length of request body (optional)
+      @param aBody           Body of request (optional)
+      @return 0 if successful, else error
+    */
+    int startRequest(const char* aURLPath,
+                     const char* aHttpMethod,
+                     const char* aContentType = NULL,
+                     int aContentLength = -1,
+                     const byte aBody[] = NULL);
+
+    /** Send an additional header line.  This can only be called in between the
+      calls to beginRequest and endRequest.
+      @param aHeader Header line to send, in its entirety (but without the
+                     trailing CRLF.  E.g. "Authorization: Basic YQDDCAIGES"
+    */
+    void sendHeader(const char* aHeader);
+
+    void sendHeader(const String& aHeader)
+      { sendHeader(aHeader.c_str()); }
+
+    /** Send an additional header line.  This is an alternate form of
+      sendHeader() which takes the header name and content as separate strings.
+      The call will add the ": " to separate the header, so for example, to
+      send a XXXXXX header call sendHeader("XXXXX", "Something")
+      @param aHeaderName Type of header being sent
+      @param aHeaderValue Value for that header
+    */
+    void sendHeader(const char* aHeaderName, const char* aHeaderValue);
+
+    void sendHeader(const String& aHeaderName, const String& aHeaderValue)
+      { sendHeader(aHeaderName.c_str(), aHeaderValue.c_str()); }
+
+    /** Send an additional header line.  This is an alternate form of
+      sendHeader() which takes the header name and content separately but where
+      the value is provided as an integer.
+      The call will add the ": " to separate the header, so for example, to
+      send a XXXXXX header call sendHeader("XXXXX", 123)
+      @param aHeaderName Type of header being sent
+      @param aHeaderValue Value for that header
+    */
+    void sendHeader(const char* aHeaderName, const int aHeaderValue);
+
+    void sendHeader(const String& aHeaderName, const int aHeaderValue)
+      { sendHeader(aHeaderName.c_str(), aHeaderValue); }
+
+    /** Send a basic authentication header.  This will encode the given username
+      and password, and send them in suitable header line for doing Basic
+      Authentication.
+      @param aUser Username for the authorization
+      @param aPassword Password for the user aUser
+    */
+    void sendBasicAuth(const char* aUser, const char* aPassword);
+
+    void sendBasicAuth(const String& aUser, const String& aPassword)
+      { sendBasicAuth(aUser.c_str(), aPassword.c_str()); }
+
+    /** Get the HTTP status code contained in the response.
+      For example, 200 for successful request, 404 for file not found, etc.
+    */
+    int responseStatusCode();
+
+    /** Check if a header is available to be read.
+      Use readHeaderName() to read header name, and readHeaderValue() to
+      read the header value
+      MUST be called after responseStatusCode() and before contentLength()
+    */
+    bool headerAvailable();
+
+    /** Read the name of the current response header.
+      Returns empty string if a header is not available.
+    */
+    String readHeaderName();
+
+    /** Read the vallue of the current response header.
+      Returns empty string if a header is not available.
+    */
+    String readHeaderValue();
+
+    /** Read the next character of the response headers.
+      This functions in the same way as read() but to be used when reading
+      through the headers.  Check whether or not the end of the headers has
+      been reached by calling endOfHeadersReached(), although after that point
+      this will still return data as read() would, but slightly less efficiently
+      MUST be called after responseStatusCode() and before contentLength()
+      @return The next character of the response headers
+    */
+    int readHeader();
+
+    /** Skip any response headers to get to the body.
+      Use this if you don't want to do any special processing of the headers
+      returned in the response.  You can also use it after you've found all of
+      the headers you're interested in, and just want to get on with processing
+      the body.
+      MUST be called after responseStatusCode()
+      @return HTTP_SUCCESS if successful, else an error code
+    */
+    int skipResponseHeaders();
+
+    /** Test whether all of the response headers have been consumed.
+      @return true if we are now processing the response body, else false
+    */
+    bool endOfHeadersReached();
+
+    /** Test whether the end of the body has been reached.
+      Only works if the Content-Length header was returned by the server
+      @return true if we are now at the end of the body, else false
+    */
+    bool endOfBodyReached();
+    virtual bool endOfStream() { return endOfBodyReached(); };
+    virtual bool completed() { return endOfBodyReached(); };
+
+    /** Return the length of the body.
+      Also skips response headers if they have not been read already
+      MUST be called after responseStatusCode()
+      @return Length of the body, in bytes, or kNoContentLengthHeader if no
+      Content-Length header was returned by the server
+    */
+    int contentLength();
+
+    /** Returns if the response body is chunked
+      @return true if response body is chunked, false otherwise
+    */
+    int isResponseChunked() { return iIsChunked; }
+
+    /** Return the response body as a String
+      Also skips response headers if they have not been read already
+      MUST be called after responseStatusCode()
+      @return response body of request as a String
+    */
+    String responseBody();
+
+    /** Enables connection keep-alive mode
+    */
+    void connectionKeepAlive();
+
+    /** Disables sending the default request headers (Host and User Agent)
+    */
+    void noDefaultRequestHeaders();
+
+    // Inherited from Print
+    // Note: 1st call to these indicates the user is sending the body, so if need
+    // Note: be we should finish the header first
+    virtual size_t write(uint8_t aByte) { if (iState < eRequestSent) { finishHeaders(); }; return iClient-> write(aByte); };
+    virtual size_t write(const uint8_t *aBuffer, size_t aSize) { if (iState < eRequestSent) { finishHeaders(); }; return iClient->write(aBuffer, aSize); };
+    // Inherited from Stream
+    virtual int available();
+    /** Read the next byte from the server.
+      @return Byte read or -1 if there are no bytes available.
+    */
+    virtual int read();
+    virtual int read(uint8_t *buf, size_t size);
+    virtual int peek() { return iClient->peek(); };
+    virtual void flush() { iClient->flush(); };
+
+    // Inherited from Client
+    virtual int connect(IPAddress ip, uint16_t port) { return iClient->connect(ip, port); };
+    virtual int connect(const char *host, uint16_t port) { return iClient->connect(host, port); };
+    virtual void stop();
+    virtual uint8_t connected() { return iClient->connected(); };
+    virtual operator bool() { return bool(iClient); };
+    virtual uint32_t httpResponseTimeout() { return iHttpResponseTimeout; };
+    virtual void setHttpResponseTimeout(uint32_t timeout) { iHttpResponseTimeout = timeout; };
+protected:
+    /** Reset internal state data back to the "just initialised" state
+    */
+    void resetState();
+
+    /** Send the first part of the request and the initial headers.
+      @param aURLPath	Url to request
+      @param aHttpMethod  Type of HTTP request to make, e.g. "GET", "POST", etc.
+      @return 0 if successful, else error
+    */
+    int sendInitialHeaders(const char* aURLPath,
+                     const char* aHttpMethod);
+
+    /* Let the server know that we've reached the end of the headers
+    */
+    void finishHeaders();
+
+    /** Reading any pending data from the client (used in connection keep alive mode)
+    */
+    void flushClientRx();
+
+    // Number of milliseconds that we wait each time there isn't any data
+    // available to be read (during status code and header processing)
+    static const int kHttpWaitForDataDelay = 1000;
+    // Number of milliseconds that we'll wait in total without receiveing any
+    // data before returning HTTP_ERROR_TIMED_OUT (during status code and header
+    // processing)
+    static const int kHttpResponseTimeout = 30*1000;
+    static const char* kContentLengthPrefix;
+    static const char* kTransferEncodingChunked;
+    typedef enum {
+        eIdle,
+        eRequestStarted,
+        eRequestSent,
+        eReadingStatusCode,
+        eStatusCodeRead,
+        eReadingContentLength,
+        eSkipToEndOfHeader,
+        eLineStartingCRFound,
+        eReadingBody,
+        eReadingChunkLength,
+        eReadingBodyChunk
+    } tHttpState;
+    // Client we're using
+    Client* iClient;
+    // Server we are connecting to
+    const char* iServerName;
+    IPAddress iServerAddress;
+    // Port of server we are connecting to
+    uint16_t iServerPort;
+    // Current state of the finite-state-machine
+    tHttpState iState;
+    // Stores the status code for the response, once known
+    int iStatusCode;
+    // Stores the value of the Content-Length header, if present
+    int iContentLength;
+    // How many bytes of the response body have been read by the user
+    int iBodyLengthConsumed;
+    // How far through a Content-Length header prefix we are
+    const char* iContentLengthPtr;
+    // How far through a Transfer-Encoding chunked header we are
+    const char* iTransferEncodingChunkedPtr;
+    // Stores if the response body is chunked
+    bool iIsChunked;
+    // Stores the value of the current chunk length, if present
+    int iChunkLength;
+    uint32_t iHttpResponseTimeout;
+    bool iConnectionClose;
+    bool iSendDefaultRequestHeaders;
+    String iHeaderLine;
+};
+
+#endif

.pio/libdeps/esp32dev/ArduinoHttpClient/src/URLEncoder.cpp

@@ -0,0 +1,53 @@
+// Library to simplify HTTP fetching on Arduino
+// (c) Copyright Arduino. 2019
+// Released under Apache License, version 2.0
+
+#include "URLEncoder.h"
+
+URLEncoderClass::URLEncoderClass()
+{
+}
+
+URLEncoderClass::~URLEncoderClass()
+{
+}
+
+String URLEncoderClass::encode(const char* str)
+{
+    return encode(str, strlen(str));
+}
+
+String URLEncoderClass::encode(const String& str)
+{
+    return encode(str.c_str(), str.length());
+}
+
+String URLEncoderClass::encode(const char* str, int length)
+{
+    String encoded;
+
+    encoded.reserve(length);
+
+    for (int i = 0; i < length; i++) {
+        char c = str[i];
+
+        const char HEX_DIGIT_MAPPER[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+        if (isAlphaNumeric(c) || (c == '-') || (c == '.') || (c == '_') || (c == '~')) {
+            encoded += c;
+        } else {
+            char s[4];
+
+            s[0] = '%';
+            s[1] = HEX_DIGIT_MAPPER[(c >> 4) & 0xf];
+            s[2] = HEX_DIGIT_MAPPER[(c & 0x0f)];
+            s[3] = 0;
+
+            encoded += s;
+        }
+    }
+
+    return encoded;
+}
+
+URLEncoderClass URLEncoder;

.pio/libdeps/esp32dev/ArduinoHttpClient/src/URLEncoder.h

@@ -0,0 +1,25 @@
+// Library to simplify HTTP fetching on Arduino
+// (c) Copyright Arduino. 2019
+// Released under Apache License, version 2.0
+
+#ifndef URL_ENCODER_H
+#define URL_ENCODER_H
+
+#include <Arduino.h>
+
+class URLEncoderClass
+{
+public:
+    URLEncoderClass();
+    virtual ~URLEncoderClass();
+
+    static String encode(const char* str);
+    static String encode(const String& str);
+
+private:
+    static String encode(const char* str, int length);
+};
+
+extern URLEncoderClass URLEncoder;
+
+#endif

.pio/libdeps/esp32dev/ArduinoHttpClient/src/WebSocketClient.cpp

@@ -0,0 +1,372 @@
+// (c) Copyright Arduino. 2016
+// Released under Apache License, version 2.0
+
+#include "b64.h"
+
+#include "WebSocketClient.h"
+
+WebSocketClient::WebSocketClient(Client& aClient, const char* aServerName, uint16_t aServerPort)
+ : HttpClient(aClient, aServerName, aServerPort),
+   iTxStarted(false),
+   iRxSize(0)
+{
+}
+
+WebSocketClient::WebSocketClient(Client& aClient, const String& aServerName, uint16_t aServerPort) 
+ : HttpClient(aClient, aServerName, aServerPort),
+   iTxStarted(false),
+   iRxSize(0)
+{
+}
+
+WebSocketClient::WebSocketClient(Client& aClient, const IPAddress& aServerAddress, uint16_t aServerPort)
+ : HttpClient(aClient, aServerAddress, aServerPort),
+   iTxStarted(false),
+   iRxSize(0)
+{
+}
+
+int WebSocketClient::begin(const char* aPath)
+{
+    // start the GET request
+    beginRequest();
+    connectionKeepAlive();
+    int status = get(aPath);
+
+    if (status == 0)
+    {
+        uint8_t randomKey[16];
+        char base64RandomKey[25];
+
+        // create a random key for the connection upgrade
+        for (int i = 0; i < (int)sizeof(randomKey); i++)
+        {
+            randomKey[i] = random(0x01, 0xff);
+        }
+        memset(base64RandomKey, 0x00, sizeof(base64RandomKey));
+        b64_encode(randomKey, sizeof(randomKey), (unsigned char*)base64RandomKey, sizeof(base64RandomKey));
+
+        // start the connection upgrade sequence
+        sendHeader("Upgrade", "websocket");
+        sendHeader("Connection", "Upgrade");
+        sendHeader("Sec-WebSocket-Key", base64RandomKey);
+        sendHeader("Sec-WebSocket-Version", "13");
+        endRequest();
+
+        status = responseStatusCode();
+
+        if (status > 0)
+        {
+            skipResponseHeaders();
+        }
+    }
+
+    iRxSize = 0;
+
+    // status code of 101 means success
+    return (status == 101) ? 0 : status;
+}
+
+int WebSocketClient::begin(const String& aPath)
+{
+    return begin(aPath.c_str());
+}
+
+int WebSocketClient::beginMessage(int aType)
+{
+    if (iTxStarted)
+    {
+        // fail TX already started
+        return 1;
+    }
+
+    iTxStarted = true;
+    iTxMessageType = (aType & 0xf);
+    iTxSize = 0;
+
+    return 0;
+}
+
+int WebSocketClient::endMessage()
+{
+    if (!iTxStarted)
+    {
+        // fail TX not started
+        return 1;
+    }
+
+    // send FIN + the message type (opcode)
+    HttpClient::write(0x80 | iTxMessageType);
+
+    // the message is masked (0x80)
+    // send the length
+    if (iTxSize < 126)
+    {
+        HttpClient::write(0x80 | (uint8_t)iTxSize);
+    }
+    else if (iTxSize < 0xffff)
+    {
+        HttpClient::write(0x80 | 126);
+        HttpClient::write((iTxSize >> 8) & 0xff);
+        HttpClient::write((iTxSize >> 0) & 0xff);
+    }
+    else
+    {
+        HttpClient::write(0x80 | 127);
+        HttpClient::write((iTxSize >> 56) & 0xff);
+        HttpClient::write((iTxSize >> 48) & 0xff);
+        HttpClient::write((iTxSize >> 40) & 0xff);
+        HttpClient::write((iTxSize >> 32) & 0xff);
+        HttpClient::write((iTxSize >> 24) & 0xff);
+        HttpClient::write((iTxSize >> 16) & 0xff);
+        HttpClient::write((iTxSize >> 8) & 0xff);
+        HttpClient::write((iTxSize >> 0) & 0xff);
+    }
+
+    uint8_t maskKey[4];
+
+    // create a random mask for the data and send
+    for (int i = 0; i < (int)sizeof(maskKey); i++)
+    {
+        maskKey[i] = random(0xff);
+    }
+    HttpClient::write(maskKey, sizeof(maskKey));
+
+    // mask the data and send
+    for (int i = 0; i < (int)iTxSize; i++) {
+        iTxBuffer[i] ^= maskKey[i % sizeof(maskKey)];
+    }
+
+    size_t txSize = iTxSize;
+
+    iTxStarted = false;
+    iTxSize = 0;
+
+    return (HttpClient::write(iTxBuffer, txSize) == txSize) ? 0 : 1;
+}
+
+size_t WebSocketClient::write(uint8_t aByte)
+{
+    return write(&aByte, sizeof(aByte));
+}
+
+size_t WebSocketClient::write(const uint8_t *aBuffer, size_t aSize)
+{
+    if (iState < eReadingBody)
+    {
+        // have not upgraded the connection yet
+        return HttpClient::write(aBuffer, aSize);
+    }
+
+    if (!iTxStarted)
+    {
+        // fail TX not   started
+        return 0;
+    }
+
+    // check if the write size, fits in the buffer
+    if ((iTxSize + aSize) > sizeof(iTxBuffer))
+    {
+        aSize = sizeof(iTxSize) - iTxSize;
+    }
+
+    // copy data into the buffer
+    memcpy(iTxBuffer + iTxSize, aBuffer, aSize);
+
+    iTxSize += aSize;
+    
+    return aSize;
+}
+
+int WebSocketClient::parseMessage()
+{
+    flushRx();
+
+    // make sure 2 bytes (opcode + length)
+    // are available
+    if (HttpClient::available() < 2)
+    {
+        return 0;
+    }
+
+    // read open code and length
+    uint8_t opcode = HttpClient::read();
+    int length = HttpClient::read();
+
+    if ((opcode & 0x0f) == 0)
+    {
+        // continuation, use previous opcode and update flags
+        iRxOpCode |= opcode;
+    }
+    else
+    {
+        iRxOpCode = opcode;
+    }
+
+    iRxMasked = (length & 0x80);
+    length &= 0x7f;
+
+    // read the RX size
+    if (length < 126)
+    {
+        iRxSize = length;
+    }
+    else if (length == 126)
+    {
+        iRxSize = (HttpClient::read() << 8) | HttpClient::read();
+    }
+    else
+    {
+        iRxSize = ((uint64_t)HttpClient::read() << 56) | 
+                    ((uint64_t)HttpClient::read() << 48) | 
+                    ((uint64_t)HttpClient::read() << 40) | 
+                    ((uint64_t)HttpClient::read() << 32) | 
+                    ((uint64_t)HttpClient::read() << 24) | 
+                    ((uint64_t)HttpClient::read() << 16) | 
+                    ((uint64_t)HttpClient::read() << 8)  |
+                    (uint64_t)HttpClient::read(); 
+    }
+
+    // read in the mask, if present
+    if (iRxMasked)
+    {
+        for (int i = 0; i < (int)sizeof(iRxMaskKey); i++)
+        {
+            iRxMaskKey[i] = HttpClient::read();
+        }
+    }
+
+    iRxMaskIndex = 0;
+
+    if (TYPE_CONNECTION_CLOSE == messageType())
+    {
+        flushRx();
+        stop();
+        iRxSize = 0;
+    }
+    else if (TYPE_PING == messageType())
+    {
+        beginMessage(TYPE_PONG);
+        while(available())
+        {
+            write(read());
+        }
+        endMessage();
+
+        iRxSize = 0;
+    }
+    else if (TYPE_PONG == messageType())
+    {
+        flushRx();
+        iRxSize = 0;
+    }
+
+    return iRxSize;
+}
+
+int WebSocketClient::messageType()
+{
+    return (iRxOpCode & 0x0f);
+}
+
+bool WebSocketClient::isFinal()
+{
+    return ((iRxOpCode & 0x80) != 0);
+}
+
+String WebSocketClient::readString()
+{
+    int avail = available();
+    String s;
+
+    if (avail > 0)
+    {
+        s.reserve(avail);
+
+        for (int i = 0; i < avail; i++)
+        {
+            s += (char)read();
+        }
+    }
+
+    return s;
+}
+
+int WebSocketClient::ping()
+{
+    uint8_t pingData[16];
+
+    // create random data for the ping
+    for (int i = 0; i < (int)sizeof(pingData); i++)
+    {
+        pingData[i] = random(0xff);
+    }
+
+    beginMessage(TYPE_PING);
+    write(pingData, sizeof(pingData));
+    return endMessage();
+}
+
+int WebSocketClient::available()
+{
+    if (iState < eReadingBody)
+    {
+        return HttpClient::available();
+    }
+
+    return iRxSize;
+}
+
+int WebSocketClient::read()
+{
+    byte b;
+
+    if (read(&b, sizeof(b)))
+    {
+        return b;
+    }
+
+    return -1;
+}
+
+int WebSocketClient::read(uint8_t *aBuffer, size_t aSize)
+{
+    int readCount = HttpClient::read(aBuffer, aSize);
+
+    if (readCount > 0)
+    {
+        iRxSize -= readCount;
+
+        // unmask the RX data if needed
+        if (iRxMasked)
+        {
+            for (int i = 0; i < (int)aSize; i++, iRxMaskIndex++)
+            {
+                aBuffer[i] ^= iRxMaskKey[iRxMaskIndex % sizeof(iRxMaskKey)];
+            }
+        }
+    }
+
+    return readCount;
+}
+
+int WebSocketClient::peek()
+{
+    int p = HttpClient::peek();
+
+    if (p != -1 && iRxMasked)
+    {
+        // unmask the RX data if needed
+        p = (uint8_t)p ^ iRxMaskKey[iRxMaskIndex % sizeof(iRxMaskKey)];
+    }
+
+    return p;
+}
+
+void WebSocketClient::flushRx()
+{
+    while(available())
+    {
+        read();
+    }
+}

.pio/libdeps/esp32dev/ArduinoHttpClient/src/WebSocketClient.h

@@ -0,0 +1,99 @@
+// (c) Copyright Arduino. 2016
+// Released under Apache License, version 2.0
+
+#ifndef WebSocketClient_h
+#define WebSocketClient_h
+
+#include <Arduino.h>
+
+#include "HttpClient.h"
+
+static const int TYPE_CONTINUATION     = 0x0;
+static const int TYPE_TEXT             = 0x1;
+static const int TYPE_BINARY           = 0x2;
+static const int TYPE_CONNECTION_CLOSE = 0x8;
+static const int TYPE_PING             = 0x9;
+static const int TYPE_PONG             = 0xa;
+
+class WebSocketClient : public HttpClient
+{
+public:
+    WebSocketClient(Client& aClient, const char* aServerName, uint16_t aServerPort = HttpClient::kHttpPort);
+    WebSocketClient(Client& aClient, const String& aServerName, uint16_t aServerPort = HttpClient::kHttpPort);
+    WebSocketClient(Client& aClient, const IPAddress& aServerAddress, uint16_t aServerPort = HttpClient::kHttpPort);
+
+    /** Start the Web Socket connection to the specified path
+      @param aURLPath     Path to use in request (optional, "/" is used by default)
+      @return 0 if successful, else error
+     */
+    int begin(const char* aPath = "/");
+    int begin(const String& aPath);
+
+    /** Begin to send a message of type (TYPE_TEXT or TYPE_BINARY)
+        Use the write or Stream API's to set message content, followed by endMessage
+        to complete the message.
+      @param aURLPath     Path to use in request
+      @return 0 if successful, else error
+    */
+    int beginMessage(int aType);
+
+    /** Completes sending of a message started by beginMessage
+      @return 0 if successful, else error
+    */
+    int endMessage();
+
+    /** Try to parse an incoming messages
+      @return 0 if no message available, else size of parsed message
+    */
+    int parseMessage();
+
+    /** Returns type of current parsed message
+      @return type of current parsedMessage (TYPE_TEXT or TYPE_BINARY)
+    */
+    int messageType();
+
+    /** Returns if the current message is the final chunk of a split
+        message
+      @return true for final message, false otherwise
+    */
+    bool isFinal();
+
+    /** Read the current messages as a string
+      @return current message as a string
+    */
+    String readString();
+
+    /** Send a ping
+      @return 0 if successful, else error
+    */
+    int ping();
+
+    // Inherited from Print
+    virtual size_t write(uint8_t aByte);
+    virtual size_t write(const uint8_t *aBuffer, size_t aSize);
+    // Inherited from Stream
+    virtual int available();
+    /** Read the next byte from the server.
+      @return Byte read or -1 if there are no bytes available.
+    */
+    virtual int read();
+    virtual int read(uint8_t *buf, size_t size);
+    virtual int peek();
+
+private:
+    void flushRx();
+
+private:
+    bool iTxStarted;
+    uint8_t iTxMessageType;
+    uint8_t iTxBuffer[128];
+    uint64_t iTxSize;
+
+    uint8_t iRxOpCode;
+    uint64_t iRxSize;
+    bool iRxMasked;
+    int iRxMaskIndex;
+    uint8_t iRxMaskKey[4];
+};
+
+#endif

.pio/libdeps/esp32dev/ArduinoHttpClient/src/b64.cpp

@@ -0,0 +1,72 @@
+// Simple Base64 code
+// (c) Copyright 2010 MCQN Ltd.
+// Released under Apache License, version 2.0
+
+#include "b64.h"
+
+/* Simple test program
+#include <stdio.h>
+void main()
+{
+    char* in = "amcewen";
+    char out[22];
+
+    b64_encode(in, 15, out, 22);
+    out[21] = '\0';
+
+    printf(out);
+}
+*/
+
+int b64_encode(const unsigned char* aInput, int aInputLen, unsigned char* aOutput, int aOutputLen)
+{
+    // Work out if we've got enough space to encode the input
+    // Every 6 bits of input becomes a byte of output
+    if (aOutputLen < (aInputLen*8)/6)
+    {
+        // FIXME Should we return an error here, or just the length
+        return (aInputLen*8)/6;
+    }
+
+    // If we get here we've got enough space to do the encoding
+
+    const char* b64_dictionary = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    if (aInputLen == 3)
+    {
+        aOutput[0] = b64_dictionary[aInput[0] >> 2];
+        aOutput[1] = b64_dictionary[(aInput[0] & 0x3)<<4|(aInput[1]>>4)];
+        aOutput[2] = b64_dictionary[(aInput[1]&0x0F)<<2|(aInput[2]>>6)];
+        aOutput[3] = b64_dictionary[aInput[2]&0x3F];
+    }
+    else if (aInputLen == 2)
+    {
+        aOutput[0] = b64_dictionary[aInput[0] >> 2];
+        aOutput[1] = b64_dictionary[(aInput[0] & 0x3)<<4|(aInput[1]>>4)];
+        aOutput[2] = b64_dictionary[(aInput[1]&0x0F)<<2];
+        aOutput[3] = '=';
+    }
+    else if (aInputLen == 1)
+    {
+        aOutput[0] = b64_dictionary[aInput[0] >> 2];
+        aOutput[1] = b64_dictionary[(aInput[0] & 0x3)<<4];
+        aOutput[2] = '=';
+        aOutput[3] = '=';
+    }
+    else
+    {
+        // Break the input into 3-byte chunks and process each of them
+        int i;
+        for (i = 0; i < aInputLen/3; i++)
+        {
+            b64_encode(&aInput[i*3], 3, &aOutput[i*4], 4);
+        }
+        if (aInputLen % 3 > 0)
+        {
+            // It doesn't fit neatly into a 3-byte chunk, so process what's left
+            b64_encode(&aInput[i*3], aInputLen % 3, &aOutput[i*4], aOutputLen - (i*4));
+        }
+    }
+
+    return ((aInputLen+2)/3)*4;
+}
+

.pio/libdeps/esp32dev/ArduinoHttpClient/src/b64.h

@@ -0,0 +1,6 @@
+#ifndef b64_h
+#define b64_h
+
+int b64_encode(const unsigned char* aInput, int aInputLen, unsigned char* aOutput, int aOutputLen);
+
+#endif

.pio/libdeps/esp32dev/EspSoftwareSerial/.gitignore

@@ -0,0 +1,33 @@
+
+#Ignore thumbnails created by Windows
+Thumbs.db
+#Ignore files built by Visual Studio
+*.obj
+*.exe
+*.pdb
+*.user
+*.aps
+*.pch
+*.vspscc
+*_i.c
+*_p.c
+*.ncb
+*.suo
+*.tlb
+*.tlh
+*.bak
+*.cache
+*.ilk
+*.log
+[Bb]in
+[Dd]ebug*/
+*.lib
+*.sbr
+obj/
+[Rr]elease*/
+_ReSharper*/
+[Tt]est[Rr]esult*
+.vs/
+#Nuget packages folder
+packages/
+__vm/

.pio/libdeps/esp32dev/EspSoftwareSerial/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "EspSoftwareSerial", "version": "6.17.1", "spec": {"owner": "plerup", "id": 168, "name": "EspSoftwareSerial", "requirements": null, "uri": null}}

.pio/libdeps/esp32dev/EspSoftwareSerial/LICENSE

@@ -0,0 +1,502 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

.pio/libdeps/esp32dev/EspSoftwareSerial/README.md

@@ -0,0 +1,169 @@
+# EspSoftwareSerial
+
+## Implementation of the Arduino software serial library for the ESP8266 / ESP32 family
+
+This fork implements interrupt service routine best practice.
+In the receive interrupt, instead of blocking for whole bytes
+at a time - voiding any near-realtime behavior of the CPU - only level
+change and timestamp are recorded. The more time consuming phase
+detection and byte assembly are done in the main code.
+
+Except at high bitrates, depending on other ongoing activity,
+interrupts in particular, this software serial adapter
+supports full duplex receive and send. At high bitrates (115200bps)
+send bit timing can be improved at the expense of blocking concurrent
+full duplex receives, with the `SoftwareSerial::enableIntTx(false)` function call.
+
+The same functionality is given as the corresponding AVR library but
+several instances can be active at the same time. Speed up to 115200 baud
+is supported. Besides a constructor compatible to the AVR SoftwareSerial class,
+and updated constructor that takes no arguments exists, instead the `begin()`
+function can handle the pin assignments and logic inversion.
+It also has optional input buffer capacity arguments for byte buffer and ISR bit buffer.
+This way, it is a better drop-in replacement for the hardware serial APIs on the ESP MCUs.
+
+Please note that due to the fact that the ESPs always have other activities
+ongoing, there will be some inexactness in interrupt timings. This may
+lead to inevitable, but few, bit errors when having heavy data traffic
+at high baud rates.
+
+This library supports ESP8266, ESP32, ESP32-S2 and ESP32-C3 devices.
+
+## Resource optimization
+
+The memory footprint can be optimized to just fit the amount of expected
+incoming asynchronous data.
+For this, the `SoftwareSerial` constructor provides two arguments. First, the
+octet buffer capacity for assembled received octets can be set. Read calls are
+satisfied from this buffer, freeing it in return.
+Second, the signal edge detection buffer of 32bit fields can be resized.
+One octet may require up to to 10 fields, but fewer may be needed,
+depending on the bit pattern. Any read or write calls check this buffer
+to assemble received octets, thus promoting completed octets to the octet
+buffer, freeing fields in the edge detection buffer.
+
+Look at the swsertest.ino example. There, on reset, ASCII characters ' ' to 'z'
+are sent. This happens not as a block write, but in a single write call per
+character. As the example uses a local loopback wire, every outgoing bit is
+immediately received back. Therefore, any single write call causes up to
+10 fields - depending on the exact bit pattern - to be occupied in the signal
+edge detection buffer. In turn, as explained before, each single write call
+also causes received bit assembly to be performed, promoting these bits from
+the signal edge detection buffer to the octet buffer as soon as possible.
+Explaining by way of contrast, if during a a single write call, perhaps because
+of using block writing, more than a single octet is received, there will be a
+need for more than 10 fields in the signal edge detection buffer.
+The necessary capacity of the octet buffer only depends on the amount of incoming
+data until the next read call.
+
+For the swsertest.ino example, this results in the following optimized
+constructor arguments to spend only the minimum RAM on buffers required:
+
+The octet buffer capacity (`bufCapacity`) is 95 (93 characters net plus two tolerance).
+The signal edge detection buffer capacity (`isrBufCapacity`) is 11, as each
+single octet can have up to 11 bits on the wire,
+which are immediately received during the write, and each
+write call causes the signal edge detection to promote the previously sent and
+received bits to the octet buffer.
+
+In a more generalized scenario, calculate the bits (use message size in octets
+times 10) that may be asynchronously received to determine the value for
+`isrBufCapacity` in the constructor. Also use the number of received octets
+that must be buffered for reading as the value of `bufCapacity`.
+The more frequently your code calls write or read functions, the greater the
+chances are that you can reduce the `isrBufCapacity` footprint without losing data,
+and each time you call read to fetch from the octet buffer, you reduce the
+need for space there.
+
+## SoftwareSerialConfig and parity
+The configuration of the data stream is done via a `SoftwareSerialConfig`
+argument to `begin()`. Word lengths can be set to between 5 and 8 bits, parity
+can be N(one), O(dd) or E(ven) and 1 or 2 stop bits can be used. The default is
+`SWSERIAL_8N1` using 8 bits, no parity and 1 stop bit but any combination can
+be used, e.g. `SWSERIAL_7E2`. If using EVEN or ODD parity, any parity errors
+can be detected with the `readParity()` and `parityEven()` or `parityOdd()`
+functions respectively. Note that the result of `readParity()` always applies
+to the preceding `read()` or `peek()` call, and is undefined if they report
+no data or an error.
+
+To allow flexible 9-bit and data/addressing protocols, the additional parity
+modes MARK and SPACE are also available. Furthermore, the parity mode can be
+individually set in each call to `write()`.
+
+This allows a simple implementation of protocols where the parity bit is used to
+distinguish between data and addresses/commands ("9-bit" protocols). First set
+up SoftwareSerial with parity mode SPACE, e.g. `SWSERIAL_8S1`. This will add a
+parity bit to every byte sent, setting it to logical zero (SPACE parity).
+
+To detect incoming bytes with the parity bit set (MARK parity), use the
+`readParity()` function. To send a byte with the parity bit set, just add
+`MARK` as the second argument when writing, e.g. `write(ch, SWSERIAL_PARITY_MARK)`.
+
+## Checking for correct pin selection / configuration 
+In general, most pins on the ESP8266 and ESP32 devices can be used by SoftwareSerial, 
+however each device has a number of pins that have special functions or require careful
+handling to prevent undesirable situations, for example they are connected to the 
+on-board SPI flash memory or they are used to determine boot and programming modes 
+after powerup or brownouts. These pins are not able to be configured by this library.
+
+The exact list for each device can be found in the
+[ESP32 data sheet](https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf)
+in sections 2.2 (Pin Descriptions) and 2.4 (Strapping pins). There is a discussion
+dedicated to the use of GPIO12 in this
+[note about GPIO12](https://github.com/espressif/esp-idf/tree/release/v3.2/examples/storage/sd_card#note-about-gpio12).
+Refer to the `isValidGPIOpin()`, `isValidRxGPIOpin()` and `isValidTxGPIOpin()`
+functions for the GPIO restrictions enforced by this library by default.
+
+The easiest and safest method is to test the object returned at runtime, to see if 
+it is valid. For example:
+
+```
+#include <SoftwareSerial.h>
+
+#define MYPORT_TX 12
+#define MYPORT_RX 13
+
+SoftwareSerial myPort;
+
+[...]
+
+Serial.begin(115200); // Standard hardware serial port
+
+myPort.begin(38400, SWSERIAL_8N1, MYPORT_RX, MYPORT_TX, false);
+if (!myPort) { // If the object did not initialize, then its configuration is invalid
+  Serial.println("Invalid SoftwareSerial pin configuration, check config"); 
+  while (1) { // Don't continue with invalid configuration
+    delay (1000);
+  }
+} 
+
+[...]
+```
+
+## Using and updating EspSoftwareSerial in the esp8266com/esp8266 Arduino build environment
+
+EspSoftwareSerial is both part of the BSP download for ESP8266 in Arduino,
+and it is set up as a Git submodule in the esp8266 source tree,
+specifically in `.../esp8266/libraries/SoftwareSerial` when using a Github
+repository clone in your Arduino sketchbook hardware directory.
+This supersedes any version of EspSoftwareSerial installed for instance via
+the Arduino library manager, it is not required to install EspSoftwareSerial
+for the ESP8266 separately at all, but doing so has ill effect.
+
+The responsible maintainer of the esp8266 repository has kindly shared the
+following command line instructions to use, if one wishes to manually
+update EspSoftwareSerial to a newer release than pulled in via the ESP8266 Arduino BSP:
+
+To update esp8266/arduino SoftwareSerial submodule to lastest master:
+
+Clean it (optional):
+```shell
+$ rm -rf libraries/SoftwareSerial
+$ git submodule update --init
+```
+Now update it:
+```shell
+$ cd libraries/SoftwareSerial
+$ git checkout master
+$ git pull
+```

.pio/libdeps/esp32dev/EspSoftwareSerial/examples/bitpattern/bitpattern.ino

@@ -0,0 +1,71 @@
+#include "SoftwareSerial.h"
+
+#ifndef D5
+#if defined(ESP8266)
+#define D8 (15)
+#define D5 (14)
+#define D7 (13)
+#define D6 (12)
+#define RX (3)
+#define TX (1)
+#elif defined(ESP32)
+#define D8 (5)
+#define D5 (18)
+#define D7 (23)
+#define D6 (19)
+#define RX (3)
+#define TX (1)
+#endif
+#endif
+
+SoftwareSerial swSer;
+#ifdef ESP8266
+auto logSer = SoftwareSerial(-1, TX);
+auto hwSer = Serial;
+#else
+auto logSer = Serial;
+auto hwSer = Serial1;
+#endif
+
+constexpr uint32_t TESTBPS = 115200;
+
+void setup() {
+	delay(2000);
+#ifdef ESP8266
+	hwSer.begin(TESTBPS, SERIAL_8N1);
+	hwSer.swap();
+#else
+	hwSer.begin(TESTBPS, SERIAL_8N1, D6, D5);
+#endif
+	logSer.begin(115200);
+	logSer.println(PSTR("\nOne Wire Half Duplex Bitpattern and Datarate Test"));
+	swSer.begin(TESTBPS, SWSERIAL_8N1, D6, D5);
+	swSer.enableIntTx(true);
+	logSer.println(PSTR("Tx on swSer"));
+}
+
+uint8_t val = 0xff;
+
+void loop() {
+	swSer.write((uint8_t)0x00);
+	swSer.write(val);
+	swSer.write(val);
+	auto start = ESP.getCycleCount();
+	int rxCnt = 0;
+	while (ESP.getCycleCount() - start < ESP.getCpuFreqMHz() * 1000000 / 10) {
+		if (hwSer.available()) {
+			auto rxVal = hwSer.read();
+			if ((!rxCnt && rxVal) || (rxCnt && rxVal != val)) {
+				logSer.printf(PSTR("Rx bit error: tx = 0x%02x, rx = 0x%02x\n"), val, rxVal);
+			}
+			++rxCnt;
+		}
+	}
+	if (rxCnt != 3) {
+		logSer.printf(PSTR("Rx cnt error, tx = 0x%02x\n"), val);
+	}
+	++val;
+	if (!val) {
+		logSer.println("Starting over");
+	}
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/examples/loopback/loopback.ino

@@ -0,0 +1,279 @@
+#include <SoftwareSerial.h>
+
+// On ESP8266:
+// Local SoftwareSerial loopback, connect D5 (rx) and D6 (tx).
+// For local hardware loopback, connect D5 to D8 (tx), D6 to D7 (rx).
+// For hardware send/sink, connect D7 (rx) and D8 (tx).
+// Hint: The logger is run at 9600bps such that enableIntTx(true) can remain unchanged. Blocking
+// interrupts severely impacts the ability of the SoftwareSerial devices to operate concurrently
+// and/or in duplex mode.
+// Operating in software serial full duplex mode, runs at 19200bps and few errors (~2.5%).
+// Operating in software serial half duplex mode (both loopback and repeater),
+// runs at 57600bps with nearly no errors.
+// Operating loopback in full duplex, and repeater in half duplex, runs at 38400bps with nearly no errors.
+// On ESP32:
+// For SoftwareSerial or hardware send/sink, connect D5 (rx) and D6 (tx).
+// Hardware Serial2 defaults to D4 (rx), D3 (tx).
+// For local hardware loopback, connect D5 (rx) to D3 (tx), D6 (tx) to D4 (rx).
+
+#ifndef D5
+#if defined(ESP8266)
+#define D8 (15)
+#define D5 (14)
+#define D7 (13)
+#define D6 (12)
+#define RX (3)
+#define TX (1)
+#elif defined(ESP32)
+#define D8 (5)
+#define D5 (18)
+#define D7 (23)
+#define D6 (19)
+#define RX (3)
+#define TX (1)
+#endif
+#endif
+
+// Pick only one of HWLOOPBACK, HWSOURCESWSINK, or HWSOURCESINK
+//#define HWLOOPBACK 1
+//#define HWSOURCESWSINK 1
+//#define HWSOURCESINK 1
+#define HALFDUPLEX 1
+
+#ifdef ESP32
+constexpr int IUTBITRATE = 19200;
+#else
+constexpr int IUTBITRATE = 19200;
+#endif
+
+#if defined(ESP8266)
+constexpr SoftwareSerialConfig swSerialConfig = SWSERIAL_8E1;
+constexpr SerialConfig hwSerialConfig = SERIAL_8E1;
+#elif defined(ESP32)
+constexpr SoftwareSerialConfig swSerialConfig = SWSERIAL_8E1;
+constexpr uint32_t hwSerialConfig = SERIAL_8E1;
+#else
+constexpr unsigned swSerialConfig = 3;
+#endif
+constexpr bool invert = false;
+
+constexpr int BLOCKSIZE = 16; // use fractions of 256
+
+unsigned long start;
+const char effTxTxt[] PROGMEM = "eff. tx: ";
+const char effRxTxt[] PROGMEM = "eff. rx: ";
+int txCount;
+int rxCount;
+int expected;
+int rxErrors;
+int rxParityErrors;
+constexpr int ReportInterval = IUTBITRATE / 8;
+
+#if defined(ESP8266)
+#if defined(HWLOOPBACK) || defined(HWSOURCESWSINK)
+HardwareSerial& hwSerial(Serial);
+SoftwareSerial serialIUT;
+SoftwareSerial logger;
+#elif defined(HWSOURCESINK)
+HardwareSerial& serialIUT(Serial);
+SoftwareSerial logger;
+#else
+SoftwareSerial serialIUT;
+HardwareSerial& logger(Serial);
+#endif
+#elif defined(ESP32)
+#if defined(HWLOOPBACK) || defined (HWSOURCESWSINK)
+HardwareSerial& hwSerial(Serial2);
+SoftwareSerial serialIUT;
+#elif defined(HWSOURCESINK)
+HardwareSerial& serialIUT(Serial2);
+#else
+SoftwareSerial serialIUT;
+#endif
+HardwareSerial& logger(Serial);
+#else
+SoftwareSerial serialIUT(14, 12);
+HardwareSerial& logger(Serial);
+#endif
+
+void setup() {
+#if defined(ESP8266)
+#if defined(HWLOOPBACK) || defined(HWSOURCESINK) || defined(HWSOURCESWSINK)
+    Serial.begin(IUTBITRATE, hwSerialConfig, SERIAL_FULL, 1, invert);
+    Serial.swap();
+    Serial.setRxBufferSize(2 * BLOCKSIZE);
+    logger.begin(9600, SWSERIAL_8N1, -1, TX);
+#else
+    logger.begin(9600);
+#endif
+#if !defined(HWSOURCESINK)
+    serialIUT.begin(IUTBITRATE, swSerialConfig, D5, D6, invert, 2 * BLOCKSIZE);
+#ifdef HALFDUPLEX
+    serialIUT.enableIntTx(false);
+#endif
+#endif
+#elif defined(ESP32)
+#if defined(HWLOOPBACK) || defined(HWSOURCESWSINK)
+    Serial2.begin(IUTBITRATE, hwSerialConfig, D4, D3, invert);
+    Serial2.setRxBufferSize(2 * BLOCKSIZE);
+#elif defined(HWSOURCESINK)
+    serialIUT.begin(IUTBITRATE, hwSerialConfig, D5, D6, invert);
+    serialIUT.setRxBufferSize(2 * BLOCKSIZE);
+#endif
+#if !defined(HWSOURCESINK)
+    serialIUT.begin(IUTBITRATE, swSerialConfig, D5, D6, invert, 2 * BLOCKSIZE);
+#ifdef HALFDUPLEX
+    serialIUT.enableIntTx(false);
+#endif
+#endif
+    logger.begin(9600);
+#else
+#if !defined(HWSOURCESINK)
+    serialIUT.begin(IUTBITRATE);
+#endif
+    logger.begin(9600);
+#endif
+
+    logger.println(PSTR("Loopback example for EspSoftwareSerial"));
+
+    start = micros();
+    txCount = 0;
+    rxCount = 0;
+    rxErrors = 0;
+    rxParityErrors = 0;
+    expected = -1;
+}
+
+unsigned char c = 0;
+
+void loop() {
+#ifdef HALFDUPLEX
+    char block[BLOCKSIZE];
+#endif
+    char inBuf[BLOCKSIZE];
+    for (int i = 0; i < BLOCKSIZE; ++i) {
+#ifndef HALFDUPLEX
+#ifdef HWSOURCESWSINK
+        hwSerial.write(c);
+#else
+        serialIUT.write(c);
+#endif
+#ifdef HWLOOPBACK
+        int avail = hwSerial.available();
+        while ((0 == (i % 8)) && avail > 0) {
+            int inCnt = hwSerial.read(inBuf, min(avail, min(BLOCKSIZE, hwSerial.availableForWrite())));
+            hwSerial.write(inBuf, inCnt);
+            avail -= inCnt;
+        }
+#endif
+#else
+        block[i] = c;
+#endif
+        c = (c + 1) % 256;
+        ++txCount;
+    }
+#ifdef HALFDUPLEX
+#ifdef HWSOURCESWSINK
+    hwSerial.write(block, BLOCKSIZE);
+#else
+    serialIUT.write(block, BLOCKSIZE);
+#endif
+#endif
+#ifdef HWSOURCESINK
+#if defined(ESP8266)
+    if (serialIUT.hasOverrun()) { logger.println(PSTR("serialIUT.overrun")); }
+#endif
+#else
+    if (serialIUT.overflow()) { logger.println(PSTR("serialIUT.overflow")); }
+#endif
+
+    int inCnt;
+    uint32_t deadlineStart;
+
+#ifdef HWLOOPBACK
+    // starting deadline for the first bytes to become readable
+    deadlineStart = ESP.getCycleCount();
+    inCnt = 0;
+    while ((ESP.getCycleCount() - deadlineStart) < (1000000UL * 12 * BLOCKSIZE) / IUTBITRATE * 24 * ESP.getCpuFreqMHz()) {
+        int avail = hwSerial.available();
+        inCnt += hwSerial.read(&inBuf[inCnt], min(avail, min(BLOCKSIZE - inCnt, hwSerial.availableForWrite())));
+        if (inCnt >= BLOCKSIZE) { break; }
+        // wait for more outstanding bytes to trickle in
+        if (avail) deadlineStart = ESP.getCycleCount();
+    }
+    hwSerial.write(inBuf, inCnt);
+#endif
+
+    // starting deadline for the first bytes to come in
+    deadlineStart = ESP.getCycleCount();
+    inCnt = 0;
+    while ((ESP.getCycleCount() - deadlineStart) < (1000000UL * 12 * BLOCKSIZE) / IUTBITRATE * 8 * ESP.getCpuFreqMHz()) {
+        int avail;
+        if (0 != (swSerialConfig & 070))
+            avail = serialIUT.available();
+        else
+            avail = serialIUT.read(inBuf, BLOCKSIZE);
+        for (int i = 0; i < avail; ++i)
+        {
+            unsigned char r;
+            if (0 != (swSerialConfig & 070))
+                r = serialIUT.read();
+            else
+                r = inBuf[i];
+            if (expected == -1) { expected = r; }
+            else {
+                expected = (expected + 1) % (1UL << (5 + swSerialConfig % 4));
+            }
+            if (r != expected) {
+                ++rxErrors;
+                expected = -1;
+            }
+#ifndef HWSOURCESINK
+            if (serialIUT.readParity() != (static_cast<bool>(swSerialConfig & 010) ? serialIUT.parityOdd(r) : serialIUT.parityEven(r)))
+            {
+                ++rxParityErrors;
+            }
+#elif defined(ESP8266)
+            // current ESP8266 API does not flag parity errors separately
+            if (serialIUT.hasRxError())
+            {
+                ++rxParityErrors;
+            }
+#endif
+            ++rxCount;
+            ++inCnt;
+        }
+
+        if (inCnt >= BLOCKSIZE) { break; }
+        // wait for more outstanding bytes to trickle in
+        if (avail) deadlineStart = ESP.getCycleCount();
+    }
+
+    const uint32_t interval = micros() - start;
+    if (txCount >= ReportInterval && interval) {
+        uint8_t wordBits = (5 + swSerialConfig % 4) + static_cast<bool>(swSerialConfig & 070) + 1 + ((swSerialConfig & 0300) ? 1 : 0);
+        logger.println(String(PSTR("tx/rx: ")) + txCount + PSTR("/") + rxCount);
+        const long txCps = txCount * (1000000.0 / interval);
+        const long rxCps = rxCount * (1000000.0 / interval);
+        logger.print(String(FPSTR(effTxTxt)) + wordBits * txCps + PSTR("bps, ")
+            + effRxTxt + wordBits * rxCps + PSTR("bps, ")
+            + rxErrors + PSTR(" errors (") + 100.0 * rxErrors / (!rxErrors ? 1 : rxCount) + PSTR("%)"));
+        if (0 != (swSerialConfig & 070))
+        {
+            logger.print(PSTR(" (")); logger.print(rxParityErrors); logger.println(PSTR(" parity errors)"));
+        }
+        else
+        {
+            logger.println();
+        }
+        txCount = 0;
+        rxCount = 0;
+        rxErrors = 0;
+        rxParityErrors = 0;
+        expected = -1;
+        // resync
+        delay(1000UL * 12 * BLOCKSIZE / IUTBITRATE * 16);
+        serialIUT.flush();
+        start = micros();
+    }
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/examples/onewiretest/onewiretest.ino

@@ -0,0 +1,59 @@
+#include "SoftwareSerial.h"
+
+#ifndef D5
+#if defined(ESP8266)
+#define D5 (14)
+#define D6 (12)
+#elif defined(ESP32)
+#define D5 (18)
+#define D6 (19)
+#endif
+#endif
+
+SoftwareSerial swSer1;
+SoftwareSerial swSer2;
+
+void setup() {
+	delay(2000);
+	Serial.begin(115200);
+	Serial.println(PSTR("\nOne Wire Half Duplex Serial Tester"));
+	swSer1.begin(115200, SWSERIAL_8N1, D6, D6, false, 256);
+	// high speed half duplex, turn off interrupts during tx
+	swSer1.enableIntTx(false);
+	swSer2.begin(115200, SWSERIAL_8N1, D5, D5, false, 256);
+	// high speed half duplex, turn off interrupts during tx
+	swSer2.enableIntTx(false);
+}
+
+void loop() {
+	Serial.println(PSTR("\n\nTesting on swSer1"));
+	Serial.print(PSTR("Enter something to send using swSer1."));
+	checkSwSerial(&swSer1);
+
+	Serial.println(PSTR("\n\nTesting on swSer2"));
+	Serial.print(PSTR("Enter something to send using swSer2."));
+	checkSwSerial(&swSer2);
+
+}
+
+void checkSwSerial(SoftwareSerial* ss) {
+	byte ch;
+	while (!Serial.available());
+	ss->enableTx(true);
+	while (Serial.available()) {
+		ch = Serial.read();
+		ss->write(ch);
+	}
+	ss->enableTx(false);
+	// wait 1 second for the reply from SOftwareSerial if any
+	delay(1000);
+	if (ss->available()) {
+		Serial.print(PSTR("\nResult:"));
+		while (ss->available()) {
+			ch = (byte)ss->read();
+			Serial.print(ch < 0x10 ? PSTR(" 0") : PSTR(" "));
+			Serial.print(ch, HEX);
+		}
+		Serial.println();
+	}
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/examples/repeater/repeater.ino

@@ -0,0 +1,199 @@
+#include <SoftwareSerial.h>
+
+// On ESP8266:
+// SoftwareSerial loopback for remote source (loopback.ino), or hardware loopback.
+// Connect source D5 (rx) to local D8 (tx), source D6 (tx) to local D7 (rx).
+// Hint: The logger is run at 9600bps such that enableIntTx(true) can remain unchanged. Blocking
+// interrupts severely impacts the ability of the SoftwareSerial devices to operate concurrently
+// and/or in duplex mode.
+// On ESP32:
+// For software or hardware loopback, connect source rx to local D8 (tx), source tx to local D7 (rx).
+
+#ifndef D5
+#if defined(ESP8266)
+#define D8 (15)
+#define D5 (14)
+#define D7 (13)
+#define D6 (12)
+#define RX (3)
+#define TX (1)
+#elif defined(ESP32)
+#define D8 (5)
+#define D5 (18)
+#define D7 (23)
+#define D6 (19)
+#define RX (3)
+#define TX (1)
+#endif
+#endif
+
+#define HWLOOPBACK 1
+#define HALFDUPLEX 1
+
+#ifdef ESP32
+constexpr int IUTBITRATE = 19200;
+#else
+constexpr int IUTBITRATE = 19200;
+#endif
+
+#if defined(ESP8266)
+constexpr SoftwareSerialConfig swSerialConfig = SWSERIAL_8E1;
+constexpr SerialConfig hwSerialConfig = SERIAL_8E1;
+#elif defined(ESP32)
+constexpr SoftwareSerialConfig swSerialConfig = SWSERIAL_8E1;
+constexpr uint32_t hwSerialConfig = SERIAL_8E1;
+#else
+constexpr unsigned swSerialConfig = 3;
+#endif
+constexpr bool invert = false;
+
+constexpr int BLOCKSIZE = 16; // use fractions of 256
+
+unsigned long start;
+const char bitRateTxt[] PROGMEM = "Effective data rate: ";
+int rxCount;
+int seqErrors;
+int parityErrors;
+int expected;
+constexpr int ReportInterval = IUTBITRATE / 8;
+
+#if defined(ESP8266)
+#if defined(HWLOOPBACK)
+HardwareSerial& repeater(Serial);
+SoftwareSerial logger;
+#else
+SoftwareSerial repeater;
+HardwareSerial& logger(Serial);
+#endif
+#elif defined(ESP32)
+#if defined(HWLOOPBACK)
+HardwareSerial& repeater(Serial2);
+#else
+SoftwareSerial repeater;
+#endif
+HardwareSerial& logger(Serial);
+#else
+SoftwareSerial repeater(14, 12);
+HardwareSerial& logger(Serial);
+#endif
+
+void setup() {
+#if defined(ESP8266)
+#if defined(HWLOOPBACK)
+    repeater.begin(IUTBITRATE, hwSerialConfig, SERIAL_FULL, 1, invert);
+    repeater.swap();
+    repeater.setRxBufferSize(2 * BLOCKSIZE);
+    logger.begin(9600, SWSERIAL_8N1, -1, TX);
+#else
+    repeater.begin(IUTBITRATE, swSerialConfig, D7, D8, invert, 4 * BLOCKSIZE);
+#ifdef HALFDUPLEX
+    repeater.enableIntTx(false);
+#endif
+    logger.begin(9600);
+#endif
+#elif defined(ESP32)
+#if defined(HWLOOPBACK)
+    repeater.begin(IUTBITRATE, hwSerialConfig, D7, D8, invert);
+    repeater.setRxBufferSize(2 * BLOCKSIZE);
+#else
+    repeater.begin(IUTBITRATE, swSerialConfig, D7, D8, invert, 4 * BLOCKSIZE);
+#ifdef HALFDUPLEX
+    repeater.enableIntTx(false);
+#endif
+#endif
+    logger.begin(9600);
+#else
+    repeater.begin(IUTBITRATE);
+    logger.begin(9600);
+#endif
+
+    logger.println(PSTR("Repeater example for EspSoftwareSerial"));
+    start = micros();
+    rxCount = 0;
+    seqErrors = 0;
+    parityErrors = 0;
+    expected = -1;
+}
+
+void loop() {
+#ifdef HWLOOPBACK
+#if defined(ESP8266)
+    if (repeater.hasOverrun()) { logger.println(PSTR("repeater.overrun")); }
+#endif
+#else
+    if (repeater.overflow()) { logger.println(PSTR("repeater.overflow")); }
+#endif
+
+#ifdef HALFDUPLEX
+    char block[BLOCKSIZE];
+#endif
+    // starting deadline for the first bytes to come in
+    uint32_t deadlineStart = ESP.getCycleCount();
+    int inCnt = 0;
+    while ((ESP.getCycleCount() - deadlineStart) < (1000000UL * 12 * BLOCKSIZE) / IUTBITRATE * 24 * ESP.getCpuFreqMHz()) {
+        int avail = repeater.available();
+        for (int i = 0; i < avail; ++i)
+        {
+            int r = repeater.read();
+            if (r == -1) { logger.println(PSTR("read() == -1")); }
+            if (expected == -1) { expected = r; }
+            else {
+                expected = (expected + 1) % (1UL << (5 + swSerialConfig % 4));
+            }
+            if (r != expected) {
+                ++seqErrors;
+                expected = -1;
+            }
+#ifndef HWLOOPBACK
+            if (repeater.readParity() != (static_cast<bool>(swSerialConfig & 010) ? repeater.parityOdd(r) : repeater.parityEven(r)))
+            {
+                ++parityErrors;
+            }
+#elif defined(ESP8266)
+            // current ESP8266 API does not flag parity errors separately
+            if (repeater.hasRxError())
+            {
+                ++parityErrors;
+            }
+#endif
+            ++rxCount;
+#ifdef HALFDUPLEX
+            block[inCnt] = r;
+#else
+            repeater.write(r);
+#endif
+            if (++inCnt >= BLOCKSIZE) { break; }
+        }
+        if (inCnt >= BLOCKSIZE) { break; }
+        // wait for more outstanding bytes to trickle in
+        if (avail) deadlineStart = ESP.getCycleCount();
+    }
+
+#ifdef HALFDUPLEX
+    repeater.write(block, inCnt);
+#endif
+
+    if (rxCount >= ReportInterval) {
+        auto end = micros();
+        unsigned long interval = end - start;
+        long cps = rxCount * (1000000.0 / interval);
+        long seqErrorsps = seqErrors * (1000000.0 / interval);
+        logger.print(String(FPSTR(bitRateTxt)) + 10 * cps + PSTR("bps, ")
+            + seqErrorsps + PSTR("cps seq. errors (") + 100.0 * seqErrors / rxCount + PSTR("%)"));
+#ifndef HWLOOPBACK
+        if (0 != (swSerialConfig & 070))
+        {
+            logger.print(PSTR(" (")); logger.print(parityErrors); logger.println(PSTR(" parity errors)"));
+        }
+        else
+#endif
+        {
+            logger.println();
+        }
+        start = end;
+        rxCount = 0;
+        seqErrors = 0;
+        parityErrors = 0;
+        expected = -1;
+    }
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/examples/servoTester/servoTester.ino

@@ -0,0 +1,113 @@
+#include <SoftwareSerial.h>
+
+SoftwareSerial swSer;
+
+byte buf[10] =               { 0xFA, 0xAF,0x00,0x00,0x00, 0x00, 0x00, 0x00, 0x00, 0xED };
+const byte cmd[10] PROGMEM = { 0xFA, 0xAF,0x00,0x00,0x00, 0x00, 0x00, 0x00, 0x00, 0xED };
+
+
+void setup() {
+	delay(2000);
+	Serial.begin(115200);
+	Serial.println(PSTR("\nAlpha 1S Servo Tester"));
+	swSer.begin(115200, SWSERIAL_8N1, 12, 12, false, 256);
+}
+
+void loop() {
+	for (int i = 1; i <= 32; i++) {
+		GetVersion(i);
+		delay(100);
+	}
+	SetLED(1, 0);
+	GoPos(1, 0, 50);
+	delay(1000);
+	GoPos(1, 90, 50);
+	delay(1000);
+	GoPos(1, 100, 50);
+	delay(1000);
+	SetLED(1, 1);
+	delay(2000);
+}
+
+
+
+
+void GetVersion(byte id) {
+	memcpy_P(buf, cmd, 10);
+	buf[0] = 0xFC;
+	buf[1] = 0xCF;
+	buf[2] = id;
+	buf[3] = 0x01;
+	SendCommand();
+}
+
+
+void GoPos(byte id, byte Pos, byte Time) {
+	memcpy_P(buf, cmd, 10);
+	buf[2] = id;
+	buf[3] = 0x01;
+	buf[4] = Pos;
+	buf[5] = Time;
+	buf[6] = 0x00;
+	buf[7] = Time;
+	SendCommand();
+}
+
+void GetPos(byte id) {
+	memcpy_P(buf, cmd, 10);
+	buf[2] = id;
+	buf[3] = 0x02;
+	SendCommand();
+}
+
+
+void SetLED(byte id, byte mode) {
+	memcpy_P(buf, cmd, 10);
+	buf[2] = id;
+	buf[3] = 0x04;
+	buf[4] = mode;
+	SendCommand();
+}
+
+void SendCommand() {
+	SendCommand(true);
+}
+
+void SendCommand(bool checkResult) {
+	byte sum = 0;
+	for (int i = 2; i < 8; i++) {
+		sum += buf[i];
+	}
+	buf[8] = sum;
+	ShowCommand();
+	swSer.flush();
+	swSer.enableTx(true);
+	swSer.write(buf, 10);
+	swSer.enableTx(false);
+	if (checkResult) checkReturn();
+}
+
+void ShowCommand() {
+	Serial.print(millis());
+	Serial.print(PSTR(" OUT>>"));
+	for (int i = 0; i < 10; i++) {
+		Serial.print(buf[i] < 0x10 ? PSTR(" 0") : PSTR(" "));
+		Serial.print(buf[i], HEX);
+	}
+	Serial.println();
+}
+
+void checkReturn() {
+	unsigned long startMs = millis();
+	while (((millis() - startMs) < 500) && (!swSer.available()));
+	if (swSer.available()) {
+		Serial.print(millis());
+		Serial.print(PSTR(" IN>>>"));
+		while (swSer.available()) {
+			byte ch = (byte)swSer.read();
+			Serial.print((ch < 0x10 ? PSTR(" 0") : PSTR(" ")));
+			Serial.print(ch, HEX);
+		}
+		Serial.println();
+	}
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/examples/swsertest/swsertest.ino

@@ -0,0 +1,79 @@
+// On ESP8266:
+// At 80MHz runs up 57600ps, and at 160MHz CPU frequency up to 115200bps with only negligible errors.
+// Connect pin 13 to 15.
+// For verification and as a example for how to use SW serial on the USB to PC connection,
+// which allows the use of HW Serial on GPIO13 and GPIO15 instead, #define SWAPSERIAL below.
+// Notice how the bitrates are also swapped then between RX/TX and GPIO13/GPIO15.
+// Builtin debug output etc. must be stopped on HW Serial in this case, as it would interfere with the
+// external communication on GPIO13/GPIO15.
+
+#include <SoftwareSerial.h>
+
+#ifndef D5
+#if defined(ESP8266)
+#define D8 (15)
+#define D5 (14)
+#define D7 (13)
+#define D6 (12)
+#define RX (3)
+#define TX (1)
+#elif defined(ESP32)
+#define D8 (5)
+#define D5 (18)
+#define D7 (23)
+#define D6 (19)
+#define RX (3)
+#define TX (1)
+#endif
+#endif
+
+#ifdef ESP32
+#define BAUD_RATE 57600
+#else
+#define BAUD_RATE 57600
+#endif
+
+#undef SWAPSERIAL
+
+#ifndef SWAPSERIAL
+auto& usbSerial = Serial;
+SoftwareSerial testSerial;
+#else
+SoftwareSerial usbSerial;
+auto& testSerial = Serial;
+#endif
+
+void setup() {
+#ifndef SWAPSERIAL
+    usbSerial.begin(115200);
+    // Important: the buffer size optimizations here, in particular the isrBufSize (11) that is only sufficiently
+    // large to hold a single word (up to start - 8 data - parity - stop), are on the basis that any char written
+    // to the loopback SoftwareSerial adapter gets read before another write is performed.
+    // Block writes with a size greater than 1 would usually fail. Do not copy this into your own project without
+    // reading the documentation.
+    testSerial.begin(BAUD_RATE, SWSERIAL_8N1, D7, D8, false, 95, 11);
+#else
+    testSerial.begin(115200);
+    testSerial.setDebugOutput(false);
+    testSerial.swap();
+    usbSerial.begin(BAUD_RATE, SWSERIAL_8N1, RX, TX, false, 95);
+#endif
+
+    usbSerial.println(PSTR("\nSoftware serial test started"));
+
+    for (char ch = ' '; ch <= 'z'; ch++) {
+        testSerial.write(ch);
+    }
+    testSerial.println();
+}
+
+void loop() {
+    while (testSerial.available() > 0) {
+        usbSerial.write(testSerial.read());
+        yield();
+    }
+    while (usbSerial.available() > 0) {
+        testSerial.write(usbSerial.read());
+        yield();
+    }
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/keywords.txt

@@ -0,0 +1,43 @@
+#######################################
+# Syntax Coloring Map for SoftwareSerial
+# (esp8266)
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+SoftwareSerial	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+baudRate	KEYWORD2
+setTransmitEnablePin	KEYWORD2
+enableIntTx	KEYWORD2
+overflow	KEYWORD2
+available	KEYWORD2
+peek	KEYWORD2
+read	KEYWORD2
+flush	KEYWORD2
+write	KEYWORD2
+enableRx	KEYWORD2
+enableTx	KEYWORD2
+listen	KEYWORD2
+end	KEYWORD2
+isListening	KEYWORD2
+stopListening	KEYWORD2
+onReceive	KEYWORD2
+perform_work	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+SW_SERIAL_UNUSED_PIN	LITERAL1
+SWSERIAL_5N1	LITERAL1
+SWSERIAL_6N1	LITERAL1
+SWSERIAL_7N1	LITERAL1
+SWSERIAL_8N1	LITERAL1

.pio/libdeps/esp32dev/EspSoftwareSerial/library.json

@@ -0,0 +1,26 @@
+{
+    "name": "EspSoftwareSerial",
+    "version": "6.17.1",
+    "description": "Implementation of the Arduino software serial for ESP8266/ESP32.",
+    "keywords": [
+        "serial", "io", "softwareserial"
+    ],
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/plerup/espsoftwareserial"
+    },
+    "authors": [
+        {
+            "name": "Dirk Kaar"
+        },
+        {
+            "name": "Peter Lerup"
+        }
+    ],
+    "license": "LGPL-2.1+",
+    "frameworks": "arduino",
+    "platforms": [
+        "espressif8266", "espressif32"
+    ]
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/library.properties

@@ -0,0 +1,9 @@
+name=EspSoftwareSerial
+version=6.17.1
+author=Dirk Kaar, Peter Lerup
+maintainer=Dirk Kaar <dok@dok-net.net>
+sentence=Implementation of the Arduino software serial for ESP8266/ESP32.
+paragraph=
+category=Signal Input/Output
+url=https://github.com/plerup/espsoftwareserial/
+architectures=esp8266,esp32

.pio/libdeps/esp32dev/EspSoftwareSerial/src/SoftwareSerial.cpp

@@ -0,0 +1,679 @@
+/*
+
+SoftwareSerial.cpp - Implementation of the Arduino software serial for ESP8266/ESP32.
+Copyright (c) 2015-2016 Peter Lerup. All rights reserved.
+Copyright (c) 2018-2019 Dirk O. Kaar. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#include "SoftwareSerial.h"
+#include <Arduino.h>
+
+#ifndef ESP32
+uint32_t SoftwareSerial::m_savedPS = 0;
+#else
+portMUX_TYPE SoftwareSerial::m_interruptsMux = portMUX_INITIALIZER_UNLOCKED;
+#endif
+
+inline void IRAM_ATTR SoftwareSerial::disableInterrupts()
+{
+#ifndef ESP32
+    m_savedPS = xt_rsil(15);
+#else
+    taskENTER_CRITICAL(&m_interruptsMux);
+#endif
+}
+
+inline void IRAM_ATTR SoftwareSerial::restoreInterrupts()
+{
+#ifndef ESP32
+    xt_wsr_ps(m_savedPS);
+#else
+    taskEXIT_CRITICAL(&m_interruptsMux);
+#endif
+}
+
+constexpr uint8_t BYTE_ALL_BITS_SET = ~static_cast<uint8_t>(0);
+
+SoftwareSerial::SoftwareSerial() {
+    m_isrOverflow = false;
+    m_rxGPIOPullUpEnabled = true;
+    m_txGPIOOpenDrain = false;
+}
+
+SoftwareSerial::SoftwareSerial(int8_t rxPin, int8_t txPin, bool invert)
+{
+    m_isrOverflow = false;
+    m_rxGPIOPullUpEnabled = true;
+    m_txGPIOOpenDrain = false;
+    m_rxPin = rxPin;
+    m_txPin = txPin;
+    m_invert = invert;
+}
+
+SoftwareSerial::~SoftwareSerial() {
+    end();
+}
+
+#if __GNUC__ >= 10
+constexpr
+#endif
+bool SoftwareSerial::isValidGPIOpin(int8_t pin) const {
+#if defined(ESP8266)
+    return (pin >= 0 && pin <= 16) && !isFlashInterfacePin(pin);
+#elif defined(ESP32)
+    // Remove the strapping pins as defined in the datasheets, they affect bootup and other critical operations
+    // Remmove the flash memory pins on related devices, since using these causes memory access issues.
+#ifdef CONFIG_IDF_TARGET_ESP32
+    // Datasheet https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf,
+    // Pinout    https://docs.espressif.com/projects/esp-idf/en/latest/esp32/_images/esp32-devkitC-v4-pinout.jpg    
+    return (pin == 1) || (pin >= 3 && pin <= 5) ||
+        (pin >= 12 && pin <= 15) ||
+        (!psramFound() && pin >= 16 && pin <= 17) ||
+        (pin >= 18 && pin <= 19) ||
+        (pin >= 21 && pin <= 23) || (pin >= 25 && pin <= 27) || (pin >= 32 && pin <= 39);
+#elif CONFIG_IDF_TARGET_ESP32S2
+    // Datasheet https://www.espressif.com/sites/default/files/documentation/esp32-s2_datasheet_en.pdf,
+    // Pinout    https://docs.espressif.com/projects/esp-idf/en/latest/esp32s2/_images/esp32-s2_saola1-pinout.jpg
+    return (pin >= 1 && pin <= 21) || (pin >= 33 && pin <= 44);
+#elif CONFIG_IDF_TARGET_ESP32C3
+    // Datasheet https://www.espressif.com/sites/default/files/documentation/esp32-c3_datasheet_en.pdf, 
+    // Pinout    https://docs.espressif.com/projects/esp-idf/en/latest/esp32c3/_images/esp32-c3-devkitm-1-v1-pinout.jpg
+    return (pin >= 0 && pin <= 1) || (pin >= 3 && pin <= 7) || (pin >= 18 && pin <= 21);
+#else 
+    return pin >= 0;
+#endif
+#else
+    return pin >= 0;
+#endif
+}
+
+#if __GNUC__ >= 10
+constexpr
+#endif
+bool SoftwareSerial::isValidRxGPIOpin(int8_t pin) const {
+    return isValidGPIOpin(pin)
+#if defined(ESP8266)
+        && (pin != 16)
+#endif
+        ;
+}
+
+#if __GNUC__ >= 10
+constexpr
+#endif
+bool SoftwareSerial::isValidTxGPIOpin(int8_t pin) const {
+    return isValidGPIOpin(pin)
+#if defined(ESP32)
+#ifdef CONFIG_IDF_TARGET_ESP32
+        && (pin < 34)
+#elif CONFIG_IDF_TARGET_ESP32S2
+        && (pin <= 45)
+#elif CONFIG_IDF_TARGET_ESP32C3
+        // no restrictions
+#endif
+#endif
+        ;
+}
+
+#if __GNUC__ >= 10
+constexpr
+#endif
+bool SoftwareSerial::hasRxGPIOPullUp(int8_t pin) const {
+#if defined(ESP32)
+    return !(pin >= 34 && pin <= 39);
+#else
+    (void)pin;
+    return true;
+#endif
+}
+
+void SoftwareSerial::setRxGPIOPinMode() {
+    if (m_rxValid) {
+        pinMode(m_rxPin, hasRxGPIOPullUp(m_rxPin) && m_rxGPIOPullUpEnabled ? INPUT_PULLUP : INPUT);
+    }
+}
+
+void SoftwareSerial::setTxGPIOPinMode() {
+    if (m_txValid) {
+        pinMode(m_txPin, m_txGPIOOpenDrain ? OUTPUT_OPEN_DRAIN : OUTPUT);
+    }
+}
+
+void SoftwareSerial::begin(uint32_t baud, SoftwareSerialConfig config,
+    int8_t rxPin, int8_t txPin,
+    bool invert, int bufCapacity, int isrBufCapacity) {
+    if (-1 != rxPin) m_rxPin = rxPin;
+    if (-1 != txPin) m_txPin = txPin;
+    m_oneWire = (m_rxPin == m_txPin);
+    m_invert = invert;
+    m_dataBits = 5 + (config & 07);
+    m_parityMode = static_cast<SoftwareSerialParity>(config & 070);
+    m_stopBits = 1 + ((config & 0300) ? 1 : 0);
+    m_pduBits = m_dataBits + static_cast<bool>(m_parityMode) + m_stopBits;
+    m_bitTicks = (microsToTicks(1000000UL) + baud / 2) / baud;
+    m_intTxEnabled = true;
+    if (isValidRxGPIOpin(m_rxPin)) {
+        m_rxReg = portInputRegister(digitalPinToPort(m_rxPin));
+        m_rxBitMask = digitalPinToBitMask(m_rxPin);
+        m_buffer.reset(new circular_queue<uint8_t>((bufCapacity > 0) ? bufCapacity : 64));
+        if (m_parityMode)
+        {
+            m_parityBuffer.reset(new circular_queue<uint8_t>((m_buffer->capacity() + 7) / 8));
+            m_parityInPos = m_parityOutPos = 1;
+        }
+        m_isrBuffer.reset(new circular_queue<uint32_t, SoftwareSerial*>((isrBufCapacity > 0) ?
+            isrBufCapacity : m_buffer->capacity() * (2 + m_dataBits + static_cast<bool>(m_parityMode))));
+        if (m_buffer && (!m_parityMode || m_parityBuffer) && m_isrBuffer) {
+            m_rxValid = true;
+            setRxGPIOPinMode();
+        }
+    }
+    if (isValidTxGPIOpin(m_txPin)) {
+#if !defined(ESP8266)
+        m_txReg = portOutputRegister(digitalPinToPort(m_txPin));
+#endif
+        m_txBitMask = digitalPinToBitMask(m_txPin);
+        m_txValid = true;
+        if (!m_oneWire) {
+            setTxGPIOPinMode();
+            digitalWrite(m_txPin, !m_invert);
+        }
+    }
+    enableRx(true);
+}
+
+void SoftwareSerial::end()
+{
+    enableRx(false);
+    m_txValid = false;
+    if (m_buffer) {
+        m_buffer.reset();
+    }
+    m_parityBuffer.reset();
+    if (m_isrBuffer) {
+        m_isrBuffer.reset();
+    }
+}
+
+uint32_t SoftwareSerial::baudRate() {
+    return 1000000UL / ticksToMicros(m_bitTicks);
+}
+
+void SoftwareSerial::setTransmitEnablePin(int8_t txEnablePin) {
+    if (isValidTxGPIOpin(txEnablePin)) {
+        m_txEnableValid = true;
+        m_txEnablePin = txEnablePin;
+        pinMode(m_txEnablePin, OUTPUT);
+        digitalWrite(m_txEnablePin, LOW);
+    }
+    else {
+        m_txEnableValid = false;
+    }
+}
+
+void SoftwareSerial::enableIntTx(bool on) {
+    m_intTxEnabled = on;
+}
+
+void SoftwareSerial::enableRxGPIOPullUp(bool on) {
+    m_rxGPIOPullUpEnabled = on;
+    setRxGPIOPinMode();
+}
+
+void SoftwareSerial::enableTxGPIOOpenDrain(bool on) {
+    m_txGPIOOpenDrain = on;
+    setTxGPIOPinMode();
+}
+
+void SoftwareSerial::enableTx(bool on) {
+    if (m_txValid && m_oneWire) {
+        if (on) {
+            enableRx(false);
+            setTxGPIOPinMode();
+            digitalWrite(m_txPin, !m_invert);
+        }
+        else {
+            setRxGPIOPinMode();
+            enableRx(true);
+        }
+    }
+}
+
+void SoftwareSerial::enableRx(bool on) {
+    if (m_rxValid && on != m_rxEnabled) {
+        if (on) {
+            m_rxLastBit = m_pduBits - 1;
+            // Init to stop bit level and current tick
+            m_isrLastTick = (microsToTicks(micros()) | 1) ^ m_invert;
+            if (m_bitTicks >= microsToTicks(1000000UL / 74880UL))
+                attachInterruptArg(digitalPinToInterrupt(m_rxPin), reinterpret_cast<void (*)(void*)>(rxBitISR), this, CHANGE);
+            else
+                attachInterruptArg(digitalPinToInterrupt(m_rxPin), reinterpret_cast<void (*)(void*)>(rxBitSyncISR), this, m_invert ? RISING : FALLING);
+        }
+        else {
+            detachInterrupt(digitalPinToInterrupt(m_rxPin));
+        }
+        m_rxEnabled = on;
+    }
+}
+
+int SoftwareSerial::read() {
+    if (!m_rxValid) { return -1; }
+    if (!m_buffer->available()) {
+        rxBits();
+        if (!m_buffer->available()) { return -1; }
+    }
+    auto val = m_buffer->pop();
+    if (m_parityBuffer)
+    {
+        m_lastReadParity = m_parityBuffer->peek() & m_parityOutPos;
+        m_parityOutPos <<= 1;
+        if (!m_parityOutPos)
+        {
+            m_parityOutPos = 1;
+            m_parityBuffer->pop();
+        }
+    }
+    return val;
+}
+
+int SoftwareSerial::read(uint8_t* buffer, size_t size) {
+    if (!m_rxValid) { return 0; }
+    int avail;
+    if (0 == (avail = m_buffer->pop_n(buffer, size))) {
+        rxBits();
+        avail = m_buffer->pop_n(buffer, size);
+    }
+    if (!avail) return 0;
+    if (m_parityBuffer) {
+        uint32_t parityBits = avail;
+        while (m_parityOutPos >>= 1) ++parityBits;
+        m_parityOutPos = (1 << (parityBits % 8));
+        m_parityBuffer->pop_n(nullptr, parityBits / 8);
+    }
+    return avail;
+}
+
+size_t SoftwareSerial::readBytes(uint8_t* buffer, size_t size) {
+    if (!m_rxValid || !size) { return 0; }
+    size_t count = 0;
+    auto start = millis();
+    do {
+        auto readCnt = read(&buffer[count], size - count);
+        count += readCnt;
+        if (count >= size) break;
+        if (readCnt) {
+            start = millis();
+        }
+        else {
+            optimistic_yield(1000UL);
+        }
+    } while (millis() - start < _timeout);
+    return count;
+}
+
+int SoftwareSerial::available() {
+    if (!m_rxValid) { return 0; }
+    rxBits();
+    int avail = m_buffer->available();
+    if (!avail) {
+        optimistic_yield(10000UL);
+    }
+    return avail;
+}
+
+void SoftwareSerial::lazyDelay() {
+    // Reenable interrupts while delaying to avoid other tasks piling up
+    if (!m_intTxEnabled) { restoreInterrupts(); }
+    const auto expired = microsToTicks(micros()) - m_periodStart;
+    const int32_t remaining = m_periodDuration - expired;
+    const int32_t ms = remaining > 0 ? static_cast<int32_t>(ticksToMicros(remaining) / 1000L) : 0;
+    if (ms > 0)
+    {
+        delay(ms);
+    }
+    else
+    {
+        optimistic_yield(10000UL);
+    }
+    // Assure that below-ms part of delays are not elided
+    preciseDelay();
+    // Disable interrupts again if applicable
+    if (!m_intTxEnabled) { disableInterrupts(); }
+}
+
+void IRAM_ATTR SoftwareSerial::preciseDelay() {
+    uint32_t ticks;
+    uint32_t expired;
+    do {
+        ticks = microsToTicks(micros());
+        expired =  ticks - m_periodStart;
+    } while (static_cast<int32_t>(m_periodDuration - expired) > 0);
+    m_periodDuration = 0;
+    m_periodStart = ticks;
+}
+
+void IRAM_ATTR SoftwareSerial::writePeriod(
+    uint32_t dutyCycle, uint32_t offCycle, bool withStopBit) {
+    preciseDelay();
+    if (dutyCycle)
+    {
+#if defined(ESP8266)
+        if (16 == m_txPin) {
+            GP16O = 1;
+        }
+        else {
+            GPOS = m_txBitMask;
+        }
+#else
+        *m_txReg |= m_txBitMask;
+#endif
+        m_periodDuration += dutyCycle;
+        if (offCycle || (withStopBit && !m_invert)) {
+            if (!withStopBit || m_invert) {
+                preciseDelay();
+            }
+            else {
+                lazyDelay();
+            }
+        }
+    }
+    if (offCycle)
+    {
+#if defined(ESP8266)
+        if (16 == m_txPin) {
+            GP16O = 0;
+        }
+        else {
+            GPOC = m_txBitMask;
+        }
+#else
+        *m_txReg &= ~m_txBitMask;
+#endif
+        m_periodDuration += offCycle;
+        if (withStopBit && m_invert) lazyDelay();
+    }
+}
+
+size_t SoftwareSerial::write(uint8_t byte) {
+    return write(&byte, 1);
+}
+
+size_t SoftwareSerial::write(uint8_t byte, SoftwareSerialParity parity) {
+    return write(&byte, 1, parity);
+}
+
+size_t SoftwareSerial::write(const uint8_t* buffer, size_t size) {
+    return write(buffer, size, m_parityMode);
+}
+
+size_t IRAM_ATTR SoftwareSerial::write(const uint8_t* buffer, size_t size, SoftwareSerialParity parity) {
+    if (m_rxValid) { rxBits(); }
+    if (!m_txValid) { return -1; }
+
+    if (m_txEnableValid) {
+        digitalWrite(m_txEnablePin, HIGH);
+    }
+    // Stop bit: if inverted, LOW, otherwise HIGH
+    bool b = !m_invert;
+    uint32_t dutyCycle = 0;
+    uint32_t offCycle = 0;
+    if (!m_intTxEnabled) {
+        // Disable interrupts in order to get a clean transmit timing
+        disableInterrupts();
+    }
+    const uint32_t dataMask = ((1UL << m_dataBits) - 1);
+    bool withStopBit = true;
+    m_periodDuration = 0;
+    m_periodStart = microsToTicks(micros());
+    for (size_t cnt = 0; cnt < size; ++cnt) {
+        uint8_t byte = pgm_read_byte(buffer + cnt) & dataMask;
+        // push LSB start-data-parity-stop bit pattern into uint32_t
+        // Stop bits: HIGH
+        uint32_t word = ~0UL;
+        // inverted parity bit, performance tweak for xor all-bits-set word
+        if (parity && m_parityMode)
+        {
+            uint32_t parityBit;
+            switch (parity)
+            {
+            case SWSERIAL_PARITY_EVEN:
+                // from inverted, so use odd parity
+                parityBit = byte;
+                parityBit ^= parityBit >> 4;
+                parityBit &= 0xf;
+                parityBit = (0x9669 >> parityBit) & 1;
+                break;
+            case SWSERIAL_PARITY_ODD:
+                // from inverted, so use even parity
+                parityBit = byte;
+                parityBit ^= parityBit >> 4;
+                parityBit &= 0xf;
+                parityBit = (0x6996 >> parityBit) & 1;
+                break;
+            case SWSERIAL_PARITY_MARK:
+                parityBit = 0;
+                break;
+            case SWSERIAL_PARITY_SPACE:
+                // suppresses warning parityBit uninitialized
+            default:
+                parityBit = 1;
+                break;
+            }
+            word ^= parityBit;
+        }
+        word <<= m_dataBits;
+        word |= byte;
+        // Start bit: LOW
+        word <<= 1;
+        if (m_invert) word = ~word;
+        for (int i = 0; i <= m_pduBits; ++i) {
+            bool pb = b;
+            b = word & (1UL << i);
+            if (!pb && b) {
+                writePeriod(dutyCycle, offCycle, withStopBit);
+                withStopBit = false;
+                dutyCycle = offCycle = 0;
+            }
+            if (b) {
+                dutyCycle += m_bitTicks;
+            }
+            else {
+                offCycle += m_bitTicks;
+            }
+        }
+        withStopBit = true;
+    }
+    writePeriod(dutyCycle, offCycle, true);
+    if (!m_intTxEnabled) {
+        // restore the interrupt state if applicable
+        restoreInterrupts();
+    }
+    if (m_txEnableValid) {
+        digitalWrite(m_txEnablePin, LOW);
+    }
+    return size;
+}
+
+void SoftwareSerial::flush() {
+    if (!m_rxValid) { return; }
+    m_buffer->flush();
+    if (m_parityBuffer)
+    {
+        m_parityInPos = m_parityOutPos = 1;
+        m_parityBuffer->flush();
+    }
+}
+
+bool SoftwareSerial::overflow() {
+    bool res = m_overflow;
+    m_overflow = false;
+    return res;
+}
+
+int SoftwareSerial::peek() {
+    if (!m_rxValid) { return -1; }
+    if (!m_buffer->available()) {
+        rxBits();
+        if (!m_buffer->available()) return -1;
+    }
+    auto val = m_buffer->peek();
+    if (m_parityBuffer) m_lastReadParity = m_parityBuffer->peek() & m_parityOutPos;
+    return val;
+}
+
+void SoftwareSerial::rxBits() {
+#ifdef ESP8266
+    if (m_isrOverflow.load()) {
+        m_overflow = true;
+        m_isrOverflow.store(false);
+    }
+#else
+    if (m_isrOverflow.exchange(false)) {
+        m_overflow = true;
+    }
+#endif
+
+    m_isrBuffer->for_each(m_isrBufferForEachDel);
+
+    // A stop bit can go undetected if leading data bits are at same level
+    // and there was also no next start bit yet, so one word may be pending.
+    // Check that there was no new ISR data received in the meantime, inserting an
+    // extraneous stop level bit out of sequence breaks rx.
+    if (m_rxLastBit < m_pduBits - 1) {
+        const uint32_t detectionTicks = (m_pduBits - 1 - m_rxLastBit) * m_bitTicks;
+        if (!m_isrBuffer->available() && microsToTicks(micros()) - m_isrLastTick > detectionTicks) {
+            // Produce faux stop bit level, prevents start bit maldetection
+            // tick's LSB is repurposed for the level bit
+            rxBits(((m_isrLastTick + detectionTicks) | 1) ^ m_invert);
+        }
+    }
+}
+
+void SoftwareSerial::rxBits(const uint32_t isrTick) {
+    const bool level = (m_isrLastTick & 1) ^ m_invert;
+
+    // error introduced by edge value in LSB of isrTick is negligible
+    uint32_t ticks = isrTick - m_isrLastTick;
+    m_isrLastTick = isrTick;
+
+    uint32_t bits = ticks / m_bitTicks;
+    if (ticks % m_bitTicks > (m_bitTicks >> 1)) ++bits;
+    while (bits > 0) {
+        // start bit detection
+        if (m_rxLastBit >= (m_pduBits - 1)) {
+            // leading edge of start bit?
+            if (level) break;
+            m_rxLastBit = -1;
+            --bits;
+            continue;
+        }
+        // data bits
+        if (m_rxLastBit < (m_dataBits - 1)) {
+            uint8_t dataBits = min(bits, static_cast<uint32_t>(m_dataBits - 1 - m_rxLastBit));
+            m_rxLastBit += dataBits;
+            bits -= dataBits;
+            m_rxCurByte >>= dataBits;
+            if (level) { m_rxCurByte |= (BYTE_ALL_BITS_SET << (8 - dataBits)); }
+            continue;
+        }
+        // parity bit
+        if (m_parityMode && m_rxLastBit == (m_dataBits - 1)) {
+            ++m_rxLastBit;
+            --bits;
+            m_rxCurParity = level;
+            continue;
+        }
+        // stop bits
+        // Store the received value in the buffer unless we have an overflow
+        // if not high stop bit level, discard word
+        if (bits >= static_cast<uint32_t>(m_pduBits - 1 - m_rxLastBit) && level) {
+            m_rxCurByte >>= (sizeof(uint8_t) * 8 - m_dataBits);
+            if (!m_buffer->push(m_rxCurByte)) {
+                m_overflow = true;
+            }
+            else {
+                if (m_parityBuffer)
+                {
+                    if (m_rxCurParity) {
+                        m_parityBuffer->pushpeek() |= m_parityInPos;
+                    }
+                    else {
+                        m_parityBuffer->pushpeek() &= ~m_parityInPos;
+                    }
+                    m_parityInPos <<= 1;
+                    if (!m_parityInPos)
+                    {
+                        m_parityBuffer->push();
+                        m_parityInPos = 1;
+                    }
+                }
+            }
+        }
+        m_rxLastBit = m_pduBits - 1;
+        // reset to 0 is important for masked bit logic
+        m_rxCurByte = 0;
+        m_rxCurParity = false;
+        break;
+    }
+}
+
+void IRAM_ATTR SoftwareSerial::rxBitISR(SoftwareSerial* self) {
+    uint32_t curTick = microsToTicks(micros());
+    bool level = *self->m_rxReg & self->m_rxBitMask;
+
+    // Store level and tick in the buffer unless we have an overflow
+    // tick's LSB is repurposed for the level bit
+    if (!self->m_isrBuffer->push((curTick | 1U) ^ !level)) self->m_isrOverflow.store(true);
+}
+
+void IRAM_ATTR SoftwareSerial::rxBitSyncISR(SoftwareSerial* self) {
+    uint32_t start = microsToTicks(micros());
+    uint32_t wait = self->m_bitTicks - microsToTicks(2U);
+
+    bool level = self->m_invert;
+    // Store level and tick in the buffer unless we have an overflow
+    // tick's LSB is repurposed for the level bit
+    if (!self->m_isrBuffer->push(((start + wait) | 1U) ^ !level)) self->m_isrOverflow.store(true);
+
+    for (uint32_t i = 0; i < self->m_pduBits; ++i) {
+        while (microsToTicks(micros()) - start < wait) {};
+        wait += self->m_bitTicks;
+
+        // Store level and tick in the buffer unless we have an overflow
+        // tick's LSB is repurposed for the level bit
+        if (static_cast<bool>(*self->m_rxReg & self->m_rxBitMask) != level)
+        {
+            if (!self->m_isrBuffer->push(((start + wait) | 1U) ^ level)) self->m_isrOverflow.store(true);
+            level = !level;
+        }
+    }
+}
+
+void SoftwareSerial::onReceive(Delegate<void(int available), void*> handler) {
+    receiveHandler = handler;
+}
+
+void SoftwareSerial::perform_work() {
+    if (!m_rxValid) { return; }
+    rxBits();
+    if (receiveHandler) {
+        int avail = m_buffer->available();
+        if (avail) { receiveHandler(avail); }
+    }
+}

.pio/libdeps/esp32dev/EspSoftwareSerial/src/SoftwareSerial.h

@@ -0,0 +1,301 @@
+/*
+SoftwareSerial.h
+
+SoftwareSerial.cpp - Implementation of the Arduino software serial for ESP8266/ESP32.
+Copyright (c) 2015-2016 Peter Lerup. All rights reserved.
+Copyright (c) 2018-2019 Dirk O. Kaar. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#ifndef __SoftwareSerial_h
+#define __SoftwareSerial_h
+
+#include "circular_queue/circular_queue.h"
+#include <Stream.h>
+
+enum SoftwareSerialParity : uint8_t {
+    SWSERIAL_PARITY_NONE = 000,
+    SWSERIAL_PARITY_EVEN = 020,
+    SWSERIAL_PARITY_ODD = 030,
+    SWSERIAL_PARITY_MARK = 040,
+    SWSERIAL_PARITY_SPACE = 070,
+};
+
+enum SoftwareSerialConfig {
+    SWSERIAL_5N1 = SWSERIAL_PARITY_NONE,
+    SWSERIAL_6N1,
+    SWSERIAL_7N1,
+    SWSERIAL_8N1,
+    SWSERIAL_5E1 = SWSERIAL_PARITY_EVEN,
+    SWSERIAL_6E1,
+    SWSERIAL_7E1,
+    SWSERIAL_8E1,
+    SWSERIAL_5O1 = SWSERIAL_PARITY_ODD,
+    SWSERIAL_6O1,
+    SWSERIAL_7O1,
+    SWSERIAL_8O1,
+    SWSERIAL_5M1 = SWSERIAL_PARITY_MARK,
+    SWSERIAL_6M1,
+    SWSERIAL_7M1,
+    SWSERIAL_8M1,
+    SWSERIAL_5S1 = SWSERIAL_PARITY_SPACE,
+    SWSERIAL_6S1,
+    SWSERIAL_7S1,
+    SWSERIAL_8S1,
+    SWSERIAL_5N2 = 0200 | SWSERIAL_PARITY_NONE,
+    SWSERIAL_6N2,
+    SWSERIAL_7N2,
+    SWSERIAL_8N2,
+    SWSERIAL_5E2 = 0200 | SWSERIAL_PARITY_EVEN,
+    SWSERIAL_6E2,
+    SWSERIAL_7E2,
+    SWSERIAL_8E2,
+    SWSERIAL_5O2 = 0200 | SWSERIAL_PARITY_ODD,
+    SWSERIAL_6O2,
+    SWSERIAL_7O2,
+    SWSERIAL_8O2,
+    SWSERIAL_5M2 = 0200 | SWSERIAL_PARITY_MARK,
+    SWSERIAL_6M2,
+    SWSERIAL_7M2,
+    SWSERIAL_8M2,
+    SWSERIAL_5S2 = 0200 | SWSERIAL_PARITY_SPACE,
+    SWSERIAL_6S2,
+    SWSERIAL_7S2,
+    SWSERIAL_8S2,
+};
+
+/// This class is compatible with the corresponding AVR one, however,
+/// the constructor takes no arguments, for compatibility with the
+/// HardwareSerial class.
+/// Instead, the begin() function handles pin assignments and logic inversion.
+/// It also has optional input buffer capacity arguments for byte buffer and ISR bit buffer.
+/// Bitrates up to at least 115200 can be used.
+class SoftwareSerial : public Stream {
+public:
+    SoftwareSerial();
+    /// Ctor to set defaults for pins.
+    /// @param rxPin the GPIO pin used for RX
+    /// @param txPin -1 for onewire protocol, GPIO pin used for twowire TX
+    SoftwareSerial(int8_t rxPin, int8_t txPin = -1, bool invert = false);
+    SoftwareSerial(const SoftwareSerial&) = delete;
+    SoftwareSerial& operator= (const SoftwareSerial&) = delete;
+    virtual ~SoftwareSerial();
+    /// Configure the SoftwareSerial object for use.
+    /// @param baud the TX/RX bitrate
+    /// @param config sets databits, parity, and stop bit count
+    /// @param rxPin -1 or default: either no RX pin, or keeps the rxPin set in the ctor
+    /// @param txPin -1 or default: either no TX pin (onewire), or keeps the txPin set in the ctor
+    /// @param invert true: uses invert line level logic
+    /// @param bufCapacity the capacity for the received bytes buffer
+    /// @param isrBufCapacity 0: derived from bufCapacity. The capacity of the internal asynchronous
+    ///        bit receive buffer, a suggested size is bufCapacity times the sum of
+    ///        start, data, parity and stop bit count.
+    void begin(uint32_t baud, SoftwareSerialConfig config,
+        int8_t rxPin, int8_t txPin, bool invert,
+        int bufCapacity = 64, int isrBufCapacity = 0);
+    void begin(uint32_t baud, SoftwareSerialConfig config,
+        int8_t rxPin, int8_t txPin) {
+        begin(baud, config, rxPin, txPin, m_invert);
+    }
+    void begin(uint32_t baud, SoftwareSerialConfig config,
+        int8_t rxPin) {
+        begin(baud, config, rxPin, m_txPin, m_invert);
+    }
+    void begin(uint32_t baud, SoftwareSerialConfig config = SWSERIAL_8N1) {
+        begin(baud, config, m_rxPin, m_txPin, m_invert);
+    }
+
+    uint32_t baudRate();
+    /// Transmit control pin.
+    void setTransmitEnablePin(int8_t txEnablePin);
+    /// Enable (default) or disable interrupts during tx.
+    void enableIntTx(bool on);
+    /// Enable (default) or disable internal rx GPIO pull-up.
+    void enableRxGPIOPullUp(bool on);
+    /// Enable or disable (default) tx GPIO output mode.
+    void enableTxGPIOOpenDrain(bool on);
+
+    bool overflow();
+
+    int available() override;
+#if defined(ESP8266)
+    int availableForWrite() override {
+#else
+    int availableForWrite() {
+#endif
+        if (!m_txValid) return 0;
+        return 1;
+    }
+    int peek() override;
+    int read() override;
+    /// @returns The verbatim parity bit associated with the last successful read() or peek() call
+    bool readParity()
+    {
+        return m_lastReadParity;
+    }
+    /// @returns The calculated bit for even parity of the parameter byte
+    static bool parityEven(uint8_t byte) {
+        byte ^= byte >> 4;
+        byte &= 0xf;
+        return (0x6996 >> byte) & 1;
+    }
+    /// @returns The calculated bit for odd parity of the parameter byte
+    static bool parityOdd(uint8_t byte) {
+        byte ^= byte >> 4;
+        byte &= 0xf;
+        return (0x9669 >> byte) & 1;
+    }
+    /// The read(buffer, size) functions are non-blocking, the same as readBytes but without timeout
+    int read(uint8_t* buffer, size_t size)
+#if defined(ESP8266)
+        override
+#endif
+        ;
+    /// The read(buffer, size) functions are non-blocking, the same as readBytes but without timeout
+    int read(char* buffer, size_t size) {
+        return read(reinterpret_cast<uint8_t*>(buffer), size);
+    }
+    /// @returns The number of bytes read into buffer, up to size. Times out if the limit set through
+    ///          Stream::setTimeout() is reached.
+    size_t readBytes(uint8_t* buffer, size_t size) override;
+    /// @returns The number of bytes read into buffer, up to size. Times out if the limit set through
+    ///          Stream::setTimeout() is reached.
+    size_t readBytes(char* buffer, size_t size) override {
+        return readBytes(reinterpret_cast<uint8_t*>(buffer), size);
+    }
+    void flush() override;
+    size_t write(uint8_t byte) override;
+    size_t write(uint8_t byte, SoftwareSerialParity parity);
+    size_t write(const uint8_t* buffer, size_t size) override;
+    size_t write(const char* buffer, size_t size) {
+        return write(reinterpret_cast<const uint8_t*>(buffer), size);
+    }
+    size_t write(const uint8_t* buffer, size_t size, SoftwareSerialParity parity);
+    size_t write(const char* buffer, size_t size, SoftwareSerialParity parity) {
+        return write(reinterpret_cast<const uint8_t*>(buffer), size, parity);
+    }
+    operator bool() const {
+        return (-1 == m_rxPin || m_rxValid) && (-1 == m_txPin || m_txValid) && !(-1 == m_rxPin && m_oneWire);
+    }
+
+    /// Disable or enable interrupts on the rx pin.
+    void enableRx(bool on);
+    /// One wire control.
+    void enableTx(bool on);
+
+    // AVR compatibility methods.
+    bool listen() { enableRx(true); return true; }
+    void end();
+    bool isListening() { return m_rxEnabled; }
+    bool stopListening() { enableRx(false); return true; }
+
+    /// Set an event handler for received data.
+    void onReceive(Delegate<void(int available), void*> handler);
+
+    /// Run the internal processing and event engine. Can be iteratively called
+    /// from loop, or otherwise scheduled.
+    void perform_work();
+
+    using Print::write;
+
+private:
+    // It's legal to exceed the deadline, for instance,
+    // by enabling interrupts.
+    void lazyDelay();
+    // Synchronous precise delay
+    void preciseDelay();
+    // If withStopBit is set, either cycle contains a stop bit.
+    // If dutyCycle == 0, the level is not forced to HIGH.
+    // If offCycle == 0, the level remains unchanged from dutyCycle.
+    void writePeriod(
+        uint32_t dutyCycle, uint32_t offCycle, bool withStopBit);
+    constexpr bool isValidGPIOpin(int8_t pin) const;
+    constexpr bool isValidRxGPIOpin(int8_t pin) const;
+    constexpr bool isValidTxGPIOpin(int8_t pin) const;
+    // result is only defined for a valid Rx GPIO pin
+    constexpr bool hasRxGPIOPullUp(int8_t pin) const;
+    // safely set the pin mode for the Rx GPIO pin
+    void setRxGPIOPinMode();
+    // safely set the pin mode for the Tx GPIO pin
+    void setTxGPIOPinMode();
+    /* check m_rxValid that calling is safe */
+    void rxBits();
+    void rxBits(const uint32_t isrTick);
+    static void disableInterrupts();
+    static void restoreInterrupts();
+
+    static void rxBitISR(SoftwareSerial* self);
+    static void rxBitSyncISR(SoftwareSerial* self);
+
+    static inline uint32_t microsToTicks(uint32_t micros) {
+        return micros << 1;
+    }
+    static inline uint32_t ticksToMicros(uint32_t ticks) {
+        return ticks >> 1;
+    }
+
+    // Member variables
+    int8_t m_rxPin = -1;
+    volatile uint32_t* m_rxReg;
+    uint32_t m_rxBitMask;
+    int8_t m_txPin = -1;
+#if !defined(ESP8266)
+    volatile uint32_t* m_txReg;
+#endif
+    uint32_t m_txBitMask;
+    int8_t m_txEnablePin = -1;
+    uint8_t m_dataBits;
+    bool m_oneWire;
+    bool m_rxValid = false;
+    bool m_rxEnabled = false;
+    bool m_txValid = false;
+    bool m_txEnableValid = false;
+    bool m_invert;
+    /// PDU bits include data, parity and stop bits; the start bit is not counted.
+    uint8_t m_pduBits;
+    bool m_intTxEnabled;
+    bool m_rxGPIOPullUpEnabled;
+    bool m_txGPIOOpenDrain;
+    SoftwareSerialParity m_parityMode;
+    uint8_t m_stopBits;
+    bool m_lastReadParity;
+    bool m_overflow = false;
+    uint32_t m_bitTicks;
+    uint8_t m_parityInPos;
+    uint8_t m_parityOutPos;
+    int8_t m_rxLastBit; // 0 thru (m_pduBits - m_stopBits - 1): data/parity bits. -1: start bit. (m_pduBits - 1): stop bit.
+    uint8_t m_rxCurByte = 0;
+    std::unique_ptr<circular_queue<uint8_t> > m_buffer;
+    std::unique_ptr<circular_queue<uint8_t> > m_parityBuffer;
+    uint32_t m_periodStart;
+    uint32_t m_periodDuration;
+#ifndef ESP32
+    static uint32_t m_savedPS;
+#else
+    static portMUX_TYPE m_interruptsMux;
+#endif
+    // the ISR stores the relative bit times in the buffer. The inversion corrected level is used as sign bit (2's complement):
+    // 1 = positive including 0, 0 = negative.
+    std::unique_ptr<circular_queue<uint32_t, SoftwareSerial*> > m_isrBuffer;
+    const Delegate<void(uint32_t&&), SoftwareSerial*> m_isrBufferForEachDel = { [](SoftwareSerial* self, uint32_t&& isrTick) { self->rxBits(isrTick); }, this };
+    std::atomic<bool> m_isrOverflow;
+    uint32_t m_isrLastTick;
+    bool m_rxCurParity = false;
+    Delegate<void(int available), void*> receiveHandler;
+};
+
+#endif // __SoftwareSerial_h

.pio/libdeps/esp32dev/EspSoftwareSerial/src/circular_queue/MultiDelegate.h

@@ -0,0 +1,567 @@
+/*
+MultiDelegate.h - A queue or event multiplexer based on the efficient Delegate
+class
+Copyright (c) 2019-2020 Dirk O. Kaar. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef __MULTIDELEGATE_H
+#define __MULTIDELEGATE_H
+
+#include <iterator>
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+#include <atomic>
+#else
+#include "circular_queue/ghostl.h"
+#endif
+
+#if defined(ESP8266)
+#include <interrupts.h>
+using esp8266::InterruptLock;
+#elif defined(ARDUINO)
+class InterruptLock {
+public:
+    InterruptLock() {
+        noInterrupts();
+    }
+    ~InterruptLock() {
+        interrupts();
+    }
+};
+#else
+#include <mutex>
+#endif
+
+namespace
+{
+
+    template< typename Delegate, typename R, bool ISQUEUE = false, typename... P>
+    struct CallP
+    {
+        static R execute(Delegate& del, P... args)
+        {
+            return del(std::forward<P...>(args...));
+        }
+    };
+
+    template< typename Delegate, bool ISQUEUE, typename... P>
+    struct CallP<Delegate, void, ISQUEUE, P...>
+    {
+        static bool execute(Delegate& del, P... args)
+        {
+            del(std::forward<P...>(args...));
+            return true;
+        }
+    };
+
+    template< typename Delegate, typename R, bool ISQUEUE = false>
+    struct Call
+    {
+        static R execute(Delegate& del)
+        {
+            return del();
+        }
+    };
+
+    template< typename Delegate, bool ISQUEUE>
+    struct Call<Delegate, void, ISQUEUE>
+    {
+        static bool execute(Delegate& del)
+        {
+            del();
+            return true;
+        }
+    };
+
+}
+
+namespace delegate
+{
+    namespace detail
+    {
+
+        template< typename Delegate, typename R, bool ISQUEUE = false, size_t QUEUE_CAPACITY = 32, typename... P>
+        class MultiDelegatePImpl
+        {
+        public:
+            MultiDelegatePImpl() = default;
+            ~MultiDelegatePImpl()
+            {
+                *this = nullptr;
+            }
+
+            MultiDelegatePImpl(const MultiDelegatePImpl&) = delete;
+            MultiDelegatePImpl& operator=(const MultiDelegatePImpl&) = delete;
+
+            MultiDelegatePImpl(MultiDelegatePImpl&& md)
+            {
+                first = md.first;
+                last = md.last;
+                unused = md.unused;
+                nodeCount = md.nodeCount;
+                md.first = nullptr;
+                md.last = nullptr;
+                md.unused = nullptr;
+                md.nodeCount = 0;
+            }
+
+            MultiDelegatePImpl(const Delegate& del)
+            {
+                add(del);
+            }
+
+            MultiDelegatePImpl(Delegate&& del)
+            {
+                add(std::move(del));
+            }
+
+            MultiDelegatePImpl& operator=(MultiDelegatePImpl&& md)
+            {
+                first = md.first;
+                last = md.last;
+                unused = md.unused;
+                nodeCount = md.nodeCount;
+                md.first = nullptr;
+                md.last = nullptr;
+                md.unused = nullptr;
+                md.nodeCount = 0;
+                return *this;
+            }
+
+            MultiDelegatePImpl& operator=(std::nullptr_t)
+            {
+                if (last)
+                    last->mNext = unused;
+                if (first)
+                    unused = first;
+                while (unused)
+                {
+                    auto to_delete = unused;
+                    unused = unused->mNext;
+                    delete(to_delete);
+                }
+                return *this;
+            }
+
+            MultiDelegatePImpl& operator+=(const Delegate& del)
+            {
+                add(del);
+                return *this;
+            }
+
+            MultiDelegatePImpl& operator+=(Delegate&& del)
+            {
+                add(std::move(del));
+                return *this;
+            }
+
+        protected:
+            struct Node_t
+            {
+                ~Node_t()
+                {
+                    mDelegate = nullptr; // special overload in Delegate
+                }
+                Node_t* mNext = nullptr;
+                Delegate mDelegate;
+            };
+
+            Node_t* first = nullptr;
+            Node_t* last = nullptr;
+            Node_t* unused = nullptr;
+            size_t nodeCount = 0;
+
+            // Returns a pointer to an unused Node_t,
+            // or if none are available allocates a new one,
+            // or nullptr if limit is reached
+            Node_t* IRAM_ATTR get_node_unsafe()
+            {
+                Node_t* result = nullptr;
+                // try to get an item from unused items list
+                if (unused)
+                {
+                    result = unused;
+                    unused = unused->mNext;
+                }
+                // if no unused items, and count not too high, allocate a new one
+                else if (nodeCount < QUEUE_CAPACITY)
+                {
+#if defined(ESP8266) || defined(ESP32)            	
+                    result = new (std::nothrow) Node_t;
+#else
+                    result = new Node_t;
+#endif
+                    if (result)
+                        ++nodeCount;
+                }
+                return result;
+            }
+
+            void recycle_node_unsafe(Node_t* node)
+            {
+                node->mDelegate = nullptr; // special overload in Delegate
+                node->mNext = unused;
+                unused = node;
+            }
+
+#ifndef ARDUINO
+            std::mutex mutex_unused;
+#endif
+        public:
+            class iterator : public std::iterator<std::forward_iterator_tag, Delegate>
+            {
+            public:
+                Node_t* current = nullptr;
+                Node_t* prev = nullptr;
+                const Node_t* stop = nullptr;
+
+                iterator(MultiDelegatePImpl& md) : current(md.first), stop(md.last) {}
+                iterator() = default;
+                iterator(const iterator&) = default;
+                iterator& operator=(const iterator&) = default;
+                iterator& operator=(iterator&&) = default;
+                operator bool() const
+                {
+                    return current && stop;
+                }
+                bool operator==(const iterator& rhs) const
+                {
+                    return current == rhs.current;
+                }
+                bool operator!=(const iterator& rhs) const
+                {
+                    return !operator==(rhs);
+                }
+                Delegate& operator*() const
+                {
+                    return current->mDelegate;
+                }
+                Delegate* operator->() const
+                {
+                    return &current->mDelegate;
+                }
+                iterator& operator++() // prefix
+                {
+                    if (current && stop != current)
+                    {
+                        prev = current;
+                        current = current->mNext;
+                    }
+                    else
+                        current = nullptr; // end
+                    return *this;
+                }
+                iterator& operator++(int) // postfix
+                {
+                    iterator tmp(*this);
+                    operator++();
+                    return tmp;
+                }
+            };
+
+            iterator begin()
+            {
+                return iterator(*this);
+            }
+            iterator end() const
+            {
+                return iterator();
+            }
+
+            const Delegate* IRAM_ATTR add(const Delegate& del)
+            {
+                return add(Delegate(del));
+            }
+
+            const Delegate* IRAM_ATTR add(Delegate&& del)
+            {
+                if (!del)
+                    return nullptr;
+
+#ifdef ARDUINO
+                InterruptLock lockAllInterruptsInThisScope;
+#else
+                std::lock_guard<std::mutex> lock(mutex_unused);
+#endif
+
+                Node_t* item = ISQUEUE ? get_node_unsafe() :
+#if defined(ESP8266) || defined(ESP32)            	
+                    new (std::nothrow) Node_t;
+#else
+                    new Node_t;
+#endif
+                if (!item)
+                    return nullptr;
+
+                item->mDelegate = std::move(del);
+                item->mNext = nullptr;
+
+                if (last)
+                    last->mNext = item;
+                else
+                    first = item;
+                last = item;
+
+                return &item->mDelegate;
+            }
+
+            iterator erase(iterator it)
+            {
+                if (!it)
+                    return end();
+#ifdef ARDUINO
+                InterruptLock lockAllInterruptsInThisScope;
+#else
+                std::lock_guard<std::mutex> lock(mutex_unused);
+#endif
+                auto to_recycle = it.current;
+
+                if (last == it.current)
+                    last = it.prev;
+                it.current = it.current->mNext;
+                if (it.prev)
+                {
+                    it.prev->mNext = it.current;
+                }
+                else
+                {
+                    first = it.current;
+                }
+                if (ISQUEUE)
+                    recycle_node_unsafe(to_recycle);
+                else
+                    delete to_recycle;
+                return it;
+            }
+
+            bool erase(const Delegate* const del)
+            {
+                auto it = begin();
+                while (it)
+                {
+                    if (del == &(*it))
+                    {
+                        erase(it);
+                        return true;
+                    }
+                    ++it;
+                }
+                return false;
+            }
+
+            operator bool() const
+            {
+                return first;
+            }
+
+            R operator()(P... args)
+            {
+                auto it = begin();
+                if (!it)
+                    return {};
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return {};
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return {};
+#endif
+
+                R result;
+                do
+                {
+                    result = CallP<Delegate, R, ISQUEUE, P...>::execute(*it, args...);
+                    if (result && ISQUEUE)
+                        it = erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+                return result;
+            }
+        };
+
+        template< typename Delegate, typename R = void, bool ISQUEUE = false, size_t QUEUE_CAPACITY = 32>
+        class MultiDelegateImpl : public MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>
+        {
+        public:
+            using MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>::MultiDelegatePImpl;
+
+            R operator()()
+            {
+                auto it = this->begin();
+                if (!it)
+                    return {};
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return {};
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return {};
+#endif
+
+                R result;
+                do
+                {
+                    result = Call<Delegate, R, ISQUEUE>::execute(*it);
+                    if (result && ISQUEUE)
+                        it = this->erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+                return result;
+            }
+        };
+
+        template< typename Delegate, typename R, bool ISQUEUE, size_t QUEUE_CAPACITY, typename... P> class MultiDelegate;
+
+        template< typename Delegate, typename R, bool ISQUEUE, size_t QUEUE_CAPACITY, typename... P>
+        class MultiDelegate<Delegate, R(P...), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY, P...>
+        {
+        public:
+            using MultiDelegatePImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY, P...>::MultiDelegatePImpl;
+        };
+
+        template< typename Delegate, typename R, bool ISQUEUE, size_t QUEUE_CAPACITY>
+        class MultiDelegate<Delegate, R(), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegateImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>
+        {
+        public:
+            using MultiDelegateImpl<Delegate, R, ISQUEUE, QUEUE_CAPACITY>::MultiDelegateImpl;
+        };
+
+        template< typename Delegate, bool ISQUEUE, size_t QUEUE_CAPACITY, typename... P>
+        class MultiDelegate<Delegate, void(P...), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegatePImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY, P...>
+        {
+        public:
+            using MultiDelegatePImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY, P...>::MultiDelegatePImpl;
+
+            void operator()(P... args)
+            {
+                auto it = this->begin();
+                if (!it)
+                    return;
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return;
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return;
+#endif
+
+                do
+                {
+                    CallP<Delegate, void, ISQUEUE, P...>::execute(*it, args...);
+                    if (ISQUEUE)
+                        it = this->erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+            }
+        };
+
+        template< typename Delegate, bool ISQUEUE, size_t QUEUE_CAPACITY>
+        class MultiDelegate<Delegate, void(), ISQUEUE, QUEUE_CAPACITY> : public MultiDelegateImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY>
+        {
+        public:
+            using MultiDelegateImpl<Delegate, void, ISQUEUE, QUEUE_CAPACITY>::MultiDelegateImpl;
+
+            void operator()()
+            {
+                auto it = this->begin();
+                if (!it)
+                    return;
+
+                static std::atomic<bool> fence(false);
+                // prevent recursive calls
+#if defined(ARDUINO) && !defined(ESP32)
+                if (fence.load()) return;
+                fence.store(true);
+#else
+                if (fence.exchange(true)) return;
+#endif
+
+                do
+                {
+                    Call<Delegate, void, ISQUEUE>::execute(*it);
+                    if (ISQUEUE)
+                        it = this->erase(it);
+                    else
+                        ++it;
+#if defined(ESP8266) || defined(ESP32)
+                    // running callbacks might last too long for watchdog etc.
+                    optimistic_yield(10000);
+#endif
+                } while (it);
+
+                fence.store(false);
+            }
+        };
+
+    }
+
+}
+
+/**
+The MultiDelegate class template can be specialized to either a queue or an event multiplexer.
+It is designed to be used with Delegate, the efficient runtime wrapper for C function ptr and C++ std::function.
+@tparam Delegate specifies the concrete type that MultiDelegate bases the queue or event multiplexer on.
+@tparam ISQUEUE modifies the generated MultiDelegate class in subtle ways. In queue mode (ISQUEUE == true),
+               the value of QUEUE_CAPACITY enforces the maximum number of simultaneous items the queue can contain.
+               This is exploited to minimize the use of new and delete by reusing already allocated items, thus
+               reducing heap fragmentation. In event multiplexer mode (ISQUEUE = false), new and delete are
+               used for allocation of the event handler items.
+               If the result type of the function call operator of Delegate is void, calling a MultiDelegate queue
+               removes each item after calling it; a Multidelegate event multiplexer keeps event handlers until
+               explicitly removed.
+               If the result type of the function call operator of Delegate is non-void, in a MultiDelegate queue
+               the type-conversion to bool of that result determines if the item is immediately removed or kept
+               after each call: if true is returned, the item is removed. A Multidelegate event multiplexer keeps event
+               handlers until they are explicitly removed.
+@tparam QUEUE_CAPACITY is only used if ISQUEUE == true. Then, it sets the maximum capacity that the queue dynamically
+               allocates from the heap. Unused items are not returned to the heap, but are managed by the MultiDelegate
+               instance during its own lifetime for efficiency.
+*/
+template< typename Delegate, bool ISQUEUE = false, size_t QUEUE_CAPACITY = 32>
+class MultiDelegate : public delegate::detail::MultiDelegate<Delegate, typename Delegate::target_type, ISQUEUE, QUEUE_CAPACITY>
+{
+public:
+    using delegate::detail::MultiDelegate<Delegate, typename Delegate::target_type, ISQUEUE, QUEUE_CAPACITY>::MultiDelegate;
+};
+
+#endif // __MULTIDELEGATE_H

.pio/libdeps/esp32dev/EspSoftwareSerial/src/circular_queue/circular_queue.h

@@ -0,0 +1,393 @@
+/*
+circular_queue.h - Implementation of a lock-free circular queue for EspSoftwareSerial.
+Copyright (c) 2019 Dirk O. Kaar. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef __circular_queue_h
+#define __circular_queue_h
+
+#ifdef ARDUINO
+#include <Arduino.h>
+#endif
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+#include <atomic>
+#include <memory>
+#include <algorithm>
+#include "Delegate.h"
+using std::min;
+#else
+#include "ghostl.h"
+#endif
+
+#if !defined(ESP32) && !defined(ESP8266)
+#define IRAM_ATTR
+#endif
+
+/*!
+    @brief	Instance class for a single-producer, single-consumer circular queue / ring buffer (FIFO).
+            This implementation is lock-free between producer and consumer for the available(), peek(),
+            pop(), and push() type functions.
+*/
+template< typename T, typename ForEachArg = void >
+class circular_queue
+{
+public:
+    /*!
+        @brief	Constructs a valid, but zero-capacity dummy queue.
+    */
+    circular_queue() : m_bufSize(1)
+    {
+        m_inPos.store(0);
+        m_outPos.store(0);
+    }
+    /*!
+        @brief  Constructs a queue of the given maximum capacity.
+    */
+    circular_queue(const size_t capacity) : m_bufSize(capacity + 1), m_buffer(new T[m_bufSize])
+    {
+        m_inPos.store(0);
+        m_outPos.store(0);
+    }
+    circular_queue(circular_queue&& cq) :
+        m_bufSize(cq.m_bufSize), m_buffer(cq.m_buffer), m_inPos(cq.m_inPos.load()), m_outPos(cq.m_outPos.load())
+    {}
+    ~circular_queue()
+    {
+        m_buffer.reset();
+    }
+    circular_queue(const circular_queue&) = delete;
+    circular_queue& operator=(circular_queue&& cq)
+    {
+        m_bufSize = cq.m_bufSize;
+        m_buffer = cq.m_buffer;
+        m_inPos.store(cq.m_inPos.load());
+        m_outPos.store(cq.m_outPos.load());
+    }
+    circular_queue& operator=(const circular_queue&) = delete;
+
+    /*!
+        @brief	Get the numer of elements the queue can hold at most.
+    */
+    size_t capacity() const
+    {
+        return m_bufSize - 1;
+    }
+
+    /*!
+        @brief	Resize the queue. The available elements in the queue are preserved.
+                This is not lock-free and concurrent producer or consumer access
+                will lead to corruption.
+        @return True if the new capacity could accommodate the present elements in
+                the queue, otherwise nothing is done and false is returned.
+    */
+    bool capacity(const size_t cap);
+
+    /*!
+        @brief	Discard all data in the queue.
+    */
+    void flush()
+    {
+        m_outPos.store(m_inPos.load());
+    }
+
+    /*!
+        @brief	Get a snapshot number of elements that can be retrieved by pop.
+    */
+    size_t available() const
+    {
+        int avail = static_cast<int>(m_inPos.load() - m_outPos.load());
+        if (avail < 0) avail += m_bufSize;
+        return avail;
+    }
+
+    /*!
+        @brief	Get the remaining free elementes for pushing.
+    */
+    size_t available_for_push() const
+    {
+        int avail = static_cast<int>(m_outPos.load() - m_inPos.load()) - 1;
+        if (avail < 0) avail += m_bufSize;
+        return avail;
+    }
+
+    /*!
+        @brief	Peek at the next element pop will return without removing it from the queue.
+        @return An rvalue copy of the next element that can be popped. If the queue is empty,
+                return an rvalue copy of the element that is pending the next push.
+    */
+    T peek() const
+    {
+        const auto outPos = m_outPos.load(std::memory_order_relaxed);
+        std::atomic_thread_fence(std::memory_order_acquire);
+        return m_buffer[outPos];
+    }
+
+    /*!
+        @brief	Peek at the next pending input value.
+        @return A reference to the next element that can be pushed.
+    */
+    inline T& IRAM_ATTR pushpeek() __attribute__((always_inline))
+    {
+        const auto inPos = m_inPos.load(std::memory_order_relaxed);
+        std::atomic_thread_fence(std::memory_order_acquire);
+        return m_buffer[inPos];
+    }
+
+    /*!
+        @brief	Release the next pending input value, accessible by pushpeek(), into the queue.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    inline bool IRAM_ATTR push() __attribute__((always_inline))
+    {
+        const auto inPos = m_inPos.load(std::memory_order_acquire);
+        const size_t next = (inPos + 1) % m_bufSize;
+        if (next == m_outPos.load(std::memory_order_relaxed)) {
+            return false;
+        }
+    
+        std::atomic_thread_fence(std::memory_order_acquire);
+    
+        m_inPos.store(next, std::memory_order_release);
+        return true;
+    }
+
+    /*!
+        @brief	Move the rvalue parameter into the queue.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    inline bool IRAM_ATTR push(T&& val) __attribute__((always_inline))
+    {
+        const auto inPos = m_inPos.load(std::memory_order_acquire);
+        const size_t next = (inPos + 1) % m_bufSize;
+        if (next == m_outPos.load(std::memory_order_relaxed)) {
+            return false;
+        }
+    
+        std::atomic_thread_fence(std::memory_order_acquire);
+    
+        m_buffer[inPos] = std::move(val);
+    
+        std::atomic_thread_fence(std::memory_order_release);
+    
+        m_inPos.store(next, std::memory_order_release);
+        return true;
+    }
+
+    /*!
+        @brief	Push a copy of the parameter into the queue.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    inline bool IRAM_ATTR push(const T& val) __attribute__((always_inline))
+    {
+        T v(val);
+        return push(std::move(v));
+    }
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    /*!
+        @brief	Push copies of multiple elements from a buffer into the queue,
+                in order, beginning at buffer's head.
+        @return The number of elements actually copied into the queue, counted
+                from the buffer head.
+    */
+    size_t push_n(const T* buffer, size_t size);
+#endif
+
+    /*!
+        @brief	Pop the next available element from the queue.
+        @return An rvalue copy of the popped element, or a default
+                value of type T if the queue is empty.
+    */
+    T pop();
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    /*!
+        @brief	Pop multiple elements in ordered sequence from the queue to a buffer.
+                If buffer is nullptr, simply discards up to size elements from the queue.
+        @return The number of elements actually popped from the queue to
+                buffer.
+    */
+    size_t pop_n(T* buffer, size_t size);
+#endif
+
+    /*!
+        @brief	Iterate over and remove each available element from queue,
+                calling back fun with an rvalue reference of every single element.
+    */
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    void for_each(const Delegate<void(T&&), ForEachArg>& fun);
+#else
+    void for_each(Delegate<void(T&&), ForEachArg> fun);
+#endif
+
+    /*!
+        @brief	In reverse order, iterate over, pop and optionally requeue each available element from the queue,
+                calling back fun with a reference of every single element.
+                Requeuing is dependent on the return boolean of the callback function. If it
+                returns true, the requeue occurs.
+    */
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    bool for_each_rev_requeue(const Delegate<bool(T&), ForEachArg>& fun);
+#else
+    bool for_each_rev_requeue(Delegate<bool(T&), ForEachArg> fun);
+#endif
+
+protected:
+    const T defaultValue = {};
+    size_t m_bufSize;
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+    std::unique_ptr<T[]> m_buffer;
+#else
+    std::unique_ptr<T> m_buffer;
+#endif
+    std::atomic<size_t> m_inPos;
+    std::atomic<size_t> m_outPos;
+};
+
+template< typename T, typename ForEachArg >
+bool circular_queue<T, ForEachArg>::capacity(const size_t cap)
+{
+    if (cap + 1 == m_bufSize) return true;
+    else if (available() > cap) return false;
+    std::unique_ptr<T[] > buffer(new T[cap + 1]);
+    const auto available = pop_n(buffer, cap);
+    m_buffer.reset(buffer);
+    m_bufSize = cap + 1;
+    std::atomic_thread_fence(std::memory_order_release);
+    m_inPos.store(available, std::memory_order_relaxed);
+    m_outPos.store(0, std::memory_order_release);
+    return true;
+}
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+template< typename T, typename ForEachArg >
+size_t circular_queue<T, ForEachArg>::push_n(const T* buffer, size_t size)
+{
+    const auto inPos = m_inPos.load(std::memory_order_acquire);
+    const auto outPos = m_outPos.load(std::memory_order_relaxed);
+
+    size_t blockSize = (outPos > inPos) ? outPos - 1 - inPos : (outPos == 0) ? m_bufSize - 1 - inPos : m_bufSize - inPos;
+    blockSize = min(size, blockSize);
+    if (!blockSize) return 0;
+    int next = (inPos + blockSize) % m_bufSize;
+
+    std::atomic_thread_fence(std::memory_order_acquire);
+
+    auto dest = m_buffer.get() + inPos;
+    std::copy_n(std::make_move_iterator(buffer), blockSize, dest);
+    size = min(size - blockSize, outPos > 1 ? static_cast<size_t>(outPos - next - 1) : 0);
+    next += size;
+    dest = m_buffer.get();
+    std::copy_n(std::make_move_iterator(buffer + blockSize), size, dest);
+
+    std::atomic_thread_fence(std::memory_order_release);
+
+    m_inPos.store(next, std::memory_order_release);
+    return blockSize + size;
+}
+#endif
+
+template< typename T, typename ForEachArg >
+T circular_queue<T, ForEachArg>::pop()
+{
+    const auto outPos = m_outPos.load(std::memory_order_acquire);
+    if (m_inPos.load(std::memory_order_relaxed) == outPos) return defaultValue;
+
+    std::atomic_thread_fence(std::memory_order_acquire);
+
+    auto val = std::move(m_buffer[outPos]);
+
+    std::atomic_thread_fence(std::memory_order_release);
+
+    m_outPos.store((outPos + 1) % m_bufSize, std::memory_order_release);
+    return val;
+}
+
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+template< typename T, typename ForEachArg >
+size_t circular_queue<T, ForEachArg>::pop_n(T* buffer, size_t size) {
+    size_t avail = size = min(size, available());
+    if (!avail) return 0;
+    const auto outPos = m_outPos.load(std::memory_order_acquire);
+    size_t n = min(avail, static_cast<size_t>(m_bufSize - outPos));
+
+    std::atomic_thread_fence(std::memory_order_acquire);
+
+    if (buffer) {
+        buffer = std::copy_n(std::make_move_iterator(m_buffer.get() + outPos), n, buffer);
+        avail -= n;
+        std::copy_n(std::make_move_iterator(m_buffer.get()), avail, buffer);
+    }
+
+    std::atomic_thread_fence(std::memory_order_release);
+
+    m_outPos.store((outPos + size) % m_bufSize, std::memory_order_release);
+    return size;
+}
+#endif
+
+template< typename T, typename ForEachArg >
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+void circular_queue<T, ForEachArg>::for_each(const Delegate<void(T&&), ForEachArg>& fun)
+#else
+void circular_queue<T, ForEachArg>::for_each(Delegate<void(T&&), ForEachArg> fun)
+#endif
+{
+    auto outPos = m_outPos.load(std::memory_order_acquire);
+    const auto inPos = m_inPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    while (outPos != inPos)
+    {
+        fun(std::move(m_buffer[outPos]));
+        std::atomic_thread_fence(std::memory_order_release);
+        outPos = (outPos + 1) % m_bufSize;
+        m_outPos.store(outPos, std::memory_order_release);
+    }
+}
+
+template< typename T, typename ForEachArg >
+#if defined(ESP8266) || defined(ESP32) || !defined(ARDUINO)
+bool circular_queue<T, ForEachArg>::for_each_rev_requeue(const Delegate<bool(T&), ForEachArg>& fun)
+#else
+bool circular_queue<T, ForEachArg>::for_each_rev_requeue(Delegate<bool(T&), ForEachArg> fun)
+#endif
+{
+    auto inPos0 = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_acquire);
+    auto outPos = circular_queue<T, ForEachArg>::m_outPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    if (outPos == inPos0) return false;
+    auto pos = inPos0;
+    auto outPos1 = inPos0;
+    const auto posDecr = circular_queue<T, ForEachArg>::m_bufSize - 1;
+    do {
+        pos = (pos + posDecr) % circular_queue<T, ForEachArg>::m_bufSize;
+        T&& val = std::move(circular_queue<T, ForEachArg>::m_buffer[pos]);
+        if (fun(val))
+        {
+            outPos1 = (outPos1 + posDecr) % circular_queue<T, ForEachArg>::m_bufSize;
+            if (outPos1 != pos) circular_queue<T, ForEachArg>::m_buffer[outPos1] = std::move(val);
+        }
+    } while (pos != outPos);
+    circular_queue<T, ForEachArg>::m_outPos.store(outPos1, std::memory_order_release);
+    return true;
+}
+
+#endif // __circular_queue_h

.pio/libdeps/esp32dev/EspSoftwareSerial/src/circular_queue/circular_queue_mp.h

@@ -0,0 +1,200 @@
+/*
+circular_queue_mp.h - Implementation of a lock-free circular queue for EspSoftwareSerial.
+Copyright (c) 2019 Dirk O. Kaar. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef __circular_queue_mp_h
+#define __circular_queue_mp_h
+
+#include "circular_queue.h"
+
+#ifdef ESP8266
+#include "interrupts.h"
+#else
+#include <mutex>
+#endif
+
+/*!
+    @brief	Instance class for a multi-producer, single-consumer circular queue / ring buffer (FIFO).
+            This implementation is lock-free between producers and consumer for the available(), peek(),
+            pop(), and push() type functions, but is guarded to safely allow only a single producer
+            at any instant.
+*/
+template< typename T, typename ForEachArg = void >
+class circular_queue_mp : protected circular_queue<T, ForEachArg>
+{
+public:
+    circular_queue_mp() = default;
+    circular_queue_mp(const size_t capacity) : circular_queue<T, ForEachArg>(capacity)
+    {}
+    circular_queue_mp(circular_queue<T, ForEachArg>&& cq) : circular_queue<T, ForEachArg>(std::move(cq))
+    {}
+    using circular_queue<T, ForEachArg>::operator=;
+    using circular_queue<T, ForEachArg>::capacity;
+    using circular_queue<T, ForEachArg>::flush;
+    using circular_queue<T, ForEachArg>::available;
+    using circular_queue<T, ForEachArg>::available_for_push;
+    using circular_queue<T, ForEachArg>::peek;
+    using circular_queue<T, ForEachArg>::pop;
+    using circular_queue<T, ForEachArg>::pop_n;
+    using circular_queue<T, ForEachArg>::for_each;
+    using circular_queue<T, ForEachArg>::for_each_rev_requeue;
+
+    /*!
+        @brief	Resize the queue. The available elements in the queue are preserved.
+                This is not lock-free, but safe, concurrent producer or consumer access
+                is guarded.
+        @return True if the new capacity could accommodate the present elements in
+                the queue, otherwise nothing is done and false is returned.
+    */
+    bool capacity(const size_t cap)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::capacity(cap);
+    }
+
+    bool IRAM_ATTR push() = delete;
+
+    /*!
+        @brief	Move the rvalue parameter into the queue, guarded
+                for multiple concurrent producers.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    bool IRAM_ATTR push(T&& val)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::push(std::move(val));
+    }
+
+    /*!
+        @brief	Push a copy of the parameter into the queue, guarded
+                for multiple concurrent producers.
+        @return true if the queue accepted the value, false if the queue
+                was full.
+    */
+    bool IRAM_ATTR push(const T& val)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::push(val);
+    }
+
+    /*!
+        @brief	Push copies of multiple elements from a buffer into the queue,
+                in order, beginning at buffer's head. This is guarded for
+                multiple producers, push_n() is atomic.
+        @return The number of elements actually copied into the queue, counted
+                from the buffer head.
+    */
+    size_t push_n(const T* buffer, size_t size)
+    {
+#ifdef ESP8266
+        esp8266::InterruptLock lock;
+#else
+        std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+        return circular_queue<T, ForEachArg>::push_n(buffer, size);
+    }
+
+    /*!
+        @brief	Pops the next available element from the queue, requeues
+                it immediately.
+        @return A reference to the just requeued element, or the default
+                value of type T if the queue is empty.
+    */
+    T& pop_requeue();
+
+    /*!
+        @brief	Iterate over, pop and optionally requeue each available element from the queue,
+                calling back fun with a reference of every single element.
+                Requeuing is dependent on the return boolean of the callback function. If it
+                returns true, the requeue occurs.
+    */
+    bool for_each_requeue(const Delegate<bool(T&), ForEachArg>& fun);
+
+#ifndef ESP8266
+protected:
+    std::mutex m_pushMtx;
+#endif
+};
+
+template< typename T, typename ForEachArg >
+T& circular_queue_mp<T, ForEachArg>::pop_requeue()
+{
+#ifdef ESP8266
+    esp8266::InterruptLock lock;
+#else
+    std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+    const auto outPos = circular_queue<T, ForEachArg>::m_outPos.load(std::memory_order_acquire);
+    const auto inPos = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    if (inPos == outPos) return circular_queue<T, ForEachArg>::defaultValue;
+    T& val = circular_queue<T, ForEachArg>::m_buffer[inPos] = std::move(circular_queue<T, ForEachArg>::m_buffer[outPos]);
+    const auto bufSize = circular_queue<T, ForEachArg>::m_bufSize;
+    std::atomic_thread_fence(std::memory_order_release);
+	circular_queue<T, ForEachArg>::m_outPos.store((outPos + 1) % bufSize, std::memory_order_relaxed);
+	circular_queue<T, ForEachArg>::m_inPos.store((inPos + 1) % bufSize, std::memory_order_release);
+    return val;
+}
+
+template< typename T, typename ForEachArg >
+bool circular_queue_mp<T, ForEachArg>::for_each_requeue(const Delegate<bool(T&), ForEachArg>& fun)
+{
+    auto inPos0 = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_acquire);
+    auto outPos = circular_queue<T, ForEachArg>::m_outPos.load(std::memory_order_relaxed);
+    std::atomic_thread_fence(std::memory_order_acquire);
+    if (outPos == inPos0) return false;
+    do {
+        T&& val = std::move(circular_queue<T, ForEachArg>::m_buffer[outPos]);
+        if (fun(val))
+        {
+#ifdef ESP8266
+            esp8266::InterruptLock lock;
+#else
+            std::lock_guard<std::mutex> lock(m_pushMtx);
+#endif
+            std::atomic_thread_fence(std::memory_order_release);
+            auto inPos = circular_queue<T, ForEachArg>::m_inPos.load(std::memory_order_relaxed);
+            std::atomic_thread_fence(std::memory_order_acquire);
+			circular_queue<T, ForEachArg>::m_buffer[inPos] = std::move(val);
+            std::atomic_thread_fence(std::memory_order_release);
+			circular_queue<T, ForEachArg>::m_inPos.store((inPos + 1) % circular_queue<T, ForEachArg>::m_bufSize, std::memory_order_release);
+        }
+        else
+        {
+            std::atomic_thread_fence(std::memory_order_release);
+        }
+        outPos = (outPos + 1) % circular_queue<T, ForEachArg>::m_bufSize;
+		circular_queue<T, ForEachArg>::m_outPos.store(outPos, std::memory_order_release);
+    } while (outPos != inPos0);
+    return true;
+}
+
+#endif // __circular_queue_mp_h

.pio/libdeps/esp32dev/EspSoftwareSerial/src/circular_queue/ghostl.h

@@ -0,0 +1,94 @@
+/*
+ghostl.h - Implementation of a bare-bones, mostly no-op, C++ STL shell
+           that allows building some Arduino ESP8266/ESP32
+           libraries on Aruduino AVR.
+Copyright (c) 2019 Dirk O. Kaar. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef __ghostl_h
+#define __ghostl_h
+
+#if defined(ARDUINO_ARCH_SAMD)
+#include <atomic>
+#endif
+
+using size_t = decltype(sizeof(char));
+
+namespace std
+{
+#if !defined(ARDUINO_ARCH_SAMD)
+    typedef enum memory_order {
+        memory_order_relaxed,
+        memory_order_acquire,
+        memory_order_release,
+        memory_order_seq_cst
+    } memory_order;
+    template< typename T > class atomic {
+    private:
+        T value;
+    public:
+        atomic() {}
+        atomic(T desired) { value = desired; }
+        void store(T desired, std::memory_order = std::memory_order_seq_cst) volatile noexcept { value = desired; }
+        T load(std::memory_order = std::memory_order_seq_cst) const volatile noexcept { return value; }
+    };
+    inline void atomic_thread_fence(std::memory_order order) noexcept {}
+    template< typename T >	T&& move(T& t) noexcept { return static_cast<T&&>(t); }
+#endif
+
+    template< typename T, size_t long N > struct array
+    {
+        T _M_elems[N];
+        decltype(sizeof(0)) size() const { return N; }
+        T& operator[](decltype(sizeof(0)) i) { return _M_elems[i]; }
+        const T& operator[](decltype(sizeof(0)) i) const { return _M_elems[i]; }
+    };
+
+    template< typename T > class unique_ptr
+    {
+    public:
+        using pointer = T*;
+        unique_ptr() noexcept : ptr(nullptr) {}
+        unique_ptr(pointer p) : ptr(p) {}
+        pointer operator->() const noexcept { return ptr; }
+        T& operator[](decltype(sizeof(0)) i) const { return ptr[i]; }
+        void reset(pointer p = pointer()) noexcept
+        {
+            delete ptr;
+            ptr = p;
+        }
+        T& operator*() const { return *ptr; }
+    private:
+        pointer ptr;
+    };
+
+    template< typename T > using function = T*;
+    using nullptr_t = decltype(nullptr);
+
+    template<typename T>
+    struct identity {
+        typedef T type;
+    };
+
+    template <typename T>
+    inline T&& forward(typename identity<T>::type& t) noexcept
+    {
+        return static_cast<typename identity<T>::type&&>(t);
+    }
+}
+
+#endif // __ghostl_h

.pio/libdeps/esp32dev/PubSubClient/.gitignore

@@ -0,0 +1,5 @@
+tests/bin
+.pioenvs
+.piolibdeps
+.clang_complete
+.gcc-flags.json

.pio/libdeps/esp32dev/PubSubClient/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "PubSubClient", "version": "2.8.0", "spec": {"owner": "knolleary", "id": 89, "name": "PubSubClient", "requirements": null, "uri": null}}

.pio/libdeps/esp32dev/PubSubClient/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: cpp
+compiler:
+  - g++
+script: cd tests && make && make test
+os:
+  - linux

.pio/libdeps/esp32dev/PubSubClient/CHANGES.txt

@@ -0,0 +1,85 @@
+2.8
+   * Add setBufferSize() to override MQTT_MAX_PACKET_SIZE
+   * Add setKeepAlive() to override MQTT_KEEPALIVE
+   * Add setSocketTimeout() to overide MQTT_SOCKET_TIMEOUT
+   * Added check to prevent subscribe/unsubscribe to empty topics
+   * Declare wifi mode prior to connect in ESP example
+   * Use `strnlen` to avoid overruns
+   * Support pre-connected Client objects
+
+2.7
+   * Fix remaining-length handling to prevent buffer overrun
+   * Add large-payload API - beginPublish/write/publish/endPublish
+   * Add yield call to improve reliability on ESP
+   * Add Clean Session flag to connect options
+   * Add ESP32 support for functional callback signature
+   * Various other fixes
+
+2.4
+   * Add MQTT_SOCKET_TIMEOUT to prevent it blocking indefinitely
+     whilst waiting for inbound data
+   * Fixed return code when publishing >256 bytes
+
+2.3
+   * Add publish(topic,payload,retained) function
+
+2.2
+   * Change code layout to match Arduino Library reqs
+
+2.1
+   * Add MAX_TRANSFER_SIZE def to chunk messages if needed
+   * Reject topic/payloads that exceed MQTT_MAX_PACKET_SIZE
+
+2.0
+   * Add (and default to) MQTT 3.1.1 support
+   * Fix PROGMEM handling for Intel Galileo/ESP8266
+   * Add overloaded constructors for convenience
+   * Add chainable setters for server/callback/client/stream
+   * Add state function to return connack return code
+
+1.9
+   * Do not split MQTT packets over multiple calls to _client->write()
+   * API change: All constructors now require an instance of Client
+      to be passed in.
+   * Fixed example to match 1.8 api changes - dpslwk
+   * Added username/password support - WilHall
+   * Added publish_P - publishes messages from PROGMEM - jobytaffey
+
+1.8
+    * KeepAlive interval is configurable in PubSubClient.h
+    * Maximum packet size is configurable in PubSubClient.h
+    * API change: Return boolean rather than int from various functions
+    * API change: Length parameter in message callback changed
+       from int to unsigned int
+    * Various internal tidy-ups around types
+1.7
+    * Improved keepalive handling
+    * Updated to the Arduino-1.0 API
+1.6
+    * Added the ability to publish a retained message
+
+1.5
+    * Added default constructor
+    * Fixed compile error when used with arduino-0021 or later
+
+1.4
+    * Fixed connection lost handling
+
+1.3
+    * Fixed packet reading bug in PubSubClient.readPacket
+
+1.2
+    * Fixed compile error when used with arduino-0016 or later
+
+
+1.1
+    * Reduced size of library
+    * Added support for Will messages
+    * Clarified licensing - see LICENSE.txt
+
+
+1.0
+    * Only Quality of Service (QOS) 0 messaging is supported
+    * The maximum message size, including header, is 128 bytes
+    * The keepalive interval is set to 30 seconds
+    * No support for Will messages

.pio/libdeps/esp32dev/PubSubClient/LICENSE.txt

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

.pio/libdeps/esp32dev/PubSubClient/README.md

@@ -0,0 +1,50 @@
+# Arduino Client for MQTT
+
+This library provides a client for doing simple publish/subscribe messaging with
+a server that supports MQTT.
+
+## Examples
+
+The library comes with a number of example sketches. See File > Examples > PubSubClient
+within the Arduino application.
+
+Full API documentation is available here: https://pubsubclient.knolleary.net
+
+## Limitations
+
+ - It can only publish QoS 0 messages. It can subscribe at QoS 0 or QoS 1.
+ - The maximum message size, including header, is **256 bytes** by default. This
+   is configurable via `MQTT_MAX_PACKET_SIZE` in `PubSubClient.h` or can be changed
+   by calling `PubSubClient::setBufferSize(size)`.
+ - The keepalive interval is set to 15 seconds by default. This is configurable
+   via `MQTT_KEEPALIVE` in `PubSubClient.h` or can be changed by calling
+   `PubSubClient::setKeepAlive(keepAlive)`.
+ - The client uses MQTT 3.1.1 by default. It can be changed to use MQTT 3.1 by
+   changing value of `MQTT_VERSION` in `PubSubClient.h`.
+
+
+## Compatible Hardware
+
+The library uses the Arduino Ethernet Client api for interacting with the
+underlying network hardware. This means it Just Works with a growing number of
+boards and shields, including:
+
+ - Arduino Ethernet
+ - Arduino Ethernet Shield
+ - Arduino YUN – use the included `YunClient` in place of `EthernetClient`, and
+   be sure to do a `Bridge.begin()` first
+ - Arduino WiFi Shield - if you want to send packets > 90 bytes with this shield,
+   enable the `MQTT_MAX_TRANSFER_SIZE` define in `PubSubClient.h`.
+ - Sparkfun WiFly Shield – [library](https://github.com/dpslwk/WiFly)
+ - TI CC3000 WiFi - [library](https://github.com/sparkfun/SFE_CC3000_Library)
+ - Intel Galileo/Edison
+ - ESP8266
+ - ESP32
+
+The library cannot currently be used with hardware based on the ENC28J60 chip –
+such as the Nanode or the Nuelectronics Ethernet Shield. For those, there is an
+[alternative library](https://github.com/njh/NanodeMQTT) available.
+
+## License
+
+This code is released under the MIT License.

.pio/libdeps/esp32dev/PubSubClient/examples/mqtt_auth/mqtt_auth.ino

@@ -0,0 +1,43 @@
+/*
+ Basic MQTT example with Authentication
+
+  - connects to an MQTT server, providing username
+    and password
+  - publishes "hello world" to the topic "outTopic"
+  - subscribes to the topic "inTopic"
+*/
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <PubSubClient.h>
+
+// Update these with values suitable for your network.
+byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
+IPAddress ip(172, 16, 0, 100);
+IPAddress server(172, 16, 0, 2);
+
+void callback(char* topic, byte* payload, unsigned int length) {
+  // handle message arrived
+}
+
+EthernetClient ethClient;
+PubSubClient client(server, 1883, callback, ethClient);
+
+void setup()
+{
+  Ethernet.begin(mac, ip);
+  // Note - the default maximum packet size is 128 bytes. If the
+  // combined length of clientId, username and password exceed this use the
+  // following to increase the buffer size:
+  // client.setBufferSize(255);
+  
+  if (client.connect("arduinoClient", "testuser", "testpass")) {
+    client.publish("outTopic","hello world");
+    client.subscribe("inTopic");
+  }
+}
+
+void loop()
+{
+  client.loop();
+}

.pio/libdeps/esp32dev/PubSubClient/examples/mqtt_basic/mqtt_basic.ino

@@ -0,0 +1,77 @@
+/*
+ Basic MQTT example
+
+ This sketch demonstrates the basic capabilities of the library.
+ It connects to an MQTT server then:
+  - publishes "hello world" to the topic "outTopic"
+  - subscribes to the topic "inTopic", printing out any messages
+    it receives. NB - it assumes the received payloads are strings not binary
+
+ It will reconnect to the server if the connection is lost using a blocking
+ reconnect function. See the 'mqtt_reconnect_nonblocking' example for how to
+ achieve the same result without blocking the main loop.
+ 
+*/
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <PubSubClient.h>
+
+// Update these with values suitable for your network.
+byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
+IPAddress ip(172, 16, 0, 100);
+IPAddress server(172, 16, 0, 2);
+
+void callback(char* topic, byte* payload, unsigned int length) {
+  Serial.print("Message arrived [");
+  Serial.print(topic);
+  Serial.print("] ");
+  for (int i=0;i<length;i++) {
+    Serial.print((char)payload[i]);
+  }
+  Serial.println();
+}
+
+EthernetClient ethClient;
+PubSubClient client(ethClient);
+
+void reconnect() {
+  // Loop until we're reconnected
+  while (!client.connected()) {
+    Serial.print("Attempting MQTT connection...");
+    // Attempt to connect
+    if (client.connect("arduinoClient")) {
+      Serial.println("connected");
+      // Once connected, publish an announcement...
+      client.publish("outTopic","hello world");
+      // ... and resubscribe
+      client.subscribe("inTopic");
+    } else {
+      Serial.print("failed, rc=");
+      Serial.print(client.state());
+      Serial.println(" try again in 5 seconds");
+      // Wait 5 seconds before retrying
+      delay(5000);
+    }
+  }
+}
+
+void setup()
+{
+  Serial.begin(57600);
+
+  client.setServer(server, 1883);
+  client.setCallback(callback);
+
+  Ethernet.begin(mac, ip);
+  // Allow the hardware to sort itself out
+  delay(1500);
+}
+
+void loop()
+{
+  if (!client.connected()) {
+    reconnect();
+  }
+  client.loop();
+}

.pio/libdeps/esp32dev/PubSubClient/examples/mqtt_esp8266/mqtt_esp8266.ino

@@ -0,0 +1,129 @@
+/*
+ Basic ESP8266 MQTT example
+ This sketch demonstrates the capabilities of the pubsub library in combination
+ with the ESP8266 board/library.
+ It connects to an MQTT server then:
+  - publishes "hello world" to the topic "outTopic" every two seconds
+  - subscribes to the topic "inTopic", printing out any messages
+    it receives. NB - it assumes the received payloads are strings not binary
+  - If the first character of the topic "inTopic" is an 1, switch ON the ESP Led,
+    else switch it off
+ It will reconnect to the server if the connection is lost using a blocking
+ reconnect function. See the 'mqtt_reconnect_nonblocking' example for how to
+ achieve the same result without blocking the main loop.
+ To install the ESP8266 board, (using Arduino 1.6.4+):
+  - Add the following 3rd party board manager under "File -> Preferences -> Additional Boards Manager URLs":
+       http://arduino.esp8266.com/stable/package_esp8266com_index.json
+  - Open the "Tools -> Board -> Board Manager" and click install for the ESP8266"
+  - Select your ESP8266 in "Tools -> Board"
+*/
+
+#include <ESP8266WiFi.h>
+#include <PubSubClient.h>
+
+// Update these with values suitable for your network.
+
+const char* ssid = "........";
+const char* password = "........";
+const char* mqtt_server = "broker.mqtt-dashboard.com";
+
+WiFiClient espClient;
+PubSubClient client(espClient);
+unsigned long lastMsg = 0;
+#define MSG_BUFFER_SIZE	(50)
+char msg[MSG_BUFFER_SIZE];
+int value = 0;
+
+void setup_wifi() {
+
+  delay(10);
+  // We start by connecting to a WiFi network
+  Serial.println();
+  Serial.print("Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  randomSeed(micros());
+
+  Serial.println("");
+  Serial.println("WiFi connected");
+  Serial.println("IP address: ");
+  Serial.println(WiFi.localIP());
+}
+
+void callback(char* topic, byte* payload, unsigned int length) {
+  Serial.print("Message arrived [");
+  Serial.print(topic);
+  Serial.print("] ");
+  for (int i = 0; i < length; i++) {
+    Serial.print((char)payload[i]);
+  }
+  Serial.println();
+
+  // Switch on the LED if an 1 was received as first character
+  if ((char)payload[0] == '1') {
+    digitalWrite(BUILTIN_LED, LOW);   // Turn the LED on (Note that LOW is the voltage level
+    // but actually the LED is on; this is because
+    // it is active low on the ESP-01)
+  } else {
+    digitalWrite(BUILTIN_LED, HIGH);  // Turn the LED off by making the voltage HIGH
+  }
+
+}
+
+void reconnect() {
+  // Loop until we're reconnected
+  while (!client.connected()) {
+    Serial.print("Attempting MQTT connection...");
+    // Create a random client ID
+    String clientId = "ESP8266Client-";
+    clientId += String(random(0xffff), HEX);
+    // Attempt to connect
+    if (client.connect(clientId.c_str())) {
+      Serial.println("connected");
+      // Once connected, publish an announcement...
+      client.publish("outTopic", "hello world");
+      // ... and resubscribe
+      client.subscribe("inTopic");
+    } else {
+      Serial.print("failed, rc=");
+      Serial.print(client.state());
+      Serial.println(" try again in 5 seconds");
+      // Wait 5 seconds before retrying
+      delay(5000);
+    }
+  }
+}
+
+void setup() {
+  pinMode(BUILTIN_LED, OUTPUT);     // Initialize the BUILTIN_LED pin as an output
+  Serial.begin(115200);
+  setup_wifi();
+  client.setServer(mqtt_server, 1883);
+  client.setCallback(callback);
+}
+
+void loop() {
+
+  if (!client.connected()) {
+    reconnect();
+  }
+  client.loop();
+
+  unsigned long now = millis();
+  if (now - lastMsg > 2000) {
+    lastMsg = now;
+    ++value;
+    snprintf (msg, MSG_BUFFER_SIZE, "hello world #%ld", value);
+    Serial.print("Publish message: ");
+    Serial.println(msg);
+    client.publish("outTopic", msg);
+  }
+}

.pio/libdeps/esp32dev/PubSubClient/examples/mqtt_large_message/mqtt_large_message.ino

@@ -0,0 +1,179 @@
+/*
+ Long message ESP8266 MQTT example
+
+ This sketch demonstrates sending arbitrarily large messages in combination
+ with the ESP8266 board/library.
+
+ It connects to an MQTT server then:
+  - publishes "hello world" to the topic "outTopic"
+  - subscribes to the topic "greenBottles/#", printing out any messages
+    it receives. NB - it assumes the received payloads are strings not binary
+  - If the sub-topic is a number, it publishes a "greenBottles/lyrics" message
+    with a payload consisting of the lyrics to "10 green bottles", replacing
+    10 with the number given in the sub-topic.
+
+ It will reconnect to the server if the connection is lost using a blocking
+ reconnect function. See the 'mqtt_reconnect_nonblocking' example for how to
+ achieve the same result without blocking the main loop.
+
+ To install the ESP8266 board, (using Arduino 1.6.4+):
+  - Add the following 3rd party board manager under "File -> Preferences -> Additional Boards Manager URLs":
+       http://arduino.esp8266.com/stable/package_esp8266com_index.json
+  - Open the "Tools -> Board -> Board Manager" and click install for the ESP8266"
+  - Select your ESP8266 in "Tools -> Board"
+
+*/
+
+#include <ESP8266WiFi.h>
+#include <PubSubClient.h>
+
+// Update these with values suitable for your network.
+
+const char* ssid = "........";
+const char* password = "........";
+const char* mqtt_server = "broker.mqtt-dashboard.com";
+
+WiFiClient espClient;
+PubSubClient client(espClient);
+long lastMsg = 0;
+char msg[50];
+int value = 0;
+
+void setup_wifi() {
+
+  delay(10);
+  // We start by connecting to a WiFi network
+  Serial.println();
+  Serial.print("Connecting to ");
+  Serial.println(ssid);
+
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  randomSeed(micros());
+
+  Serial.println("");
+  Serial.println("WiFi connected");
+  Serial.println("IP address: ");
+  Serial.println(WiFi.localIP());
+}
+
+void callback(char* topic, byte* payload, unsigned int length) {
+  Serial.print("Message arrived [");
+  Serial.print(topic);
+  Serial.print("] ");
+  for (int i = 0; i < length; i++) {
+    Serial.print((char)payload[i]);
+  }
+  Serial.println();
+
+  // Find out how many bottles we should generate lyrics for
+  String topicStr(topic);
+  int bottleCount = 0; // assume no bottles unless we correctly parse a value from the topic
+  if (topicStr.indexOf('/') >= 0) {
+    // The topic includes a '/', we'll try to read the number of bottles from just after that
+    topicStr.remove(0, topicStr.indexOf('/')+1);
+    // Now see if there's a number of bottles after the '/'
+    bottleCount = topicStr.toInt();
+  }
+
+  if (bottleCount > 0) {
+    // Work out how big our resulting message will be
+    int msgLen = 0;
+    for (int i = bottleCount; i > 0; i--) {
+      String numBottles(i);
+      msgLen += 2*numBottles.length();
+      if (i == 1) {
+        msgLen += 2*String(" green bottle, standing on the wall\n").length();
+      } else {
+        msgLen += 2*String(" green bottles, standing on the wall\n").length();
+      }
+      msgLen += String("And if one green bottle should accidentally fall\nThere'll be ").length();
+      switch (i) {
+      case 1:
+        msgLen += String("no green bottles, standing on the wall\n\n").length();
+        break;
+      case 2:
+        msgLen += String("1 green bottle, standing on the wall\n\n").length();
+        break;
+      default:
+        numBottles = i-1;
+        msgLen += numBottles.length();
+        msgLen += String(" green bottles, standing on the wall\n\n").length();
+        break;
+      };
+    }
+  
+    // Now we can start to publish the message
+    client.beginPublish("greenBottles/lyrics", msgLen, false);
+    for (int i = bottleCount; i > 0; i--) {
+      for (int j = 0; j < 2; j++) {
+        client.print(i);
+        if (i == 1) {
+          client.print(" green bottle, standing on the wall\n");
+        } else {
+          client.print(" green bottles, standing on the wall\n");
+        }
+      }
+      client.print("And if one green bottle should accidentally fall\nThere'll be ");
+      switch (i) {
+      case 1:
+        client.print("no green bottles, standing on the wall\n\n");
+        break;
+      case 2:
+        client.print("1 green bottle, standing on the wall\n\n");
+        break;
+      default:
+        client.print(i-1);
+        client.print(" green bottles, standing on the wall\n\n");
+        break;
+      };
+    }
+    // Now we're done!
+    client.endPublish();
+  }
+}
+
+void reconnect() {
+  // Loop until we're reconnected
+  while (!client.connected()) {
+    Serial.print("Attempting MQTT connection...");
+    // Create a random client ID
+    String clientId = "ESP8266Client-";
+    clientId += String(random(0xffff), HEX);
+    // Attempt to connect
+    if (client.connect(clientId.c_str())) {
+      Serial.println("connected");
+      // Once connected, publish an announcement...
+      client.publish("outTopic", "hello world");
+      // ... and resubscribe
+      client.subscribe("greenBottles/#");
+    } else {
+      Serial.print("failed, rc=");
+      Serial.print(client.state());
+      Serial.println(" try again in 5 seconds");
+      // Wait 5 seconds before retrying
+      delay(5000);
+    }
+  }
+}
+
+void setup() {
+  pinMode(BUILTIN_LED, OUTPUT);     // Initialize the BUILTIN_LED pin as an output
+  Serial.begin(115200);
+  setup_wifi();
+  client.setServer(mqtt_server, 1883);
+  client.setCallback(callback);
+}
+
+void loop() {
+
+  if (!client.connected()) {
+    reconnect();
+  }
+  client.loop();
+}

.pio/libdeps/esp32dev/PubSubClient/examples/mqtt_publish_in_callback/mqtt_publish_in_callback.ino

@@ -0,0 +1,60 @@
+/*
+ Publishing in the callback
+
+  - connects to an MQTT server
+  - subscribes to the topic "inTopic"
+  - when a message is received, republishes it to "outTopic"
+
+  This example shows how to publish messages within the
+  callback function. The callback function header needs to
+  be declared before the PubSubClient constructor and the
+  actual callback defined afterwards.
+  This ensures the client reference in the callback function
+  is valid.
+
+*/
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <PubSubClient.h>
+
+// Update these with values suitable for your network.
+byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
+IPAddress ip(172, 16, 0, 100);
+IPAddress server(172, 16, 0, 2);
+
+// Callback function header
+void callback(char* topic, byte* payload, unsigned int length);
+
+EthernetClient ethClient;
+PubSubClient client(server, 1883, callback, ethClient);
+
+// Callback function
+void callback(char* topic, byte* payload, unsigned int length) {
+  // In order to republish this payload, a copy must be made
+  // as the orignal payload buffer will be overwritten whilst
+  // constructing the PUBLISH packet.
+
+  // Allocate the correct amount of memory for the payload copy
+  byte* p = (byte*)malloc(length);
+  // Copy the payload to the new buffer
+  memcpy(p,payload,length);
+  client.publish("outTopic", p, length);
+  // Free the memory
+  free(p);
+}
+
+void setup()
+{
+
+  Ethernet.begin(mac, ip);
+  if (client.connect("arduinoClient")) {
+    client.publish("outTopic","hello world");
+    client.subscribe("inTopic");
+  }
+}
+
+void loop()
+{
+  client.loop();
+}

.pio/libdeps/esp32dev/PubSubClient/examples/mqtt_reconnect_nonblocking/mqtt_reconnect_nonblocking.ino

@@ -0,0 +1,67 @@
+/*
+ Reconnecting MQTT example - non-blocking
+
+ This sketch demonstrates how to keep the client connected
+ using a non-blocking reconnect function. If the client loses
+ its connection, it attempts to reconnect every 5 seconds
+ without blocking the main loop.
+
+*/
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <PubSubClient.h>
+
+// Update these with values suitable for your hardware/network.
+byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
+IPAddress ip(172, 16, 0, 100);
+IPAddress server(172, 16, 0, 2);
+
+void callback(char* topic, byte* payload, unsigned int length) {
+  // handle message arrived
+}
+
+EthernetClient ethClient;
+PubSubClient client(ethClient);
+
+long lastReconnectAttempt = 0;
+
+boolean reconnect() {
+  if (client.connect("arduinoClient")) {
+    // Once connected, publish an announcement...
+    client.publish("outTopic","hello world");
+    // ... and resubscribe
+    client.subscribe("inTopic");
+  }
+  return client.connected();
+}
+
+void setup()
+{
+  client.setServer(server, 1883);
+  client.setCallback(callback);
+
+  Ethernet.begin(mac, ip);
+  delay(1500);
+  lastReconnectAttempt = 0;
+}
+
+
+void loop()
+{
+  if (!client.connected()) {
+    long now = millis();
+    if (now - lastReconnectAttempt > 5000) {
+      lastReconnectAttempt = now;
+      // Attempt to reconnect
+      if (reconnect()) {
+        lastReconnectAttempt = 0;
+      }
+    }
+  } else {
+    // Client connected
+
+    client.loop();
+  }
+
+}

.pio/libdeps/esp32dev/PubSubClient/examples/mqtt_stream/mqtt_stream.ino

@@ -0,0 +1,57 @@
+/*
+ Example of using a Stream object to store the message payload
+
+ Uses SRAM library: https://github.com/ennui2342/arduino-sram
+ but could use any Stream based class such as SD
+
+  - connects to an MQTT server
+  - publishes "hello world" to the topic "outTopic"
+  - subscribes to the topic "inTopic"
+*/
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <PubSubClient.h>
+#include <SRAM.h>
+
+// Update these with values suitable for your network.
+byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
+IPAddress ip(172, 16, 0, 100);
+IPAddress server(172, 16, 0, 2);
+
+SRAM sram(4, SRAM_1024);
+
+void callback(char* topic, byte* payload, unsigned int length) {
+  sram.seek(1);
+
+  // do something with the message
+  for(uint8_t i=0; i<length; i++) {
+    Serial.write(sram.read());
+  }
+  Serial.println();
+
+  // Reset position for the next message to be stored
+  sram.seek(1);
+}
+
+EthernetClient ethClient;
+PubSubClient client(server, 1883, callback, ethClient, sram);
+
+void setup()
+{
+  Ethernet.begin(mac, ip);
+  if (client.connect("arduinoClient")) {
+    client.publish("outTopic","hello world");
+    client.subscribe("inTopic");
+  }
+
+  sram.begin();
+  sram.seek(1);
+
+  Serial.begin(9600);
+}
+
+void loop()
+{
+  client.loop();
+}

.pio/libdeps/esp32dev/PubSubClient/keywords.txt

@@ -0,0 +1,36 @@
+#######################################
+# Syntax Coloring Map For PubSubClient
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+PubSubClient	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+connect 	KEYWORD2
+disconnect 	KEYWORD2
+publish 	KEYWORD2
+publish_P 	KEYWORD2
+beginPublish 	KEYWORD2
+endPublish 	KEYWORD2
+write	 	KEYWORD2
+subscribe 	KEYWORD2
+unsubscribe 	KEYWORD2
+loop 	KEYWORD2
+connected 	KEYWORD2
+setServer	KEYWORD2
+setCallback	KEYWORD2
+setClient	KEYWORD2
+setStream	KEYWORD2
+setKeepAlive 	KEYWORD2
+setBufferSize 	KEYWORD2
+setSocketTimeout 	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

.pio/libdeps/esp32dev/PubSubClient/library.json

@@ -0,0 +1,18 @@
+{
+    "name": "PubSubClient",
+    "keywords": "ethernet, mqtt, m2m, iot",
+    "description": "A client library for MQTT messaging. MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages. It supports the latest MQTT 3.1.1 protocol and can be configured to use the older MQTT 3.1 if needed. It supports all Arduino Ethernet Client compatible hardware, including the Intel Galileo/Edison, ESP8266 and TI CC3000.",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/knolleary/pubsubclient.git"
+    },
+    "version": "2.8",
+    "exclude": "tests",
+    "examples": "examples/*/*.ino",
+    "frameworks": "arduino",
+    "platforms": [
+        "atmelavr",
+        "espressif8266",
+        "espressif32"
+    ]
+}

.pio/libdeps/esp32dev/PubSubClient/library.properties

@@ -0,0 +1,9 @@
+name=PubSubClient
+version=2.8
+author=Nick O'Leary <nick.oleary@gmail.com>
+maintainer=Nick O'Leary <nick.oleary@gmail.com>
+sentence=A client library for MQTT messaging.
+paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages. It supports the latest MQTT 3.1.1 protocol and can be configured to use the older MQTT 3.1 if needed. It supports all Arduino Ethernet Client compatible hardware, including the Intel Galileo/Edison, ESP8266 and TI CC3000.
+category=Communication
+url=http://pubsubclient.knolleary.net
+architectures=*

.pio/libdeps/esp32dev/PubSubClient/src/PubSubClient.cpp

@@ -0,0 +1,769 @@
+/*
+
+  PubSubClient.cpp - A simple client for MQTT.
+  Nick O'Leary
+  http://knolleary.net
+*/
+
+#include "PubSubClient.h"
+#include "Arduino.h"
+
+PubSubClient::PubSubClient() {
+    this->_state = MQTT_DISCONNECTED;
+    this->_client = NULL;
+    this->stream = NULL;
+    setCallback(NULL);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr, port);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr,port);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr, port);
+    setCallback(callback);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(IPAddress addr, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(addr,port);
+    setCallback(callback);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip, port);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip,port);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip, port);
+    setCallback(callback);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(uint8_t *ip, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(ip,port);
+    setCallback(callback);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::PubSubClient(const char* domain, uint16_t port, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(const char* domain, uint16_t port, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setCallback(callback);
+    setClient(client);
+    this->stream = NULL;
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+PubSubClient::PubSubClient(const char* domain, uint16_t port, MQTT_CALLBACK_SIGNATURE, Client& client, Stream& stream) {
+    this->_state = MQTT_DISCONNECTED;
+    setServer(domain,port);
+    setCallback(callback);
+    setClient(client);
+    setStream(stream);
+    this->bufferSize = 0;
+    setBufferSize(MQTT_MAX_PACKET_SIZE);
+    setKeepAlive(MQTT_KEEPALIVE);
+    setSocketTimeout(MQTT_SOCKET_TIMEOUT);
+}
+
+PubSubClient::~PubSubClient() {
+  free(this->buffer);
+}
+
+boolean PubSubClient::connect(const char *id) {
+    return connect(id,NULL,NULL,0,0,0,0,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char *user, const char *pass) {
+    return connect(id,user,pass,0,0,0,0,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage) {
+    return connect(id,NULL,NULL,willTopic,willQos,willRetain,willMessage,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char *user, const char *pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage) {
+    return connect(id,user,pass,willTopic,willQos,willRetain,willMessage,1);
+}
+
+boolean PubSubClient::connect(const char *id, const char *user, const char *pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage, boolean cleanSession) {
+    if (!connected()) {
+        int result = 0;
+
+
+        if(_client->connected()) {
+            result = 1;
+        } else {
+            if (domain != NULL) {
+                result = _client->connect(this->domain, this->port);
+            } else {
+                result = _client->connect(this->ip, this->port);
+            }
+        }
+
+        if (result == 1) {
+            nextMsgId = 1;
+            // Leave room in the buffer for header and variable length field
+            uint16_t length = MQTT_MAX_HEADER_SIZE;
+            unsigned int j;
+
+#if MQTT_VERSION == MQTT_VERSION_3_1
+            uint8_t d[9] = {0x00,0x06,'M','Q','I','s','d','p', MQTT_VERSION};
+#define MQTT_HEADER_VERSION_LENGTH 9
+#elif MQTT_VERSION == MQTT_VERSION_3_1_1
+            uint8_t d[7] = {0x00,0x04,'M','Q','T','T',MQTT_VERSION};
+#define MQTT_HEADER_VERSION_LENGTH 7
+#endif
+            for (j = 0;j<MQTT_HEADER_VERSION_LENGTH;j++) {
+                this->buffer[length++] = d[j];
+            }
+
+            uint8_t v;
+            if (willTopic) {
+                v = 0x04|(willQos<<3)|(willRetain<<5);
+            } else {
+                v = 0x00;
+            }
+            if (cleanSession) {
+                v = v|0x02;
+            }
+
+            if(user != NULL) {
+                v = v|0x80;
+
+                if(pass != NULL) {
+                    v = v|(0x80>>1);
+                }
+            }
+            this->buffer[length++] = v;
+
+            this->buffer[length++] = ((this->keepAlive) >> 8);
+            this->buffer[length++] = ((this->keepAlive) & 0xFF);
+
+            CHECK_STRING_LENGTH(length,id)
+            length = writeString(id,this->buffer,length);
+            if (willTopic) {
+                CHECK_STRING_LENGTH(length,willTopic)
+                length = writeString(willTopic,this->buffer,length);
+                CHECK_STRING_LENGTH(length,willMessage)
+                length = writeString(willMessage,this->buffer,length);
+            }
+
+            if(user != NULL) {
+                CHECK_STRING_LENGTH(length,user)
+                length = writeString(user,this->buffer,length);
+                if(pass != NULL) {
+                    CHECK_STRING_LENGTH(length,pass)
+                    length = writeString(pass,this->buffer,length);
+                }
+            }
+
+            write(MQTTCONNECT,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+
+            lastInActivity = lastOutActivity = millis();
+
+            while (!_client->available()) {
+                unsigned long t = millis();
+                if (t-lastInActivity >= ((int32_t) this->socketTimeout*1000UL)) {
+                    _state = MQTT_CONNECTION_TIMEOUT;
+                    _client->stop();
+                    return false;
+                }
+            }
+            uint8_t llen;
+            uint32_t len = readPacket(&llen);
+
+            if (len == 4) {
+                if (buffer[3] == 0) {
+                    lastInActivity = millis();
+                    pingOutstanding = false;
+                    _state = MQTT_CONNECTED;
+                    return true;
+                } else {
+                    _state = buffer[3];
+                }
+            }
+            _client->stop();
+        } else {
+            _state = MQTT_CONNECT_FAILED;
+        }
+        return false;
+    }
+    return true;
+}
+
+// reads a byte into result
+boolean PubSubClient::readByte(uint8_t * result) {
+   uint32_t previousMillis = millis();
+   while(!_client->available()) {
+     yield();
+     uint32_t currentMillis = millis();
+     if(currentMillis - previousMillis >= ((int32_t) this->socketTimeout * 1000)){
+       return false;
+     }
+   }
+   *result = _client->read();
+   return true;
+}
+
+// reads a byte into result[*index] and increments index
+boolean PubSubClient::readByte(uint8_t * result, uint16_t * index){
+  uint16_t current_index = *index;
+  uint8_t * write_address = &(result[current_index]);
+  if(readByte(write_address)){
+    *index = current_index + 1;
+    return true;
+  }
+  return false;
+}
+
+uint32_t PubSubClient::readPacket(uint8_t* lengthLength) {
+    uint16_t len = 0;
+    if(!readByte(this->buffer, &len)) return 0;
+    bool isPublish = (this->buffer[0]&0xF0) == MQTTPUBLISH;
+    uint32_t multiplier = 1;
+    uint32_t length = 0;
+    uint8_t digit = 0;
+    uint16_t skip = 0;
+    uint32_t start = 0;
+
+    do {
+        if (len == 5) {
+            // Invalid remaining length encoding - kill the connection
+            _state = MQTT_DISCONNECTED;
+            _client->stop();
+            return 0;
+        }
+        if(!readByte(&digit)) return 0;
+        this->buffer[len++] = digit;
+        length += (digit & 127) * multiplier;
+        multiplier <<=7; //multiplier *= 128
+    } while ((digit & 128) != 0);
+    *lengthLength = len-1;
+
+    if (isPublish) {
+        // Read in topic length to calculate bytes to skip over for Stream writing
+        if(!readByte(this->buffer, &len)) return 0;
+        if(!readByte(this->buffer, &len)) return 0;
+        skip = (this->buffer[*lengthLength+1]<<8)+this->buffer[*lengthLength+2];
+        start = 2;
+        if (this->buffer[0]&MQTTQOS1) {
+            // skip message id
+            skip += 2;
+        }
+    }
+    uint32_t idx = len;
+
+    for (uint32_t i = start;i<length;i++) {
+        if(!readByte(&digit)) return 0;
+        if (this->stream) {
+            if (isPublish && idx-*lengthLength-2>skip) {
+                this->stream->write(digit);
+            }
+        }
+
+        if (len < this->bufferSize) {
+            this->buffer[len] = digit;
+            len++;
+        }
+        idx++;
+    }
+
+    if (!this->stream && idx > this->bufferSize) {
+        len = 0; // This will cause the packet to be ignored.
+    }
+    return len;
+}
+
+boolean PubSubClient::loop() {
+    if (connected()) {
+        unsigned long t = millis();
+        if ((t - lastInActivity > this->keepAlive*1000UL) || (t - lastOutActivity > this->keepAlive*1000UL)) {
+            if (pingOutstanding) {
+                this->_state = MQTT_CONNECTION_TIMEOUT;
+                _client->stop();
+                return false;
+            } else {
+                this->buffer[0] = MQTTPINGREQ;
+                this->buffer[1] = 0;
+                _client->write(this->buffer,2);
+                lastOutActivity = t;
+                lastInActivity = t;
+                pingOutstanding = true;
+            }
+        }
+        if (_client->available()) {
+            uint8_t llen;
+            uint16_t len = readPacket(&llen);
+            uint16_t msgId = 0;
+            uint8_t *payload;
+            if (len > 0) {
+                lastInActivity = t;
+                uint8_t type = this->buffer[0]&0xF0;
+                if (type == MQTTPUBLISH) {
+                    if (callback) {
+                        uint16_t tl = (this->buffer[llen+1]<<8)+this->buffer[llen+2]; /* topic length in bytes */
+                        memmove(this->buffer+llen+2,this->buffer+llen+3,tl); /* move topic inside buffer 1 byte to front */
+                        this->buffer[llen+2+tl] = 0; /* end the topic as a 'C' string with \x00 */
+                        char *topic = (char*) this->buffer+llen+2;
+                        // msgId only present for QOS>0
+                        if ((this->buffer[0]&0x06) == MQTTQOS1) {
+                            msgId = (this->buffer[llen+3+tl]<<8)+this->buffer[llen+3+tl+1];
+                            payload = this->buffer+llen+3+tl+2;
+                            callback(topic,payload,len-llen-3-tl-2);
+
+                            this->buffer[0] = MQTTPUBACK;
+                            this->buffer[1] = 2;
+                            this->buffer[2] = (msgId >> 8);
+                            this->buffer[3] = (msgId & 0xFF);
+                            _client->write(this->buffer,4);
+                            lastOutActivity = t;
+
+                        } else {
+                            payload = this->buffer+llen+3+tl;
+                            callback(topic,payload,len-llen-3-tl);
+                        }
+                    }
+                } else if (type == MQTTPINGREQ) {
+                    this->buffer[0] = MQTTPINGRESP;
+                    this->buffer[1] = 0;
+                    _client->write(this->buffer,2);
+                } else if (type == MQTTPINGRESP) {
+                    pingOutstanding = false;
+                }
+            } else if (!connected()) {
+                // readPacket has closed the connection
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+boolean PubSubClient::publish(const char* topic, const char* payload) {
+    return publish(topic,(const uint8_t*)payload, payload ? strnlen(payload, this->bufferSize) : 0,false);
+}
+
+boolean PubSubClient::publish(const char* topic, const char* payload, boolean retained) {
+    return publish(topic,(const uint8_t*)payload, payload ? strnlen(payload, this->bufferSize) : 0,retained);
+}
+
+boolean PubSubClient::publish(const char* topic, const uint8_t* payload, unsigned int plength) {
+    return publish(topic, payload, plength, false);
+}
+
+boolean PubSubClient::publish(const char* topic, const uint8_t* payload, unsigned int plength, boolean retained) {
+    if (connected()) {
+        if (this->bufferSize < MQTT_MAX_HEADER_SIZE + 2+strnlen(topic, this->bufferSize) + plength) {
+            // Too long
+            return false;
+        }
+        // Leave room in the buffer for header and variable length field
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        length = writeString(topic,this->buffer,length);
+
+        // Add payload
+        uint16_t i;
+        for (i=0;i<plength;i++) {
+            this->buffer[length++] = payload[i];
+        }
+
+        // Write the header
+        uint8_t header = MQTTPUBLISH;
+        if (retained) {
+            header |= 1;
+        }
+        return write(header,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+    }
+    return false;
+}
+
+boolean PubSubClient::publish_P(const char* topic, const char* payload, boolean retained) {
+    return publish_P(topic, (const uint8_t*)payload, payload ? strnlen(payload, this->bufferSize) : 0, retained);
+}
+
+boolean PubSubClient::publish_P(const char* topic, const uint8_t* payload, unsigned int plength, boolean retained) {
+    uint8_t llen = 0;
+    uint8_t digit;
+    unsigned int rc = 0;
+    uint16_t tlen;
+    unsigned int pos = 0;
+    unsigned int i;
+    uint8_t header;
+    unsigned int len;
+    int expectedLength;
+
+    if (!connected()) {
+        return false;
+    }
+
+    tlen = strnlen(topic, this->bufferSize);
+
+    header = MQTTPUBLISH;
+    if (retained) {
+        header |= 1;
+    }
+    this->buffer[pos++] = header;
+    len = plength + 2 + tlen;
+    do {
+        digit = len  & 127; //digit = len %128
+        len >>= 7; //len = len / 128
+        if (len > 0) {
+            digit |= 0x80;
+        }
+        this->buffer[pos++] = digit;
+        llen++;
+    } while(len>0);
+
+    pos = writeString(topic,this->buffer,pos);
+
+    rc += _client->write(this->buffer,pos);
+
+    for (i=0;i<plength;i++) {
+        rc += _client->write((char)pgm_read_byte_near(payload + i));
+    }
+
+    lastOutActivity = millis();
+
+    expectedLength = 1 + llen + 2 + tlen + plength;
+
+    return (rc == expectedLength);
+}
+
+boolean PubSubClient::beginPublish(const char* topic, unsigned int plength, boolean retained) {
+    if (connected()) {
+        // Send the header and variable length field
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        length = writeString(topic,this->buffer,length);
+        uint8_t header = MQTTPUBLISH;
+        if (retained) {
+            header |= 1;
+        }
+        size_t hlen = buildHeader(header, this->buffer, plength+length-MQTT_MAX_HEADER_SIZE);
+        uint16_t rc = _client->write(this->buffer+(MQTT_MAX_HEADER_SIZE-hlen),length-(MQTT_MAX_HEADER_SIZE-hlen));
+        lastOutActivity = millis();
+        return (rc == (length-(MQTT_MAX_HEADER_SIZE-hlen)));
+    }
+    return false;
+}
+
+int PubSubClient::endPublish() {
+ return 1;
+}
+
+size_t PubSubClient::write(uint8_t data) {
+    lastOutActivity = millis();
+    return _client->write(data);
+}
+
+size_t PubSubClient::write(const uint8_t *buffer, size_t size) {
+    lastOutActivity = millis();
+    return _client->write(buffer,size);
+}
+
+size_t PubSubClient::buildHeader(uint8_t header, uint8_t* buf, uint16_t length) {
+    uint8_t lenBuf[4];
+    uint8_t llen = 0;
+    uint8_t digit;
+    uint8_t pos = 0;
+    uint16_t len = length;
+    do {
+
+        digit = len  & 127; //digit = len %128
+        len >>= 7; //len = len / 128
+        if (len > 0) {
+            digit |= 0x80;
+        }
+        lenBuf[pos++] = digit;
+        llen++;
+    } while(len>0);
+
+    buf[4-llen] = header;
+    for (int i=0;i<llen;i++) {
+        buf[MQTT_MAX_HEADER_SIZE-llen+i] = lenBuf[i];
+    }
+    return llen+1; // Full header size is variable length bit plus the 1-byte fixed header
+}
+
+boolean PubSubClient::write(uint8_t header, uint8_t* buf, uint16_t length) {
+    uint16_t rc;
+    uint8_t hlen = buildHeader(header, buf, length);
+
+#ifdef MQTT_MAX_TRANSFER_SIZE
+    uint8_t* writeBuf = buf+(MQTT_MAX_HEADER_SIZE-hlen);
+    uint16_t bytesRemaining = length+hlen;  //Match the length type
+    uint8_t bytesToWrite;
+    boolean result = true;
+    while((bytesRemaining > 0) && result) {
+        bytesToWrite = (bytesRemaining > MQTT_MAX_TRANSFER_SIZE)?MQTT_MAX_TRANSFER_SIZE:bytesRemaining;
+        rc = _client->write(writeBuf,bytesToWrite);
+        result = (rc == bytesToWrite);
+        bytesRemaining -= rc;
+        writeBuf += rc;
+    }
+    return result;
+#else
+    rc = _client->write(buf+(MQTT_MAX_HEADER_SIZE-hlen),length+hlen);
+    lastOutActivity = millis();
+    return (rc == hlen+length);
+#endif
+}
+
+boolean PubSubClient::subscribe(const char* topic) {
+    return subscribe(topic, 0);
+}
+
+boolean PubSubClient::subscribe(const char* topic, uint8_t qos) {
+    size_t topicLength = strnlen(topic, this->bufferSize);
+    if (topic == 0) {
+        return false;
+    }
+    if (qos > 1) {
+        return false;
+    }
+    if (this->bufferSize < 9 + topicLength) {
+        // Too long
+        return false;
+    }
+    if (connected()) {
+        // Leave room in the buffer for header and variable length field
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        nextMsgId++;
+        if (nextMsgId == 0) {
+            nextMsgId = 1;
+        }
+        this->buffer[length++] = (nextMsgId >> 8);
+        this->buffer[length++] = (nextMsgId & 0xFF);
+        length = writeString((char*)topic, this->buffer,length);
+        this->buffer[length++] = qos;
+        return write(MQTTSUBSCRIBE|MQTTQOS1,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+    }
+    return false;
+}
+
+boolean PubSubClient::unsubscribe(const char* topic) {
+	size_t topicLength = strnlen(topic, this->bufferSize);
+    if (topic == 0) {
+        return false;
+    }
+    if (this->bufferSize < 9 + topicLength) {
+        // Too long
+        return false;
+    }
+    if (connected()) {
+        uint16_t length = MQTT_MAX_HEADER_SIZE;
+        nextMsgId++;
+        if (nextMsgId == 0) {
+            nextMsgId = 1;
+        }
+        this->buffer[length++] = (nextMsgId >> 8);
+        this->buffer[length++] = (nextMsgId & 0xFF);
+        length = writeString(topic, this->buffer,length);
+        return write(MQTTUNSUBSCRIBE|MQTTQOS1,this->buffer,length-MQTT_MAX_HEADER_SIZE);
+    }
+    return false;
+}
+
+void PubSubClient::disconnect() {
+    this->buffer[0] = MQTTDISCONNECT;
+    this->buffer[1] = 0;
+    _client->write(this->buffer,2);
+    _state = MQTT_DISCONNECTED;
+    _client->flush();
+    _client->stop();
+    lastInActivity = lastOutActivity = millis();
+}
+
+uint16_t PubSubClient::writeString(const char* string, uint8_t* buf, uint16_t pos) {
+    const char* idp = string;
+    uint16_t i = 0;
+    pos += 2;
+    while (*idp) {
+        buf[pos++] = *idp++;
+        i++;
+    }
+    buf[pos-i-2] = (i >> 8);
+    buf[pos-i-1] = (i & 0xFF);
+    return pos;
+}
+
+
+boolean PubSubClient::connected() {
+    boolean rc;
+    if (_client == NULL ) {
+        rc = false;
+    } else {
+        rc = (int)_client->connected();
+        if (!rc) {
+            if (this->_state == MQTT_CONNECTED) {
+                this->_state = MQTT_CONNECTION_LOST;
+                _client->flush();
+                _client->stop();
+            }
+        } else {
+            return this->_state == MQTT_CONNECTED;
+        }
+    }
+    return rc;
+}
+
+PubSubClient& PubSubClient::setServer(uint8_t * ip, uint16_t port) {
+    IPAddress addr(ip[0],ip[1],ip[2],ip[3]);
+    return setServer(addr,port);
+}
+
+PubSubClient& PubSubClient::setServer(IPAddress ip, uint16_t port) {
+    this->ip = ip;
+    this->port = port;
+    this->domain = NULL;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setServer(const char * domain, uint16_t port) {
+    this->domain = domain;
+    this->port = port;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setCallback(MQTT_CALLBACK_SIGNATURE) {
+    this->callback = callback;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setClient(Client& client){
+    this->_client = &client;
+    return *this;
+}
+
+PubSubClient& PubSubClient::setStream(Stream& stream){
+    this->stream = &stream;
+    return *this;
+}
+
+int PubSubClient::state() {
+    return this->_state;
+}
+
+boolean PubSubClient::setBufferSize(uint16_t size) {
+    if (size == 0) {
+        // Cannot set it back to 0
+        return false;
+    }
+    if (this->bufferSize == 0) {
+        this->buffer = (uint8_t*)malloc(size);
+    } else {
+        uint8_t* newBuffer = (uint8_t*)realloc(this->buffer, size);
+        if (newBuffer != NULL) {
+            this->buffer = newBuffer;
+        } else {
+            return false;
+        }
+    }
+    this->bufferSize = size;
+    return (this->buffer != NULL);
+}
+
+uint16_t PubSubClient::getBufferSize() {
+    return this->bufferSize;
+}
+PubSubClient& PubSubClient::setKeepAlive(uint16_t keepAlive) {
+    this->keepAlive = keepAlive;
+    return *this;
+}
+PubSubClient& PubSubClient::setSocketTimeout(uint16_t timeout) {
+    this->socketTimeout = timeout;
+    return *this;
+}

.pio/libdeps/esp32dev/PubSubClient/src/PubSubClient.h

@@ -0,0 +1,184 @@
+/*
+ PubSubClient.h - A simple client for MQTT.
+  Nick O'Leary
+  http://knolleary.net
+*/
+
+#ifndef PubSubClient_h
+#define PubSubClient_h
+
+#include <Arduino.h>
+#include "IPAddress.h"
+#include "Client.h"
+#include "Stream.h"
+
+#define MQTT_VERSION_3_1      3
+#define MQTT_VERSION_3_1_1    4
+
+// MQTT_VERSION : Pick the version
+//#define MQTT_VERSION MQTT_VERSION_3_1
+#ifndef MQTT_VERSION
+#define MQTT_VERSION MQTT_VERSION_3_1_1
+#endif
+
+// MQTT_MAX_PACKET_SIZE : Maximum packet size. Override with setBufferSize().
+#ifndef MQTT_MAX_PACKET_SIZE
+#define MQTT_MAX_PACKET_SIZE 256
+#endif
+
+// MQTT_KEEPALIVE : keepAlive interval in Seconds. Override with setKeepAlive()
+#ifndef MQTT_KEEPALIVE
+#define MQTT_KEEPALIVE 15
+#endif
+
+// MQTT_SOCKET_TIMEOUT: socket timeout interval in Seconds. Override with setSocketTimeout()
+#ifndef MQTT_SOCKET_TIMEOUT
+#define MQTT_SOCKET_TIMEOUT 15
+#endif
+
+// MQTT_MAX_TRANSFER_SIZE : limit how much data is passed to the network client
+//  in each write call. Needed for the Arduino Wifi Shield. Leave undefined to
+//  pass the entire MQTT packet in each write call.
+//#define MQTT_MAX_TRANSFER_SIZE 80
+
+// Possible values for client.state()
+#define MQTT_CONNECTION_TIMEOUT     -4
+#define MQTT_CONNECTION_LOST        -3
+#define MQTT_CONNECT_FAILED         -2
+#define MQTT_DISCONNECTED           -1
+#define MQTT_CONNECTED               0
+#define MQTT_CONNECT_BAD_PROTOCOL    1
+#define MQTT_CONNECT_BAD_CLIENT_ID   2
+#define MQTT_CONNECT_UNAVAILABLE     3
+#define MQTT_CONNECT_BAD_CREDENTIALS 4
+#define MQTT_CONNECT_UNAUTHORIZED    5
+
+#define MQTTCONNECT     1 << 4  // Client request to connect to Server
+#define MQTTCONNACK     2 << 4  // Connect Acknowledgment
+#define MQTTPUBLISH     3 << 4  // Publish message
+#define MQTTPUBACK      4 << 4  // Publish Acknowledgment
+#define MQTTPUBREC      5 << 4  // Publish Received (assured delivery part 1)
+#define MQTTPUBREL      6 << 4  // Publish Release (assured delivery part 2)
+#define MQTTPUBCOMP     7 << 4  // Publish Complete (assured delivery part 3)
+#define MQTTSUBSCRIBE   8 << 4  // Client Subscribe request
+#define MQTTSUBACK      9 << 4  // Subscribe Acknowledgment
+#define MQTTUNSUBSCRIBE 10 << 4 // Client Unsubscribe request
+#define MQTTUNSUBACK    11 << 4 // Unsubscribe Acknowledgment
+#define MQTTPINGREQ     12 << 4 // PING Request
+#define MQTTPINGRESP    13 << 4 // PING Response
+#define MQTTDISCONNECT  14 << 4 // Client is Disconnecting
+#define MQTTReserved    15 << 4 // Reserved
+
+#define MQTTQOS0        (0 << 1)
+#define MQTTQOS1        (1 << 1)
+#define MQTTQOS2        (2 << 1)
+
+// Maximum size of fixed header and variable length size header
+#define MQTT_MAX_HEADER_SIZE 5
+
+#if defined(ESP8266) || defined(ESP32)
+#include <functional>
+#define MQTT_CALLBACK_SIGNATURE std::function<void(char*, uint8_t*, unsigned int)> callback
+#else
+#define MQTT_CALLBACK_SIGNATURE void (*callback)(char*, uint8_t*, unsigned int)
+#endif
+
+#define CHECK_STRING_LENGTH(l,s) if (l+2+strnlen(s, this->bufferSize) > this->bufferSize) {_client->stop();return false;}
+
+class PubSubClient : public Print {
+private:
+   Client* _client;
+   uint8_t* buffer;
+   uint16_t bufferSize;
+   uint16_t keepAlive;
+   uint16_t socketTimeout;
+   uint16_t nextMsgId;
+   unsigned long lastOutActivity;
+   unsigned long lastInActivity;
+   bool pingOutstanding;
+   MQTT_CALLBACK_SIGNATURE;
+   uint32_t readPacket(uint8_t*);
+   boolean readByte(uint8_t * result);
+   boolean readByte(uint8_t * result, uint16_t * index);
+   boolean write(uint8_t header, uint8_t* buf, uint16_t length);
+   uint16_t writeString(const char* string, uint8_t* buf, uint16_t pos);
+   // Build up the header ready to send
+   // Returns the size of the header
+   // Note: the header is built at the end of the first MQTT_MAX_HEADER_SIZE bytes, so will start
+   //       (MQTT_MAX_HEADER_SIZE - <returned size>) bytes into the buffer
+   size_t buildHeader(uint8_t header, uint8_t* buf, uint16_t length);
+   IPAddress ip;
+   const char* domain;
+   uint16_t port;
+   Stream* stream;
+   int _state;
+public:
+   PubSubClient();
+   PubSubClient(Client& client);
+   PubSubClient(IPAddress, uint16_t, Client& client);
+   PubSubClient(IPAddress, uint16_t, Client& client, Stream&);
+   PubSubClient(IPAddress, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client);
+   PubSubClient(IPAddress, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&);
+   PubSubClient(uint8_t *, uint16_t, Client& client);
+   PubSubClient(uint8_t *, uint16_t, Client& client, Stream&);
+   PubSubClient(uint8_t *, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client);
+   PubSubClient(uint8_t *, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&);
+   PubSubClient(const char*, uint16_t, Client& client);
+   PubSubClient(const char*, uint16_t, Client& client, Stream&);
+   PubSubClient(const char*, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client);
+   PubSubClient(const char*, uint16_t, MQTT_CALLBACK_SIGNATURE,Client& client, Stream&);
+
+   ~PubSubClient();
+
+   PubSubClient& setServer(IPAddress ip, uint16_t port);
+   PubSubClient& setServer(uint8_t * ip, uint16_t port);
+   PubSubClient& setServer(const char * domain, uint16_t port);
+   PubSubClient& setCallback(MQTT_CALLBACK_SIGNATURE);
+   PubSubClient& setClient(Client& client);
+   PubSubClient& setStream(Stream& stream);
+   PubSubClient& setKeepAlive(uint16_t keepAlive);
+   PubSubClient& setSocketTimeout(uint16_t timeout);
+
+   boolean setBufferSize(uint16_t size);
+   uint16_t getBufferSize();
+
+   boolean connect(const char* id);
+   boolean connect(const char* id, const char* user, const char* pass);
+   boolean connect(const char* id, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage);
+   boolean connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage);
+   boolean connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage, boolean cleanSession);
+   void disconnect();
+   boolean publish(const char* topic, const char* payload);
+   boolean publish(const char* topic, const char* payload, boolean retained);
+   boolean publish(const char* topic, const uint8_t * payload, unsigned int plength);
+   boolean publish(const char* topic, const uint8_t * payload, unsigned int plength, boolean retained);
+   boolean publish_P(const char* topic, const char* payload, boolean retained);
+   boolean publish_P(const char* topic, const uint8_t * payload, unsigned int plength, boolean retained);
+   // Start to publish a message.
+   // This API:
+   //   beginPublish(...)
+   //   one or more calls to write(...)
+   //   endPublish()
+   // Allows for arbitrarily large payloads to be sent without them having to be copied into
+   // a new buffer and held in memory at one time
+   // Returns 1 if the message was started successfully, 0 if there was an error
+   boolean beginPublish(const char* topic, unsigned int plength, boolean retained);
+   // Finish off this publish message (started with beginPublish)
+   // Returns 1 if the packet was sent successfully, 0 if there was an error
+   int endPublish();
+   // Write a single byte of payload (only to be used with beginPublish/endPublish)
+   virtual size_t write(uint8_t);
+   // Write size bytes from buffer into the payload (only to be used with beginPublish/endPublish)
+   // Returns the number of bytes written
+   virtual size_t write(const uint8_t *buffer, size_t size);
+   boolean subscribe(const char* topic);
+   boolean subscribe(const char* topic, uint8_t qos);
+   boolean unsubscribe(const char* topic);
+   boolean loop();
+   boolean connected();
+   int state();
+
+};
+
+
+#endif

.pio/libdeps/esp32dev/TinyGSM/.piopm

@@ -0,0 +1 @@
+{"type": "library", "name": "TinyGSM", "version": "0.11.5", "spec": {"owner": "vshymanskyy", "id": 1287, "name": "TinyGSM", "requirements": null, "uri": null}}

.pio/libdeps/esp32dev/TinyGSM/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

.pio/libdeps/esp32dev/TinyGSM/README.md

@@ -0,0 +1,415 @@
+![TinyGSM logo](https://cdn.rawgit.com/vshymanskyy/TinyGSM/d18e93dc51fe988a0b175aac647185457ef640b5/extras/logo.svg)
+
+A small Arduino library for GSM modules, that just works.
+<!---
+[![GitHub download](https://img.shields.io/github/downloads/vshymanskyy/TinyGSM/total.svg)](https://github.com/vshymanskyy/TinyGSM/releases/latest)--->
+[![GitHub version](https://img.shields.io/github/release/vshymanskyy/TinyGSM.svg)](https://github.com/vshymanskyy/TinyGSM/releases/latest)
+[![Build status](https://img.shields.io/travis/vshymanskyy/TinyGSM.svg)](https://travis-ci.org/vshymanskyy/TinyGSM)
+[![GitHub issues](https://img.shields.io/github/issues/vshymanskyy/TinyGSM.svg)](https://github.com/vshymanskyy/TinyGSM/issues)
+[![GitHub wiki](https://img.shields.io/badge/Wiki-available-brightgreen.svg)](https://github.com/vshymanskyy/TinyGSM/wiki)
+[![GitHub stars](https://img.shields.io/github/stars/vshymanskyy/TinyGSM.svg)](https://github.com/vshymanskyy/TinyGSM/stargazers)
+[![License](https://img.shields.io/badge/license-LGPL3-blue.svg)](https://github.com/vshymanskyy/TinyGSM/blob/master/LICENSE)
+
+If you like **TinyGSM** - give it a star, or fork it and contribute!
+[![GitHub stars](https://img.shields.io/github/stars/vshymanskyy/TinyGSM.svg?style=social&label=Star)](https://github.com/vshymanskyy/TinyGSM/stargazers)
+[![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)
+
+- [Supported modems](#supported-modems)
+  - [Supported boards/modules](#supported-boardsmodules)
+- [Features](#features)
+- [Getting Started](#getting-started)
+    - [First Steps](#first-steps)
+    - [Writing your own code](#writing-your-own-code)
+    - [If you have any issues](#if-you-have-any-issues)
+- [How does it work?](#how-does-it-work)
+- [API Reference](#api-reference)
+- [Troubleshooting](#troubleshooting)
+  - [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)
+  - [Diagnostics sketch](#diagnostics-sketch)
+  - [Web request formatting problems - "but it works with PostMan"](#web-request-formatting-problems---but-it-works-with-postman)
+  - [SoftwareSerial problems](#softwareserial-problems)
+  - [ESP32 Notes](#esp32-notes)
+    - [HardwareSerial](#hardwareserial)
+    - [HttpClient](#httpclient)
+  - [SAMD21](#samd21)
+  - [Goouuu Tech IOT-GA6 vs AI-Thinker A6 confusion](#goouuu-tech-iot-ga6-vs-ai-thinker-a6-confusion)
+  - [SIM800 and SSL](#sim800-and-ssl)
+  - [Which version of the SIM7000 code to use](#which-version-of-the-sim7000-code-to-use)
+- [License](#license)
+
+### Arduino Client interface support
+This library is easy to integrate with lots of sketches which use Ethernet or WiFi.
+**PubSubClient ([MQTT](http://mqtt.org/))**, **[Blynk](http://blynk.cc)**, **HTTP Client** and **File Download** examples are provided.
+
+![examples](/extras/examples.png)
+
+### TinyGSM is tiny
+The complete WebClient example for Arduino Uno (via Software Serial) takes little resources:
+```
+Sketch uses 15022 bytes (46%) of program storage space. Maximum is 32256 bytes.
+Global variables use 574 bytes (28%) of dynamic memory, leaving 1474 bytes for local variables. Maximum is 2048 bytes.
+```
+Arduino GSM library uses 15868 bytes (49%) of Flash and 1113 bytes (54%) of RAM in a similar scenario.
+TinyGSM also pulls data gently from the modem (whenever possible), so it can operate on very little RAM.
+**Now, you have more space for your experiments.**
+
+
+## Supported modems
+
+- SIMCom SIM800 series (SIM800A, SIM800C, SIM800L, SIM800H, SIM808, SIM868)
+- SIMCom SIM900 series (SIM900A, SIM900D, SIM908, SIM968)
+- SIMCom WCDMA/HSPA/HSPA+ Modules (SIM5360, SIM5320, SIM5300E, SIM5300E/A)
+- 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
+- AI-Thinker A6, A6C, A7, A20
+- ESP8266/ESP32 (AT commands interface, similar to GSM modems)
+- 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_)
+- Sequans Monarch LTE Cat M1/NB1 (VZM20Q)
+- Quectel BG96
+- Quectel M95
+- Quectel MC60 ***(alpha)***
+
+### Supported boards/modules
+- Arduino MKR GSM 1400
+- GPRSbee
+- Microduino GSM
+- Adafruit FONA (Mini Cellular GSM Breakout)
+- Adafruit FONA 800/808 Shield
+- Industruino GSM
+- 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
+
+**Data connections**
+- TCP (HTTP, MQTT, Blynk, ...)
+    - ALL modules support TCP connections
+    - Most modules support multiple simultaneous connections:
+        - A6/A7 - 8
+        - ESP8266 - 5
+        - Neoway M590 - 2
+        - Quectel BG96 - 12
+        - Quectel M95 - 6
+        - Quectel MC60/MC60E - 6
+        - Sequans Monarch - 6
+        - SIM 800/900 - 5
+        - SIM 5360/5320/5300/7100 - 10
+        - SIM7000 - 8 possible without SSL, only 2 with
+        - SIM 7070/7080/7090 - 12
+        - SIM 7500/7600/7800 - 10
+        - u-blox 2G/3G - 7
+        - u-blox SARA R4/N4 - 7
+        - Digi XBee - _only 1 connection supported!_
+- UDP
+    - 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
+        - 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
+    - Not possible on:
+        - SIM900, A6/A7, Neoway M590, XBee _WiFi_
+    - Like TCP, most modules support simultaneous connections
+    - TCP and SSL connections can usually be mixed up to the total number of possible connections
+
+**USSD**
+- Sending USSD requests and decoding 7,8,16-bit responses
+    - Supported on:
+        - All SIMCom modems, Quectel modems, most u-blox
+    - Not possible on:
+        - XBee, u-blox SARA R4/N4, ESP8266 (obviously)
+
+**SMS**
+- Only _sending_ SMS is supported, not receiving
+    - Supported on all cellular modules
+
+**Voice Calls**
+- Supported on:
+    - SIM800/SIM900, SIM7600, A6/A7, Quectel modems, u-blox
+- 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)
+- Functions:
+    - Dial, hangup
+    - DTMF sending
+
+**Location**
+- GPS/GNSS
+    - SIM808, SIM7000, SIM7500/7600/7800, BG96, 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
+
+**Credits**
+- Primary Authors/Contributors:
+    - [vshymanskyy](https://github.com/vshymanskyy)
+    - [SRGDamia1](https://github.com/SRGDamia1/)
+- SIM7000:
+    - [captFuture](https://github.com/captFuture/)
+    - [FStefanni](https://github.com/FStefanni/)
+- Sequans Monarch:
+    - [nootropicdesign](https://github.com/nootropicdesign/)
+- Quectel M9C60
+    - [V1pr](https://github.com/V1pr)
+- Quectel M95
+    - [replicadeltd](https://github.com/replicadeltd)
+- Other Contributors:
+    - https://github.com/vshymanskyy/TinyGSM/graphs/contributors
+
+## Getting Started
+
+#### First Steps
+
+  1. Using your phone:
+    - Disable PIN code on the SIM card
+    - Check your balance
+    - Check that APN, User, Pass are correct and you have internet
+  2. Ensure the SIM card is correctly inserted into the module
+  3. Ensure that GSM antenna is firmly attached
+  4. Ensure that you have a stable power supply to the module of at least **2A**.
+  5. Check if serial connection is working (Hardware Serial is recommended)
+     Send an ```AT``` command using [this sketch](tools/AT_Debug/AT_Debug.ino)
+  6. Try out the [WebClient](https://github.com/vshymanskyy/TinyGSM/blob/master/examples/WebClient/WebClient.ino) example
+
+#### Writing your own code
+
+The general flow of your code should be:
+- Define the module that you are using (choose one and only one)
+    - ie, ```#define TINY_GSM_MODEM_SIM800```
+- Included TinyGSM
+    - ```#include <TinyGsmClient.h>```
+- Create a TinyGSM modem instance
+    - ```TinyGsm modem(SerialAT);```
+- Create one or more TinyGSM client instances
+    - For a single connection, use
+        - ```TinyGsmClient client(modem);```
+        or
+        ```TinyGsmClientSecure client(modem);``` (on supported modules)
+    - For multiple connections (on supported modules) use:
+        - ```TinyGsmClient clientX(modem, 0);```, ```TinyGsmClient clientY(modem, 1);```, etc
+          or
+        - ```TinyGsmClientSecure clientX(modem, 0);```, ```TinyGsmClientSecure clientY(modem, 1);```, etc
+    - Secure and insecure clients can usually be mixed when using multiple connections.
+    - The total number of connections possible varies by module
+- Begin your serial communication and set all your pins as required to power your module and bring it to full functionality.
+    - The examples attempt to guess the module's baud rate.  In working code, you should use a set baud.
+- Wait for the module to be ready (could be as much as 6s, depending on the module)
+- Initialize the modem
+    - ```modem.init()``` or ```modem.restart()```
+    - restart generally takes longer than init but ensures the module doesn't have lingering connections
+- Unlock your SIM, if necessary:
+    - ```modem.simUnlock(GSM_PIN)```
+- If using **WiFi**, specify your SSID information:
+    - ```modem.networkConnect(wifiSSID, wifiPass)```
+    - Network registration should be automatic on cellular modules
+- Wait for network registration to be successful
+    - ```modem.waitForNetwork(600000L)```
+- If using cellular, establish the GPRS or EPS data connection _after_ your are successfully registered on the network
+    - ```modem.gprsConnect(apn, gprsUser, gprsPass)``` (or simply ```modem.gprsConnect(apn)```)
+    - The same command is used for both GPRS or EPS connection
+    - If using a **Digi** brand cellular XBee, you must specify your GPRS/EPS connection information _before_ waiting for the network.  This is true ONLY for _Digi cellular XBees_!  _For all other cellular modules, use the GPRS connect function after network registration._
+- Connect the TCP or SSL client
+    ```client.connect(server, port)```
+- Send out your data.
+
+
+#### If you have any issues
+
+  1. Read the whole README (you're looking at it!), particularly the troubleshooting section below.
+  2. Some boards require [**special configuration**](https://github.com/vshymanskyy/TinyGSM/wiki/Board-configuration).
+  3. Try running the Diagnostics sketch
+  4. Check for [**highlighted topics here**](https://github.com/vshymanskyy/TinyGSM/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22for+reference%22+)
+  5. If you have a question, please post it in our [Gitter chat](https://gitter.im/tinygsm)
+
+## How does it work?
+
+Many GSM modems, WiFi and radio modules can be controlled by sending AT commands over Serial.
+TinyGSM knows which commands to send, and how to handle AT responses, and wraps that into standard Arduino Client interface.
+
+This library is "blocking" in all of its communication.
+Depending on the function, your code may be blocked for a long time waiting for the module responses.
+Apart from the obvious (ie, `waitForNetwork()`) several other functions may block your code for up to several *minutes*.
+The `gprsConnect()` and `client.connect()` functions commonly block the longest, especially in poorer service regions.
+The module shutdown and restart may also be quite slow.
+
+This libary *does not* support any sort of "hardware" or pin level controls for the modules.
+If you need to turn your module on or reset it using some sort of High/Low/High pin sequence, you must write those functions yourself.
+
+## API Reference
+
+For GPRS data streams, this library provides the standard [Arduino Client](https://www.arduino.cc/en/Reference/ClientConstructor) interface.
+For additional functions, please refer to [this example sketch](examples/AllFunctions/AllFunctions.ino)
+
+## Troubleshooting
+
+### Ensure stable data & power connection
+
+Most modules require _**as much as 2A**_ to properly connect to the network.
+This is 4x what a "standard" USB will supply!
+Improving the power supply actually solves stability problems in **many** cases!
+- Read about [**powering your module**](https://github.com/vshymanskyy/TinyGSM/wiki/Powering-GSM-module).
+- Keep your wires as short as possible
+- Consider soldering them for a stable connection
+- Do not put your wires next to noisy signal sources (buck converters, antennas, oscillators etc.)
+- If everything else seems to be working but you are unable to connect to the network, check your power supply!
+
+### Baud rates
+
+Most modules support some sort of "auto-bauding" feature where the module will attempt to adjust it's baud rate to match what it is receiving.
+TinyGSM also implements its own auto bauding function (`TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);`).
+While very useful when initially connecting to a module and doing tests, these should **NOT** be used in any sort of production code.
+Once you've established communication with the module, set the baud rate using the `setBaud(#)` function and stick with that rate.
+
+### Broken initial configuration
+
+Sometimes (especially if you played with AT commands), your module configuration may become invalid.
+This may result in problems such as:
+
+ * Can't connect to the GPRS network
+ * Can't connect to the server
+ * Sent/received data contains invalid bytes
+ * etc.
+
+To return module to **Factory Defaults**, use this sketch:
+  File -> Examples -> TinyGSM -> tools -> [FactoryReset](https://github.com/vshymanskyy/TinyGSM/blob/master/tools/FactoryReset/FactoryReset.ino)
+
+In some cases, you may need to set an initial APN to connect to the cellular network.
+Try using the ```gprsConnect(APN)``` function to set an initial APN if you are unable to register on the network.
+You may need set the APN again after registering.
+(In most cases, you should set the APN after registration.)
+
+### Failed connection or no data received
+
+The first connection with a new SIM card, a new module, or at a new location/tower may take a *LONG* time - up to 15 minutes or even more, especially if the signal quality isn't excellent.
+If it is your first connection, you may need to adjust your wait times and possibly go to lunch while you're waiting.
+
+If you are able to open a TCP connection but have the connection close before receiving data, try adding a keep-alive header to your request.
+Some modules (ie, the SIM7000 in SSL mode) will immediately throw away any un-read data when the remote server closes the connection - sometimes without even giving a notification that data arrived in the first place.
+When using MQTT, to keep a continuous connection you may need to reduce your keep-alive interval (PINGREQ/PINGRESP).
+
+### Diagnostics sketch
+
+Use this sketch to help diagnose SIM card and GPRS connection issues:
+  File -> Examples -> TinyGSM -> tools -> [Diagnostics](https://github.com/vshymanskyy/TinyGSM/blob/master/tools/Diagnostics/Diagnostics.ino)
+
+If the diagnostics fail, uncomment this line to output some debugging comments from the library:
+```cpp
+#define TINY_GSM_DEBUG SerialMon
+```
+In any custom code, ```TINY_GSM_DEBUG``` must be defined before including the TinyGSM library.
+
+If you are unable to see any obvious errors in the library debugging, use [StreamDebugger](https://github.com/vshymanskyy/StreamDebugger) to copy the entire AT command sequence to the main serial port.
+In the diagnostics example, simply uncomment the line:
+```cpp
+#define DUMP_AT_COMMANDS
+```
+In custom code, you can add this snippit:
+```cpp
+#ifdef DUMP_AT_COMMANDS
+  #include <StreamDebugger.h>
+  StreamDebugger debugger(SerialAT, SerialMon);
+  TinyGsm modem(debugger);
+#else
+  TinyGsm modem(SerialAT);
+#endif
+```
+
+### Web request formatting problems - "but it works with PostMan"
+
+This library opens a TCP (or SSL) connection to a server.
+In the [OSI model](https://en.wikipedia.org/wiki/OSI_model), that's [layer 4](http://www.tcpipguide.com/free/t_TransportLayerLayer4.htm) (or 5 for SSL).
+HTTP (GET/POST), MQTT, and most of the other functions you probably want to use live up at [layer 7](http://www.tcpipguide.com/free/t_ApplicationLayerLayer7.htm).
+This means that you need to either manually code the top layer or use another library (like [HTTPClient](https://github.com/arduino-libraries/ArduinoHttpClient) or [PubSubClient](https://pubsubclient.knolleary.net/)) to do it for you.
+Tools like [PostMan](https://www.postman.com/) also show layer 7, not layer 4/5 like TinyGSM.
+If you are successfully connecting to a server, but getting responses of "bad request" (or no response), the issue is probably your formatting.
+Here are some tips for writing layer 7 (particularly HTTP request) manually:
+- Look at the "WebClient" example
+- Make sure you are including all required headers.
+    - If you are testing with PostMan, make sure you un-hide and look at the "auto-generated" headers; you'll probably be surprised by how many of them there are.
+- Use ```client.print("...")```, or ```client.write(buf, #)```, or even ```client.write(String("..."))```, not ```client.write("...")``` to help prevent text being sent out one character at a time (typewriter style)
+- Enclose the entirety of each header or line within a single string or print statement
+    - use
+    ```cpp
+    client.print(String("GET ") + resource + " HTTP/1.1\r\n");
+    ```
+    instead of
+    ```cpp
+    client.print("GET ");
+    client.print(resource);
+    client.println(" HTTP/1.1")
+    ```
+- Make sure there is one entirely blank line between the last header and the content of any POST request.
+    - Add two lines to the last header ```client.print("....\r\n\r\n")``` or put in an extra ```client.println()```
+    - This is an HTTP requirement and is really easy to miss.
+
+### SoftwareSerial problems
+
+When using ```SoftwareSerial``` (on Uno, Nano, etc), the speed **115200** may not work.
+Try selecting **57600**, **38400**, or even lower - the one that works best for you.
+In some cases **9600** is unstable, but using **38400** helps, etc.
+Be sure to set correct TX/RX pins in the sketch. Please note that not every Arduino pin can serve as TX or RX pin.
+**Read more about SoftSerial options and configuration [here](https://www.pjrc.com/teensy/td_libs_AltSoftSerial.html) and [here](https://www.arduino.cc/en/Reference/SoftwareSerial).**
+
+### ESP32 Notes
+
+#### HardwareSerial
+
+When using ESP32 `HardwareSerial`, you may need to specify additional parameters to the `.begin()` call.
+Please [refer to this comment](https://github.com/vshymanskyy/TinyGSM/issues/91#issuecomment-356024747).
+
+#### HttpClient
+You will not be able to compile the HttpClient or HttpsClient examples with ESP32 core 1.0.2.  Upgrade to 1.0.3, downgrade to version 1.0.1 or use the WebClient example.
+
+### SAMD21
+
+When using SAMD21-based boards, you may need to use a sercom uart port instead of `Serial1`.
+Please [refer to this comment](https://github.com/vshymanskyy/TinyGSM/issues/102#issuecomment-345548941).
+
+### Goouuu Tech IOT-GA6 vs AI-Thinker A6 confusion
+
+It turns out that **Goouuu Tech IOT-GA6** is not the same as **AI-Thinker A6**. Unfortunately IOT-GA6 is not supported out of the box yet. There are some hints that IOT-GA6 firmware may be updated to match A6... See [this topic](https://github.com/vshymanskyy/TinyGSM/issues/164).
+
+### SIM800 and SSL
+
+Some, but not all, versions of the SIM800 support SSL.
+Having SSL support depends on the firmware version and the individual module.
+Users have had varying levels of success in using SSL on the SIM800 even with apparently identical firmware.
+If you need SSL and it does not appear to be working on your SIM800, try a different module or try using a secondary SSL library.
+
+### Which version of the SIM7000 code to use
+
+There are two versions of the SIM7000 code, one using `TINY_GSM_MODEM_SIM7000` and another with `TINY_GSM_MODEM_SIM7000SSL`.
+The `TINY_GSM_MODEM_SIM7000` version *does not support SSL* but supports up to 8 simultaneous connections.
+The `TINY_GSM_MODEM_SIM7000SSL` version supports both SSL *and unsecured connections* with up to 2 simultaneous connections.
+So why are there two versions?
+The "SSL" version uses the SIM7000's "application" commands while the other uses the "TCP-IP toolkit".
+Depending on your region/firmware, one or the other may not work for you.
+Try both and use whichever is more stable.
+If you do not need SSL, I recommend starting with `TINY_GSM_MODEM_SIM7000`.
+
+__________
+
+## License
+This project is released under
+The GNU Lesser General Public License (LGPL-3.0)

.pio/libdeps/esp32dev/TinyGSM/examples/AllFunctions/AllFunctions.ino

@@ -0,0 +1,488 @@
+/**************************************************************
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ * NOTE:
+ * Some of the functions may be unavailable for your modem.
+ * Just comment them out.
+ *
+ **************************************************************/
+
+// Select your modem:
+#define TINY_GSM_MODEM_SIM800
+// #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_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG96
+// #define TINY_GSM_MODEM_A6
+// #define TINY_GSM_MODEM_A7
+// #define TINY_GSM_MODEM_M590
+// #define TINY_GSM_MODEM_MC60
+// #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, default speed 115200)
+#define SerialMon Serial
+
+// Set serial for AT commands (to the module)
+// Use Hardware Serial on Mega, Leonardo, Micro
+#ifndef __AVR_ATmega328P__
+#define SerialAT Serial1
+
+// or Software Serial on Uno, Nano
+#else
+#include <SoftwareSerial.h>
+SoftwareSerial SerialAT(2, 3);  // RX, TX
+#endif
+
+// See all AT commands, if wanted
+// #define DUMP_AT_COMMANDS
+
+// Define the serial console for debug prints, if needed
+#define TINY_GSM_DEBUG SerialMon
+
+// Range to attempt to autobaud
+// NOTE:  DO NOT AUTOBAUD in production code.  Once you've established
+// communication, set a fixed baud rate using modem.setBaud(#).
+#define GSM_AUTOBAUD_MIN 9600
+#define GSM_AUTOBAUD_MAX 57600
+
+// Add a reception delay, if needed.
+// This may be needed for a fast processor at a slow baud rate.
+// #define TINY_GSM_YIELD() { delay(2); }
+
+/*
+ * Tests enabled
+ */
+#define TINY_GSM_TEST_GPRS true
+#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_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
+// disconnect and power down modem after tests
+#define TINY_GSM_POWERDOWN false
+
+// set GSM PIN, if any
+#define GSM_PIN ""
+
+// Set phone numbers, if you want to test SMS and Calls
+// #define SMS_TARGET  "+380xxxxxxxxx"
+// #define CALL_TARGET "+380xxxxxxxxx"
+
+// Your GPRS credentials, if any
+const char apn[] = "YourAPN";
+// const char apn[] = "ibasis.iot";
+const char gprsUser[] = "";
+const char gprsPass[] = "";
+
+// Your WiFi connection credentials, if applicable
+const char wifiSSID[] = "YourSSID";
+const char wifiPass[] = "YourWiFiPass";
+
+// Server details to test TCP/SSL
+const char server[]   = "vsh.pp.ua";
+const char resource[] = "/TinyGSM/logo.txt";
+
+#include <TinyGsmClient.h>
+
+#if TINY_GSM_TEST_GPRS && not defined TINY_GSM_MODEM_HAS_GPRS
+#undef TINY_GSM_TEST_GPRS
+#undef TINY_GSM_TEST_WIFI
+#define TINY_GSM_TEST_GPRS false
+#define TINY_GSM_TEST_WIFI true
+#endif
+#if TINY_GSM_TEST_WIFI && not defined TINY_GSM_MODEM_HAS_WIFI
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+#endif
+
+#ifdef DUMP_AT_COMMANDS
+#include <StreamDebugger.h>
+StreamDebugger debugger(SerialAT, SerialMon);
+TinyGsm        modem(debugger);
+#else
+TinyGsm        modem(SerialAT);
+#endif
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // !!!!!!!!!!!
+  // Set your reset, enable, power pins here
+  // !!!!!!!!!!!
+
+  DBG("Wait...");
+  delay(6000);
+
+  // Set GSM module baud rate
+  TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
+  // SerialAT.begin(9600);
+}
+
+void loop() {
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  DBG("Initializing modem...");
+  if (!modem.restart()) {
+    // if (!modem.init()) {
+    DBG("Failed to restart modem, delaying 10s and retrying");
+    // restart autobaud in case GSM just rebooted
+    // TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
+    return;
+  }
+
+  String name = modem.getModemName();
+  DBG("Modem Name:", name);
+
+  String modemInfo = modem.getModemInfo();
+  DBG("Modem Info:", modemInfo);
+
+#if TINY_GSM_TEST_GPRS
+  // Unlock your SIM card with a PIN if needed
+  if (GSM_PIN && modem.getSimStatus() != 3) { modem.simUnlock(GSM_PIN); }
+#endif
+
+#if TINY_GSM_TEST_WIFI
+  DBG("Setting SSID/password...");
+  if (!modem.networkConnect(wifiSSID, wifiPass)) {
+    DBG(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+#endif
+
+#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
+
+  DBG("Waiting for network...");
+  if (!modem.waitForNetwork(600000L, true)) {
+    delay(10000);
+    return;
+  }
+
+  if (modem.isNetworkConnected()) { DBG("Network connected"); }
+
+#if TINY_GSM_TEST_GPRS
+  DBG("Connecting to", apn);
+  if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
+    delay(10000);
+    return;
+  }
+
+  bool res = modem.isGprsConnected();
+  DBG("GPRS status:", res ? "connected" : "not connected");
+
+  String ccid = modem.getSimCCID();
+  DBG("CCID:", ccid);
+
+  String imei = modem.getIMEI();
+  DBG("IMEI:", imei);
+
+  String imsi = modem.getIMSI();
+  DBG("IMSI:", imsi);
+
+  String cop = modem.getOperator();
+  DBG("Operator:", cop);
+
+  IPAddress local = modem.localIP();
+  DBG("Local IP:", local);
+
+  int csq = modem.getSignalQuality();
+  DBG("Signal quality:", csq);
+#endif
+
+#if TINY_GSM_TEST_USSD && defined TINY_GSM_MODEM_HAS_SMS
+  String ussd_balance = modem.sendUSSD("*111#");
+  DBG("Balance (USSD):", ussd_balance);
+
+  String ussd_phone_num = modem.sendUSSD("*161#");
+  DBG("Phone number (USSD):", ussd_phone_num);
+#endif
+
+#if TINY_GSM_TEST_TCP && defined TINY_GSM_MODEM_HAS_TCP
+  TinyGsmClient client(modem, 0);
+  const int     port = 80;
+  DBG("Connecting to", server);
+  if (!client.connect(server, port)) {
+    DBG("... failed");
+  } else {
+    // Make a HTTP GET request:
+    client.print(String("GET ") + resource + " HTTP/1.0\r\n");
+    client.print(String("Host: ") + server + "\r\n");
+    client.print("Connection: close\r\n\r\n");
+
+    // Wait for data to arrive
+    uint32_t start = millis();
+    while (client.connected() && !client.available() &&
+           millis() - start < 30000L) {
+      delay(100);
+    };
+
+    // Read data
+    start          = millis();
+    char logo[640] = {
+        '\0',
+    };
+    int read_chars = 0;
+    while (client.connected() && millis() - start < 10000L) {
+      while (client.available()) {
+        logo[read_chars]     = client.read();
+        logo[read_chars + 1] = '\0';
+        read_chars++;
+        start = millis();
+      }
+    }
+    SerialMon.println(logo);
+    DBG("#####  RECEIVED:", strlen(logo), "CHARACTERS");
+    client.stop();
+  }
+#endif
+
+#if TINY_GSM_TEST_SSL && defined TINY_GSM_MODEM_HAS_SSL
+  TinyGsmClientSecure secureClient(modem, 1);
+  const int           securePort = 443;
+  DBG("Connecting securely to", server);
+  if (!secureClient.connect(server, securePort)) {
+    DBG("... failed");
+  } else {
+    // Make a HTTP GET request:
+    secureClient.print(String("GET ") + resource + " HTTP/1.0\r\n");
+    secureClient.print(String("Host: ") + server + "\r\n");
+    secureClient.print("Connection: close\r\n\r\n");
+
+    // Wait for data to arrive
+    uint32_t startS = millis();
+    while (secureClient.connected() && !secureClient.available() &&
+           millis() - startS < 30000L) {
+      delay(100);
+    };
+
+    // Read data
+    startS          = millis();
+    char logoS[640] = {
+        '\0',
+    };
+    int read_charsS = 0;
+    while (secureClient.connected() && millis() - startS < 10000L) {
+      while (secureClient.available()) {
+        logoS[read_charsS]     = secureClient.read();
+        logoS[read_charsS + 1] = '\0';
+        read_charsS++;
+        startS = millis();
+      }
+    }
+    SerialMon.println(logoS);
+    DBG("#####  RECEIVED:", strlen(logoS), "CHARACTERS");
+    secureClient.stop();
+  }
+#endif
+
+#if TINY_GSM_TEST_CALL && defined TINY_GSM_MODEM_HAS_CALLING && \
+    defined                       CALL_TARGET
+  DBG("Calling:", CALL_TARGET);
+
+  // This is NOT supported on M590
+  res = modem.callNumber(CALL_TARGET);
+  DBG("Call:", res ? "OK" : "fail");
+
+  if (res) {
+    delay(1000L);
+
+    // Play DTMF A, duration 1000ms
+    modem.dtmfSend('A', 1000);
+
+    // Play DTMF 0..4, default duration (100ms)
+    for (char tone = '0'; tone <= '4'; tone++) { modem.dtmfSend(tone); }
+
+    delay(5000);
+
+    res = modem.callHangup();
+    DBG("Hang up:", res ? "OK" : "fail");
+  }
+#endif
+
+#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");
+
+  // This is only supported on SIMxxx series
+  res = modem.sendSMS_UTF8_begin(SMS_TARGET);
+  if (res) {
+    auto stream = modem.sendSMS_UTF8_stream();
+    stream.print(F("Привіііт! Print number: "));
+    stream.print(595);
+    res = modem.sendSMS_UTF8_end();
+  }
+  DBG("UTF8 SMS:", res ? "OK" : "fail");
+
+#endif
+
+#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;
+  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);
+      break;
+    } else {
+      DBG("Couldn't get GSM location, retrying in 15s.");
+      delay(15000L);
+    }
+  }
+  DBG("Retrieving GSM location again as a string");
+  String location = modem.getGsmLocation();
+  DBG("GSM Based Location String:", location);
+#endif
+
+#if TINY_GSM_TEST_GPS && defined TINY_GSM_MODEM_HAS_GPS
+  DBG("Enabling GPS/GNSS/GLONASS and waiting 15s for warm-up");
+  modem.enableGPS();
+  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;
+  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);
+      break;
+    } else {
+      DBG("Couldn't get GPS/GNSS/GLONASS location, retrying in 15s.");
+      delay(15000L);
+    }
+  }
+  DBG("Retrieving GPS/GNSS/GLONASS location again as a string");
+  String gps_raw = modem.getGPSraw();
+  DBG("GPS/GNSS Based Location String:", gps_raw);
+  DBG("Disabling GPS");
+  modem.disableGPS();
+#endif
+
+#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);
+#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;
+  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);
+      break;
+    } else {
+      DBG("Couldn't get network time, retrying in 15s.");
+      delay(15000L);
+    }
+  }
+  DBG("Retrieving time again as a string");
+  String time = modem.getGSMDateTime(DATE_FULL);
+  DBG("Current Network Time:", time);
+#endif
+
+#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);
+  DBG("Battery charge state:", chargeState);
+  DBG("Battery charge 'percent':", percent);
+  DBG("Battery voltage:", milliVolts / 1000.0F);
+#endif
+
+#if TINY_GSM_TEST_TEMPERATURE && defined TINY_GSM_MODEM_HAS_TEMPERATURE
+  float temp = modem.getTemperature();
+  DBG("Chip temperature:", temp);
+#endif
+
+#if TINY_GSM_POWERDOWN
+
+#if TINY_GSM_TEST_GPRS
+  modem.gprsDisconnect();
+  delay(5000L);
+  if (!modem.isGprsConnected()) {
+    DBG("GPRS disconnected");
+  } else {
+    DBG("GPRS disconnect: Failed.");
+  }
+#endif
+
+#if TINY_GSM_TEST_WIFI
+  modem.networkDisconnect();
+  DBG("WiFi disconnected");
+#endif
+
+  // Try to power-off (modem may decide to restart automatically)
+  // To turn off modem completely, please use Reset/Enable pins
+  modem.poweroff();
+  DBG("Poweroff.");
+#endif
+
+  DBG("End of tests.");
+
+  // Do nothing forevermore
+  while (true) { modem.maintain(); }
+}

.pio/libdeps/esp32dev/TinyGSM/examples/BlynkClient/BlynkClient.ino

@@ -0,0 +1,110 @@
+/**************************************************************
+ *
+ * For this example, you need to install Blynk library:
+ *   https://github.com/blynkkk/blynk-library/releases/latest
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ **************************************************************
+ *
+ * Blynk is a platform with iOS and Android apps to control
+ * Arduino, Raspberry Pi and the likes over the Internet.
+ * You can easily build graphic interfaces for all your
+ * projects by simply dragging and dropping widgets.
+ *
+ * Blynk supports many development boards with WiFi, Ethernet,
+ * GSM, Bluetooth, BLE, USB/Serial connection methods.
+ * See more in Blynk library examples and community forum.
+ *
+ *                http://www.blynk.io/
+ *
+ * Change GPRS apm, user, pass, and Blynk auth token to run :)
+ **************************************************************/
+
+#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:
+// #define BLYNK_HEARTBEAT 30
+
+// Select your modem:
+#define TINY_GSM_MODEM_SIM800
+// #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_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG96
+// #define TINY_GSM_MODEM_A6
+// #define TINY_GSM_MODEM_A7
+// #define TINY_GSM_MODEM_M590
+// #define TINY_GSM_MODEM_MC60
+// #define TINY_GSM_MODEM_MC60E
+// #define TINY_GSM_MODEM_ESP8266
+// #define TINY_GSM_MODEM_XBEE
+// #define TINY_GSM_MODEM_SEQUANS_MONARCH
+
+#include <TinyGsmClient.h>
+#include <BlynkSimpleTinyGSM.h>
+
+// Set serial for debug console (to the Serial Monitor, default speed 115200)
+#define SerialMon Serial
+
+// Hardware Serial on Mega, Leonardo, Micro
+#ifndef __AVR_ATmega328P__
+#define SerialAT Serial1
+
+// or Software Serial on Uno, Nano
+#else
+#include <SoftwareSerial.h>
+SoftwareSerial SerialAT(2, 3);  // RX, TX
+#endif
+
+
+// Your GPRS credentials, if any
+const char apn[]  = "YourAPN";
+const char user[] = "";
+const char pass[] = "";
+
+// You should get Auth Token in the Blynk App.
+// Go to the Project Settings (nut icon).
+const char auth[] = "YourAuthToken";
+
+TinyGsm modem(SerialAT);
+
+void setup()
+{
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // Set GSM module baud rate
+  SerialAT.begin(115200);
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println("Initializing modem...");
+  modem.restart();
+
+  String modemInfo = modem.getModemInfo();
+  SerialMon.print("Modem Info: ");
+  SerialMon.println(modemInfo);
+
+  // Unlock your SIM card with a PIN
+  //modem.simUnlock("1234");
+
+  Blynk.begin(auth, modem, apn, user, pass);
+}
+
+void loop()
+{
+  Blynk.run();
+}

.pio/libdeps/esp32dev/TinyGSM/examples/FileDownload/FileDownload.ino

@@ -0,0 +1,356 @@
+/**************************************************************
+ *
+ * For this example, you need to install CRC32 library:
+ *   https://github.com/bakercp/CRC32
+ *   or from http://librarymanager/all#CRC32+checksum
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ * ATTENTION! Downloading big files requires of knowledge of
+ * the TinyGSM internals and some modem specifics,
+ * so this is for more experienced developers.
+ *
+ **************************************************************/
+
+// Select your modem:
+#define TINY_GSM_MODEM_SIM800
+// #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_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG96
+// #define TINY_GSM_MODEM_A6
+// #define TINY_GSM_MODEM_A7
+// #define TINY_GSM_MODEM_M590
+// #define TINY_GSM_MODEM_MC60
+// #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, default speed 115200)
+#define SerialMon Serial
+
+// Set serial for AT commands (to the module)
+// Use Hardware Serial on Mega, Leonardo, Micro
+#ifndef __AVR_ATmega328P__
+#define SerialAT Serial1
+
+// or Software Serial on Uno, Nano
+#else
+#include <SoftwareSerial.h>
+SoftwareSerial SerialAT(2, 3);  // RX, TX
+#endif
+
+// Increase RX buffer to capture the entire response
+// Chips without internal buffering (A6/A7, ESP8266, M590)
+// need enough space in the buffer for the entire response
+// else data will be lost (and the http library will fail).
+#if !defined(TINY_GSM_RX_BUFFER)
+#define TINY_GSM_RX_BUFFER 1024
+#endif
+
+// See all AT commands, if wanted
+// #define DUMP_AT_COMMANDS
+
+// Define the serial console for debug prints, if needed
+#define TINY_GSM_DEBUG SerialMon
+// #define LOGGING  // <- Logging is for the HTTP library
+
+// Add a reception delay, if needed.
+// This may be needed for a fast processor at a slow baud rate.
+// #define TINY_GSM_YIELD() { delay(2); }
+
+// Define how you're planning to connect to the internet.
+// This is only needed for this example, not in other code.
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+
+// set GSM PIN, if any
+#define GSM_PIN ""
+
+// Your GPRS credentials, if any
+const char apn[]      = "YourAPN";
+const char gprsUser[] = "";
+const char gprsPass[] = "";
+
+// Your WiFi connection credentials, if applicable
+const char wifiSSID[] = "YourSSID";
+const char wifiPass[] = "YourWiFiPass";
+
+// Server details
+const char server[] = "vsh.pp.ua";
+const int  port     = 80;
+
+#include <TinyGsmClient.h>
+#include <CRC32.h>
+
+// Just in case someone defined the wrong thing..
+#if TINY_GSM_USE_GPRS && not defined TINY_GSM_MODEM_HAS_GPRS
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS false
+#define TINY_GSM_USE_WIFI true
+#endif
+#if TINY_GSM_USE_WIFI && not defined TINY_GSM_MODEM_HAS_WIFI
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+#endif
+
+const char resource[]    = "/TinyGSM/test_1k.bin";
+uint32_t   knownCRC32    = 0x6f50d767;
+uint32_t   knownFileSize = 1024;  // In case server does not send it
+
+#ifdef DUMP_AT_COMMANDS
+#include <StreamDebugger.h>
+StreamDebugger debugger(SerialAT, SerialMon);
+TinyGsm        modem(debugger);
+#else
+TinyGsm        modem(SerialAT);
+#endif
+
+TinyGsmClient client(modem);
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // !!!!!!!!!!!
+  // Set your reset, enable, power pins here
+  // !!!!!!!!!!!
+
+  SerialMon.println("Wait...");
+
+  // Set GSM module baud rate
+  SerialAT.begin(115200);
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println("Initializing modem...");
+  modem.restart();
+  // modem.init();
+
+  String modemInfo = modem.getModemInfo();
+  SerialMon.print("Modem Info: ");
+  SerialMon.println(modemInfo);
+
+#if TINY_GSM_USE_GPRS
+  // Unlock your SIM card with a PIN if needed
+  if (GSM_PIN && modem.getSimStatus() != 3) { modem.simUnlock(GSM_PIN); }
+#endif
+}
+
+void printPercent(uint32_t readLength, uint32_t contentLength) {
+  // If we know the total length
+  if (contentLength != (uint32_t)-1) {
+    SerialMon.print("\r ");
+    SerialMon.print((100.0 * readLength) / contentLength);
+    SerialMon.print('%');
+  } else {
+    SerialMon.println(readLength);
+  }
+}
+
+void loop() {
+#if TINY_GSM_USE_WIFI
+  // Wifi connection parameters must be set before waiting for the network
+  SerialMon.print(F("Setting SSID/password..."));
+  if (!modem.networkConnect(wifiSSID, wifiPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+#endif
+
+#if TINY_GSM_USE_GPRS && defined TINY_GSM_MODEM_XBEE
+  // The XBee must run the gprsConnect function BEFORE waiting for network!
+  modem.gprsConnect(apn, gprsUser, gprsPass);
+#endif
+
+  SerialMon.print("Waiting for network...");
+  if (!modem.waitForNetwork()) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isNetworkConnected()) { SerialMon.println("Network connected"); }
+
+#if TINY_GSM_USE_GPRS
+  // GPRS connection parameters are usually set after network registration
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(apn);
+  if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isGprsConnected()) { SerialMon.println("GPRS connected"); }
+#endif
+
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(server);
+  if (!client.connect(server, port)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  // Make a HTTP GET request:
+  client.print(String("GET ") + resource + " HTTP/1.0\r\n");
+  client.print(String("Host: ") + server + "\r\n");
+  client.print("Connection: close\r\n\r\n");
+
+  // Let's see what the entire elapsed time is, from after we send the request.
+  uint32_t timeElapsed = millis();
+
+  SerialMon.println(F("Waiting for response header"));
+
+  // While we are still looking for the end of the header (i.e. empty line
+  // FOLLOWED by a newline), continue to read data into the buffer, parsing each
+  // line (data FOLLOWED by a newline). If it takes too long to get data from
+  // the client, we need to exit.
+
+  const uint32_t clientReadTimeout   = 5000;
+  uint32_t       clientReadStartTime = millis();
+  String         headerBuffer;
+  bool           finishedHeader = false;
+  uint32_t       contentLength  = 0;
+
+  while (!finishedHeader) {
+    int nlPos;
+
+    if (client.available()) {
+      clientReadStartTime = millis();
+      while (client.available()) {
+        char c = client.read();
+        headerBuffer += c;
+
+        // Uncomment the lines below to see the data coming into the buffer
+        // if (c < 16)
+        //   SerialMon.print('0');
+        // SerialMon.print(c, HEX);
+        // SerialMon.print(' ');
+        // if (isprint(c))
+        //   SerialMon.print(reinterpret_cast<char> c);
+        // else
+        //   SerialMon.print('*');
+        // SerialMon.print(' ');
+
+        // Let's exit and process if we find a new line
+        if (headerBuffer.indexOf(F("\r\n")) >= 0) break;
+      }
+    } else {
+      if (millis() - clientReadStartTime > clientReadTimeout) {
+        // Time-out waiting for data from client
+        SerialMon.println(F(">>> Client Timeout !"));
+        break;
+      }
+    }
+
+    // See if we have a new line.
+    nlPos = headerBuffer.indexOf(F("\r\n"));
+
+    if (nlPos > 0) {
+      headerBuffer.toLowerCase();
+      // Check if line contains content-length
+      if (headerBuffer.startsWith(F("content-length:"))) {
+        contentLength =
+            headerBuffer.substring(headerBuffer.indexOf(':') + 1).toInt();
+        // SerialMon.print(F("Got Content Length: "));  // uncomment for
+        // SerialMon.println(contentLength);            // confirmation
+      }
+
+      headerBuffer.remove(0, nlPos + 2);  // remove the line
+    } else if (nlPos == 0) {
+      // if the new line is empty (i.e. "\r\n" is at the beginning of the line),
+      // we are done with the header.
+      finishedHeader = true;
+    }
+  }
+
+  // The two cases which are not managed properly are as follows:
+  // 1. The client doesn't provide data quickly enough to keep up with this
+  // loop.
+  // 2. If the client data is segmented in the middle of the 'Content-Length: '
+  // header,
+  //    then that header may be missed/damaged.
+  //
+
+  uint32_t readLength = 0;
+  CRC32    crc;
+
+  if (finishedHeader && contentLength == knownFileSize) {
+    SerialMon.println(F("Reading response data"));
+    clientReadStartTime = millis();
+
+    printPercent(readLength, contentLength);
+    while (readLength < contentLength && client.connected() &&
+           millis() - clientReadStartTime < clientReadTimeout) {
+      while (client.available()) {
+        uint8_t c = client.read();
+        // SerialMon.print(reinterpret_cast<char>c);  // Uncomment this to show
+        // data
+        crc.update(c);
+        readLength++;
+        if (readLength % (contentLength / 13) == 0) {
+          printPercent(readLength, contentLength);
+        }
+        clientReadStartTime = millis();
+      }
+    }
+    printPercent(readLength, contentLength);
+  }
+
+  timeElapsed = millis() - timeElapsed;
+  SerialMon.println();
+
+  // Shutdown
+
+  client.stop();
+  SerialMon.println(F("Server disconnected"));
+
+#if TINY_GSM_USE_WIFI
+  modem.networkDisconnect();
+  SerialMon.println(F("WiFi disconnected"));
+#endif
+#if TINY_GSM_USE_GPRS
+  modem.gprsDisconnect();
+  SerialMon.println(F("GPRS disconnected"));
+#endif
+
+  float duration = float(timeElapsed) / 1000;
+
+  SerialMon.println();
+  SerialMon.print("Content-Length: ");
+  SerialMon.println(contentLength);
+  SerialMon.print("Actually read:  ");
+  SerialMon.println(readLength);
+  SerialMon.print("Calc. CRC32:    0x");
+  SerialMon.println(crc.finalize(), HEX);
+  SerialMon.print("Known CRC32:    0x");
+  SerialMon.println(knownCRC32, HEX);
+  SerialMon.print("Duration:       ");
+  SerialMon.print(duration);
+  SerialMon.println("s");
+
+  // Do nothing forevermore
+  while (true) { delay(1000); }
+}

.pio/libdeps/esp32dev/TinyGSM/examples/HttpClient/HttpClient.ino

@@ -0,0 +1,261 @@
+/**************************************************************
+ *
+ * This sketch connects to a website and downloads a page.
+ * It can be used to perform HTTP/RESTful API calls.
+ *
+ * For this example, you need to install ArduinoHttpClient library:
+ *   https://github.com/arduino-libraries/ArduinoHttpClient
+ *   or from http://librarymanager/all#ArduinoHttpClient
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ * For more HTTP API examples, see ArduinoHttpClient library
+ *
+ * NOTE: This example may NOT work with the XBee because the
+ * HttpClient library does not empty to serial buffer fast enough
+ * and the buffer overflow causes the HttpClient library to stall.
+ * Boards with faster processors may work, 8MHz boards will not.
+ **************************************************************/
+
+// Select your modem:
+#define TINY_GSM_MODEM_SIM800
+// #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_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG96
+// #define TINY_GSM_MODEM_A6
+// #define TINY_GSM_MODEM_A7
+// #define TINY_GSM_MODEM_M590
+// #define TINY_GSM_MODEM_MC60
+// #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, default speed 115200)
+#define SerialMon Serial
+
+// Set serial for AT commands (to the module)
+// Use Hardware Serial on Mega, Leonardo, Micro
+#ifndef __AVR_ATmega328P__
+#define SerialAT Serial1
+
+// or Software Serial on Uno, Nano
+#else
+#include <SoftwareSerial.h>
+SoftwareSerial SerialAT(2, 3);  // RX, TX
+#endif
+
+// Increase RX buffer to capture the entire response
+// Chips without internal buffering (A6/A7, ESP8266, M590)
+// need enough space in the buffer for the entire response
+// else data will be lost (and the http library will fail).
+#if !defined(TINY_GSM_RX_BUFFER)
+#define TINY_GSM_RX_BUFFER 650
+#endif
+
+// See all AT commands, if wanted
+// #define DUMP_AT_COMMANDS
+
+// Define the serial console for debug prints, if needed
+#define TINY_GSM_DEBUG SerialMon
+// #define LOGGING  // <- Logging is for the HTTP library
+
+// Range to attempt to autobaud
+// NOTE:  DO NOT AUTOBAUD in production code.  Once you've established
+// communication, set a fixed baud rate using modem.setBaud(#).
+#define GSM_AUTOBAUD_MIN 9600
+#define GSM_AUTOBAUD_MAX 115200
+
+// Add a reception delay, if needed.
+// This may be needed for a fast processor at a slow baud rate.
+// #define TINY_GSM_YIELD() { delay(2); }
+
+// Define how you're planning to connect to the internet
+// These defines are only for this example; they are not needed in other code.
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+
+// set GSM PIN, if any
+#define GSM_PIN ""
+
+// Your GPRS credentials, if any
+const char apn[]      = "YourAPN";
+const char gprsUser[] = "";
+const char gprsPass[] = "";
+
+// Your WiFi connection credentials, if applicable
+const char wifiSSID[] = "YourSSID";
+const char wifiPass[] = "YourWiFiPass";
+
+// Server details
+const char server[]   = "vsh.pp.ua";
+const char resource[] = "/TinyGSM/logo.txt";
+const int  port       = 80;
+
+#include <TinyGsmClient.h>
+#include <ArduinoHttpClient.h>
+
+// Just in case someone defined the wrong thing..
+#if TINY_GSM_USE_GPRS && not defined TINY_GSM_MODEM_HAS_GPRS
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS false
+#define TINY_GSM_USE_WIFI true
+#endif
+#if TINY_GSM_USE_WIFI && not defined TINY_GSM_MODEM_HAS_WIFI
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+#endif
+
+#ifdef DUMP_AT_COMMANDS
+#include <StreamDebugger.h>
+StreamDebugger debugger(SerialAT, SerialMon);
+TinyGsm        modem(debugger);
+#else
+TinyGsm        modem(SerialAT);
+#endif
+
+TinyGsmClient client(modem);
+HttpClient    http(client, server, port);
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // !!!!!!!!!!!
+  // Set your reset, enable, power pins here
+  // !!!!!!!!!!!
+
+  SerialMon.println("Wait...");
+
+  // Set GSM module baud rate
+  TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
+  // SerialAT.begin(9600);
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println("Initializing modem...");
+  modem.restart();
+  // modem.init();
+
+  String modemInfo = modem.getModemInfo();
+  SerialMon.print("Modem Info: ");
+  SerialMon.println(modemInfo);
+
+#if TINY_GSM_USE_GPRS
+  // Unlock your SIM card with a PIN if needed
+  if (GSM_PIN && modem.getSimStatus() != 3) { modem.simUnlock(GSM_PIN); }
+#endif
+}
+
+void loop() {
+#if TINY_GSM_USE_WIFI
+  // Wifi connection parameters must be set before waiting for the network
+  SerialMon.print(F("Setting SSID/password..."));
+  if (!modem.networkConnect(wifiSSID, wifiPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+#endif
+
+#if TINY_GSM_USE_GPRS && defined TINY_GSM_MODEM_XBEE
+  // The XBee must run the gprsConnect function BEFORE waiting for network!
+  modem.gprsConnect(apn, gprsUser, gprsPass);
+#endif
+
+  SerialMon.print("Waiting for network...");
+  if (!modem.waitForNetwork()) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isNetworkConnected()) { SerialMon.println("Network connected"); }
+
+#if TINY_GSM_USE_GPRS
+  // GPRS connection parameters are usually set after network registration
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(apn);
+  if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isGprsConnected()) { SerialMon.println("GPRS connected"); }
+#endif
+
+  SerialMon.print(F("Performing HTTP GET request... "));
+  int err = http.get(resource);
+  if (err != 0) {
+    SerialMon.println(F("failed to connect"));
+    delay(10000);
+    return;
+  }
+
+  int status = http.responseStatusCode();
+  SerialMon.print(F("Response status code: "));
+  SerialMon.println(status);
+  if (!status) {
+    delay(10000);
+    return;
+  }
+
+  SerialMon.println(F("Response Headers:"));
+  while (http.headerAvailable()) {
+    String headerName  = http.readHeaderName();
+    String headerValue = http.readHeaderValue();
+    SerialMon.println("    " + headerName + " : " + headerValue);
+  }
+
+  int length = http.contentLength();
+  if (length >= 0) {
+    SerialMon.print(F("Content length is: "));
+    SerialMon.println(length);
+  }
+  if (http.isResponseChunked()) {
+    SerialMon.println(F("The response is chunked"));
+  }
+
+  String body = http.responseBody();
+  SerialMon.println(F("Response:"));
+  SerialMon.println(body);
+
+  SerialMon.print(F("Body length is: "));
+  SerialMon.println(body.length());
+
+  // Shutdown
+
+  http.stop();
+  SerialMon.println(F("Server disconnected"));
+
+#if TINY_GSM_USE_WIFI
+  modem.networkDisconnect();
+  SerialMon.println(F("WiFi disconnected"));
+#endif
+#if TINY_GSM_USE_GPRS
+  modem.gprsDisconnect();
+  SerialMon.println(F("GPRS disconnected"));
+#endif
+
+  // Do nothing forevermore
+  while (true) { delay(1000); }
+}

.pio/libdeps/esp32dev/TinyGSM/examples/HttpsClient/HttpsClient.ino

@@ -0,0 +1,257 @@
+/**************************************************************
+ *
+ * This sketch connects to a website and downloads a page.
+ * It can be used to perform HTTP/RESTful API calls.
+ *
+ * For this example, you need to install ArduinoHttpClient library:
+ *   https://github.com/arduino-libraries/ArduinoHttpClient
+ *   or from http://librarymanager/all#ArduinoHttpClient
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ * SSL/TLS is not yet supported on the Quectel modems
+ * The A6/A7/A20 and M590 are not capable of SSL/TLS
+ *
+ * For more HTTP API examples, see ArduinoHttpClient library
+ *
+ * NOTE: This example may NOT work with the XBee because the
+ * HttpClient library does not empty to serial buffer fast enough
+ * and the buffer overflow causes the HttpClient library to stall.
+ * Boards with faster processors may work, 8MHz boards will not.
+ **************************************************************/
+
+// Select your modem:
+#define TINY_GSM_MODEM_SIM800
+// #define TINY_GSM_MODEM_SIM808
+// #define TINY_GSM_MODEM_SIM868
+// #define TINY_GSM_MODEM_SIM7000SSL
+// #define TINY_GSM_MODEM_SIM7080
+// #define TINY_GSM_MODEM_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #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, default speed 115200)
+#define SerialMon Serial
+
+// Set serial for AT commands (to the module)
+// Use Hardware Serial on Mega, Leonardo, Micro
+#ifndef __AVR_ATmega328P__
+#define SerialAT Serial1
+
+// or Software Serial on Uno, Nano
+#else
+#include <SoftwareSerial.h>
+SoftwareSerial SerialAT(2, 3);  // RX, TX
+#endif
+
+// Increase RX buffer to capture the entire response
+// Chips without internal buffering (A6/A7, ESP8266, M590)
+// need enough space in the buffer for the entire response
+// else data will be lost (and the http library will fail).
+#if !defined(TINY_GSM_RX_BUFFER)
+#define TINY_GSM_RX_BUFFER 650
+#endif
+
+// See all AT commands, if wanted
+// #define DUMP_AT_COMMANDS
+
+// Define the serial console for debug prints, if needed
+#define TINY_GSM_DEBUG SerialMon
+// #define LOGGING  // <- Logging is for the HTTP library
+
+// Range to attempt to autobaud
+// NOTE:  DO NOT AUTOBAUD in production code.  Once you've established
+// communication, set a fixed baud rate using modem.setBaud(#).
+#define GSM_AUTOBAUD_MIN 9600
+#define GSM_AUTOBAUD_MAX 115200
+
+// Add a reception delay, if needed.
+// This may be needed for a fast processor at a slow baud rate.
+// #define TINY_GSM_YIELD() { delay(2); }
+
+// Define how you're planning to connect to the internet.
+// This is only needed for this example, not in other code.
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+
+// set GSM PIN, if any
+#define GSM_PIN ""
+
+// flag to force SSL client authentication, if needed
+// #define TINY_GSM_SSL_CLIENT_AUTHENTICATION
+
+// Your GPRS credentials, if any
+const char apn[]      = "YourAPN";
+const char gprsUser[] = "";
+const char gprsPass[] = "";
+
+// Your WiFi connection credentials, if applicable
+const char wifiSSID[] = "YourSSID";
+const char wifiPass[] = "YourWiFiPass";
+
+// Server details
+const char server[]   = "vsh.pp.ua";
+const char resource[] = "/TinyGSM/logo.txt";
+const int  port       = 443;
+
+#include <TinyGsmClient.h>
+#include <ArduinoHttpClient.h>
+
+// Just in case someone defined the wrong thing..
+#if TINY_GSM_USE_GPRS && not defined TINY_GSM_MODEM_HAS_GPRS
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS false
+#define TINY_GSM_USE_WIFI true
+#endif
+#if TINY_GSM_USE_WIFI && not defined TINY_GSM_MODEM_HAS_WIFI
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+#endif
+
+#ifdef DUMP_AT_COMMANDS
+#include <StreamDebugger.h>
+StreamDebugger debugger(SerialAT, SerialMon);
+TinyGsm        modem(debugger);
+#else
+TinyGsm        modem(SerialAT);
+#endif
+
+TinyGsmClientSecure client(modem);
+HttpClient          http(client, server, port);
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // !!!!!!!!!!!
+  // Set your reset, enable, power pins here
+  // !!!!!!!!!!!
+
+  SerialMon.println("Wait...");
+
+  // Set GSM module baud rate
+  TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
+  // SerialAT.begin(9600);
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println("Initializing modem...");
+  modem.restart();
+  // modem.init();
+
+  String modemInfo = modem.getModemInfo();
+  SerialMon.print("Modem Info: ");
+  SerialMon.println(modemInfo);
+
+#if TINY_GSM_USE_GPRS
+  // Unlock your SIM card with a PIN if needed
+  if (GSM_PIN && modem.getSimStatus() != 3) { modem.simUnlock(GSM_PIN); }
+#endif
+}
+
+void loop() {
+#if TINY_GSM_USE_WIFI
+  // Wifi connection parameters must be set before waiting for the network
+  SerialMon.print(F("Setting SSID/password..."));
+  if (!modem.networkConnect(wifiSSID, wifiPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+#endif
+
+#if TINY_GSM_USE_GPRS && defined TINY_GSM_MODEM_XBEE
+  // The XBee must run the gprsConnect function BEFORE waiting for network!
+  modem.gprsConnect(apn, gprsUser, gprsPass);
+#endif
+
+  SerialMon.print("Waiting for network...");
+  if (!modem.waitForNetwork()) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isNetworkConnected()) { SerialMon.println("Network connected"); }
+
+#if TINY_GSM_USE_GPRS
+  // GPRS connection parameters are usually set after network registration
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(apn);
+  if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isGprsConnected()) { SerialMon.println("GPRS connected"); }
+#endif
+
+  SerialMon.print(F("Performing HTTPS GET request... "));
+  http.connectionKeepAlive();  // Currently, this is needed for HTTPS
+  int err = http.get(resource);
+  if (err != 0) {
+    SerialMon.println(F("failed to connect"));
+    delay(10000);
+    return;
+  }
+
+  int status = http.responseStatusCode();
+  SerialMon.print(F("Response status code: "));
+  SerialMon.println(status);
+  if (!status) {
+    delay(10000);
+    return;
+  }
+
+  SerialMon.println(F("Response Headers:"));
+  while (http.headerAvailable()) {
+    String headerName  = http.readHeaderName();
+    String headerValue = http.readHeaderValue();
+    SerialMon.println("    " + headerName + " : " + headerValue);
+  }
+
+  int length = http.contentLength();
+  if (length >= 0) {
+    SerialMon.print(F("Content length is: "));
+    SerialMon.println(length);
+  }
+  if (http.isResponseChunked()) {
+    SerialMon.println(F("The response is chunked"));
+  }
+
+  String body = http.responseBody();
+  SerialMon.println(F("Response:"));
+  SerialMon.println(body);
+
+  SerialMon.print(F("Body length is: "));
+  SerialMon.println(body.length());
+
+  // Shutdown
+
+  http.stop();
+  SerialMon.println(F("Server disconnected"));
+
+#if TINY_GSM_USE_WIFI
+  modem.networkDisconnect();
+  SerialMon.println(F("WiFi disconnected"));
+#endif
+#if TINY_GSM_USE_GPRS
+  modem.gprsDisconnect();
+  SerialMon.println(F("GPRS disconnected"));
+#endif
+
+  // Do nothing forevermore
+  while (true) { delay(1000); }
+}

.pio/libdeps/esp32dev/TinyGSM/examples/MqttClient/MqttClient.ino

@@ -0,0 +1,290 @@
+/**************************************************************
+ *
+ * For this example, you need to install PubSubClient library:
+ *   https://github.com/knolleary/pubsubclient
+ *   or from http://librarymanager/all#PubSubClient
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ * For more MQTT examples, see PubSubClient library
+ *
+ **************************************************************
+ * This example connects to HiveMQ's showcase broker.
+ *
+ * You can quickly test sending and receiving messages from the HiveMQ webclient
+ * available at http://www.hivemq.com/demos/websocket-client/.
+ *
+ * Subscribe to the topic GsmClientTest/ledStatus
+ * Publish "toggle" to the topic GsmClientTest/led and the LED on your board
+ * should toggle and you should see a new message published to
+ * GsmClientTest/ledStatus with the newest LED status.
+ *
+ **************************************************************/
+
+// Select your modem:
+#define TINY_GSM_MODEM_SIM800
+// #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_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG96
+// #define TINY_GSM_MODEM_A6
+// #define TINY_GSM_MODEM_A7
+// #define TINY_GSM_MODEM_M590
+// #define TINY_GSM_MODEM_MC60
+// #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, default speed 115200)
+#define SerialMon Serial
+
+// Set serial for AT commands (to the module)
+// Use Hardware Serial on Mega, Leonardo, Micro
+#ifndef __AVR_ATmega328P__
+#define SerialAT Serial1
+
+// or Software Serial on Uno, Nano
+#else
+#include <SoftwareSerial.h>
+SoftwareSerial SerialAT(2, 3);  // RX, TX
+#endif
+
+// See all AT commands, if wanted
+// #define DUMP_AT_COMMANDS
+
+// Define the serial console for debug prints, if needed
+#define TINY_GSM_DEBUG SerialMon
+
+// Range to attempt to autobaud
+// NOTE:  DO NOT AUTOBAUD in production code.  Once you've established
+// communication, set a fixed baud rate using modem.setBaud(#).
+#define GSM_AUTOBAUD_MIN 9600
+#define GSM_AUTOBAUD_MAX 115200
+
+// Add a reception delay, if needed.
+// This may be needed for a fast processor at a slow baud rate.
+// #define TINY_GSM_YIELD() { delay(2); }
+
+// Define how you're planning to connect to the internet.
+// This is only needed for this example, not in other code.
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+
+// set GSM PIN, if any
+#define GSM_PIN ""
+
+// Your GPRS credentials, if any
+const char apn[]      = "YourAPN";
+const char gprsUser[] = "";
+const char gprsPass[] = "";
+
+// Your WiFi connection credentials, if applicable
+const char wifiSSID[] = "YourSSID";
+const char wifiPass[] = "YourWiFiPass";
+
+// MQTT details
+const char* broker = "broker.hivemq.com";
+
+const char* topicLed       = "GsmClientTest/led";
+const char* topicInit      = "GsmClientTest/init";
+const char* topicLedStatus = "GsmClientTest/ledStatus";
+
+#include <TinyGsmClient.h>
+#include <PubSubClient.h>
+
+// Just in case someone defined the wrong thing..
+#if TINY_GSM_USE_GPRS && not defined TINY_GSM_MODEM_HAS_GPRS
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS false
+#define TINY_GSM_USE_WIFI true
+#endif
+#if TINY_GSM_USE_WIFI && not defined TINY_GSM_MODEM_HAS_WIFI
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+#endif
+
+#ifdef DUMP_AT_COMMANDS
+#include <StreamDebugger.h>
+StreamDebugger debugger(SerialAT, SerialMon);
+TinyGsm        modem(debugger);
+#else
+TinyGsm        modem(SerialAT);
+#endif
+TinyGsmClient client(modem);
+PubSubClient  mqtt(client);
+
+#define LED_PIN 13
+int ledStatus = LOW;
+
+uint32_t lastReconnectAttempt = 0;
+
+void mqttCallback(char* topic, byte* payload, unsigned int len) {
+  SerialMon.print("Message arrived [");
+  SerialMon.print(topic);
+  SerialMon.print("]: ");
+  SerialMon.write(payload, len);
+  SerialMon.println();
+
+  // Only proceed if incoming message's topic matches
+  if (String(topic) == topicLed) {
+    ledStatus = !ledStatus;
+    digitalWrite(LED_PIN, ledStatus);
+    mqtt.publish(topicLedStatus, ledStatus ? "1" : "0");
+  }
+}
+
+boolean mqttConnect() {
+  SerialMon.print("Connecting to ");
+  SerialMon.print(broker);
+
+  // Connect to MQTT Broker
+  boolean status = mqtt.connect("GsmClientTest");
+
+  // Or, if you want to authenticate MQTT:
+  // boolean status = mqtt.connect("GsmClientName", "mqtt_user", "mqtt_pass");
+
+  if (status == false) {
+    SerialMon.println(" fail");
+    return false;
+  }
+  SerialMon.println(" success");
+  mqtt.publish(topicInit, "GsmClientTest started");
+  mqtt.subscribe(topicLed);
+  return mqtt.connected();
+}
+
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  pinMode(LED_PIN, OUTPUT);
+
+  // !!!!!!!!!!!
+  // Set your reset, enable, power pins here
+  // !!!!!!!!!!!
+
+  SerialMon.println("Wait...");
+
+  // Set GSM module baud rate
+  TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
+  // SerialAT.begin(9600);
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println("Initializing modem...");
+  modem.restart();
+  // modem.init();
+
+  String modemInfo = modem.getModemInfo();
+  SerialMon.print("Modem Info: ");
+  SerialMon.println(modemInfo);
+
+#if TINY_GSM_USE_GPRS
+  // Unlock your SIM card with a PIN if needed
+  if (GSM_PIN && modem.getSimStatus() != 3) { modem.simUnlock(GSM_PIN); }
+#endif
+
+#if TINY_GSM_USE_WIFI
+  // Wifi connection parameters must be set before waiting for the network
+  SerialMon.print(F("Setting SSID/password..."));
+  if (!modem.networkConnect(wifiSSID, wifiPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+#endif
+
+#if TINY_GSM_USE_GPRS && defined TINY_GSM_MODEM_XBEE
+  // The XBee must run the gprsConnect function BEFORE waiting for network!
+  modem.gprsConnect(apn, gprsUser, gprsPass);
+#endif
+
+  SerialMon.print("Waiting for network...");
+  if (!modem.waitForNetwork()) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isNetworkConnected()) { SerialMon.println("Network connected"); }
+
+#if TINY_GSM_USE_GPRS
+  // GPRS connection parameters are usually set after network registration
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(apn);
+  if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isGprsConnected()) { SerialMon.println("GPRS connected"); }
+#endif
+
+  // MQTT Broker setup
+  mqtt.setServer(broker, 1883);
+  mqtt.setCallback(mqttCallback);
+}
+
+void loop() {
+  // Make sure we're still registered on the network
+  if (!modem.isNetworkConnected()) {
+    SerialMon.println("Network disconnected");
+    if (!modem.waitForNetwork(180000L, true)) {
+      SerialMon.println(" fail");
+      delay(10000);
+      return;
+    }
+    if (modem.isNetworkConnected()) {
+      SerialMon.println("Network re-connected");
+    }
+
+#if TINY_GSM_USE_GPRS
+    // and make sure GPRS/EPS is still connected
+    if (!modem.isGprsConnected()) {
+      SerialMon.println("GPRS disconnected!");
+      SerialMon.print(F("Connecting to "));
+      SerialMon.print(apn);
+      if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
+        SerialMon.println(" fail");
+        delay(10000);
+        return;
+      }
+      if (modem.isGprsConnected()) { SerialMon.println("GPRS reconnected"); }
+    }
+#endif
+  }
+
+  if (!mqtt.connected()) {
+    SerialMon.println("=== MQTT NOT CONNECTED ===");
+    // Reconnect every 10 seconds
+    uint32_t t = millis();
+    if (t - lastReconnectAttempt > 10000L) {
+      lastReconnectAttempt = t;
+      if (mqttConnect()) { lastReconnectAttempt = 0; }
+    }
+    delay(100);
+    return;
+  }
+
+  mqtt.loop();
+}

.pio/libdeps/esp32dev/TinyGSM/examples/WebClient/WebClient.ino

@@ -0,0 +1,244 @@
+/**************************************************************
+ *
+ * This sketch connects to a website and downloads a page.
+ * It can be used to perform HTTP/RESTful API calls.
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ **************************************************************/
+
+// Select your modem:
+#define TINY_GSM_MODEM_SIM800
+// #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_UBLOX
+// #define TINY_GSM_MODEM_SARAR4
+// #define TINY_GSM_MODEM_M95
+// #define TINY_GSM_MODEM_BG96
+// #define TINY_GSM_MODEM_A6
+// #define TINY_GSM_MODEM_A7
+// #define TINY_GSM_MODEM_M590
+// #define TINY_GSM_MODEM_MC60
+// #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, default speed 115200)
+#define SerialMon Serial
+
+// Set serial for AT commands (to the module)
+// Use Hardware Serial on Mega, Leonardo, Micro
+#ifndef __AVR_ATmega328P__
+#define SerialAT Serial1
+
+// or Software Serial on Uno, Nano
+#else
+#include <SoftwareSerial.h>
+SoftwareSerial SerialAT(2, 3);  // RX, TX
+#endif
+
+// Increase RX buffer to capture the entire response
+// Chips without internal buffering (A6/A7, ESP8266, M590)
+// need enough space in the buffer for the entire response
+// else data will be lost (and the http library will fail).
+#if !defined(TINY_GSM_RX_BUFFER)
+#define TINY_GSM_RX_BUFFER 650
+#endif
+
+// See all AT commands, if wanted
+// #define DUMP_AT_COMMANDS
+
+// Define the serial console for debug prints, if needed
+#define TINY_GSM_DEBUG SerialMon
+
+// Range to attempt to autobaud
+// NOTE:  DO NOT AUTOBAUD in production code.  Once you've established
+// communication, set a fixed baud rate using modem.setBaud(#).
+#define GSM_AUTOBAUD_MIN 9600
+#define GSM_AUTOBAUD_MAX 115200
+
+// Add a reception delay, if needed.
+// This may be needed for a fast processor at a slow baud rate.
+// #define TINY_GSM_YIELD() { delay(2); }
+
+// Uncomment this if you want to use SSL
+// #define USE_SSL
+
+// Define how you're planning to connect to the internet.
+// This is only needed for this example, not in other code.
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+
+// set GSM PIN, if any
+#define GSM_PIN ""
+
+// Your GPRS credentials, if any
+const char apn[]      = "YourAPN";
+const char gprsUser[] = "";
+const char gprsPass[] = "";
+
+// Your WiFi connection credentials, if applicable
+const char wifiSSID[] = "YourSSID";
+const char wifiPass[] = "YourWiFiPass";
+
+// Server details
+const char server[]   = "vsh.pp.ua";
+const char resource[] = "/TinyGSM/logo.txt";
+
+#include <TinyGsmClient.h>
+
+// Just in case someone defined the wrong thing..
+#if TINY_GSM_USE_GPRS && not defined TINY_GSM_MODEM_HAS_GPRS
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS false
+#define TINY_GSM_USE_WIFI true
+#endif
+#if TINY_GSM_USE_WIFI && not defined TINY_GSM_MODEM_HAS_WIFI
+#undef TINY_GSM_USE_GPRS
+#undef TINY_GSM_USE_WIFI
+#define TINY_GSM_USE_GPRS true
+#define TINY_GSM_USE_WIFI false
+#endif
+
+#ifdef DUMP_AT_COMMANDS
+#include <StreamDebugger.h>
+StreamDebugger debugger(SerialAT, SerialMon);
+TinyGsm        modem(debugger);
+#else
+TinyGsm        modem(SerialAT);
+#endif
+
+#ifdef USE_SSL
+TinyGsmClientSecure client(modem);
+const int           port = 443;
+#else
+TinyGsmClient  client(modem);
+const int      port = 80;
+#endif
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // !!!!!!!!!!!
+  // Set your reset, enable, power pins here
+  // !!!!!!!!!!!
+
+  SerialMon.println("Wait...");
+
+  // Set GSM module baud rate
+  TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
+  // SerialAT.begin(9600);
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println("Initializing modem...");
+  modem.restart();
+  // modem.init();
+
+  String modemInfo = modem.getModemInfo();
+  SerialMon.print("Modem Info: ");
+  SerialMon.println(modemInfo);
+
+#if TINY_GSM_USE_GPRS
+  // Unlock your SIM card with a PIN if needed
+  if (GSM_PIN && modem.getSimStatus() != 3) { modem.simUnlock(GSM_PIN); }
+#endif
+}
+
+void loop() {
+#if TINY_GSM_USE_WIFI
+  // Wifi connection parameters must be set before waiting for the network
+  SerialMon.print(F("Setting SSID/password..."));
+  if (!modem.networkConnect(wifiSSID, wifiPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+#endif
+
+#if TINY_GSM_USE_GPRS && defined TINY_GSM_MODEM_XBEE
+  // The XBee must run the gprsConnect function BEFORE waiting for network!
+  modem.gprsConnect(apn, gprsUser, gprsPass);
+#endif
+
+  SerialMon.print("Waiting for network...");
+  if (!modem.waitForNetwork()) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isNetworkConnected()) { SerialMon.println("Network connected"); }
+
+#if TINY_GSM_USE_GPRS
+  // GPRS connection parameters are usually set after network registration
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(apn);
+  if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  if (modem.isGprsConnected()) { SerialMon.println("GPRS connected"); }
+#endif
+
+  SerialMon.print("Connecting to ");
+  SerialMon.println(server);
+  if (!client.connect(server, port)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  // Make a HTTP GET request:
+  SerialMon.println("Performing HTTP GET request...");
+  client.print(String("GET ") + resource + " HTTP/1.1\r\n");
+  client.print(String("Host: ") + server + "\r\n");
+  client.print("Connection: close\r\n\r\n");
+  client.println();
+
+  uint32_t timeout = millis();
+  while (client.connected() && millis() - timeout < 10000L) {
+    // Print available data
+    while (client.available()) {
+      char c = client.read();
+      SerialMon.print(c);
+      timeout = millis();
+    }
+  }
+  SerialMon.println();
+
+  // Shutdown
+
+  client.stop();
+  SerialMon.println(F("Server disconnected"));
+
+#if TINY_GSM_USE_WIFI
+  modem.networkDisconnect();
+  SerialMon.println(F("WiFi disconnected"));
+#endif
+#if TINY_GSM_USE_GPRS
+  modem.gprsDisconnect();
+  SerialMon.println(F("GPRS disconnected"));
+#endif
+
+  // Do nothing forevermore
+  while (true) { delay(1000); }
+}

.pio/libdeps/esp32dev/TinyGSM/examples/example_dependencies.json

@@ -0,0 +1,41 @@
+[
+  {
+    "name": "PubSubClient",
+    "owner": "knolleary",
+    "library id": "89",
+    "url": "https://github.com/knolleary/pubsubclient.git",
+    "version": "~2.8",
+    "note": "A client library for MQTT messaging.",
+    "authors": ["Nick O'Leary"]
+  },
+  {
+    "name": "Blynk",
+    "owner": "blynkkk",
+    "library id": "415",
+    "url": "https://github.com/blynkkk/blynk-library.git",
+    "version": "~0.6.7",
+    "authors": ["Volodymyr Shymanskyy"],
+    "frameworks": "*",
+    "platforms": "*"
+  },
+  {
+    "name": "AceCRC",
+    "owner": "bxparks",
+    "library id": "1202",
+    "url": "https://github.com/bxparks/AceCRC.git",
+    "version": "~1.0.1",
+    "authors": ["Brian T. Park"],
+    "frameworks": "*",
+    "platforms": "*"
+  },
+  {
+    "name": "StreamDebugger",
+    "owner": "vshymanskyy",
+    "library id": "1286",
+    "url": "https://github.com/vshymanskyy/StreamDebugger.git",
+    "version": "~1.0.1",
+    "authors": ["Volodymyr Shymanskyy"],
+    "frameworks": "*",
+    "platforms": "*"
+  }
+]

.pio/libdeps/esp32dev/TinyGSM/examples/more/Hologram_Dash/Hologram_Dash.ino

@@ -0,0 +1,136 @@
+/**************************************************************
+ *
+ * This sketch connects to a website and downloads a page.
+ * It can be used to perform HTTP/RESTful API calls.
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ **************************************************************/
+
+// Hologram Dash uses UBLOX U2 modems
+#define TINY_GSM_MODEM_UBLOX
+
+// Increase RX buffer if needed
+#if !defined(TINY_GSM_RX_BUFFER)
+#define TINY_GSM_RX_BUFFER 512
+#endif
+
+#include <TinyGsmClient.h>
+
+// Uncomment this if you want to see all AT commands
+// #define DUMP_AT_COMMANDS
+
+// Uncomment this if you want to use SSL
+// #define USE_SSL
+
+// Set serial for debug console (to the Serial Monitor, speed 115200)
+#define SerialMon Serial
+
+// We'll be using SerialSystem in Passthrough mode
+#define SerialAT SerialSystem
+
+// Your GPRS credentials
+// Leave empty, if missing user or pass
+const char apn[]  = "YourAPN";
+const char user[] = "";
+const char pass[] = "";
+
+// Server details
+const char server[] = "vsh.pp.ua";
+const char resource[] = "/TinyGSM/logo.txt";
+
+#ifdef DUMP_AT_COMMANDS
+  #include <StreamDebugger.h>
+  StreamDebugger debugger(SerialAT, SerialMon);
+  TinyGsm mdm(debugger);
+#else
+  TinyGsm mdm(SerialAT);
+#endif
+
+#ifdef USE_SSL
+  TinyGsmClientSecure client(mdm);
+  const int  port = 443;
+#else
+  TinyGsmClient client(mdm);
+  const int  port = 80;
+#endif
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // Set up Passthrough
+  HologramCloud.enterPassthrough();
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println(F("Initializing modem..."));
+  mdm.restart();
+
+  String modemInfo = mdm.getModemInfo();
+  SerialMon.print(F("Modem: "));
+  SerialMon.println(modemInfo);
+
+  // Unlock your SIM card with a PIN
+  //mdm.simUnlock("1234");
+}
+
+void loop() {
+  SerialMon.print(F("Waiting for network..."));
+  if (!mdm.waitForNetwork()) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(apn);
+  if (!mdm.gprsConnect(apn, user, pass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(server);
+  if (!client.connect(server, port)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  // Make a HTTP GET request:
+  client.print(String("GET ") + resource + " HTTP/1.0\r\n");
+  client.print(String("Host: ") + server + "\r\n");
+  client.print("Connection: close\r\n\r\n");
+
+  uint32_t timeout = millis();
+  while (client.connected() && millis() - timeout < 10000L) {
+    // Print available data
+    while (client.available()) {
+      char c = client.read();
+      SerialMon.print(c);
+      timeout = millis();
+    }
+  }
+  SerialMon.println();
+
+  // Shutdown
+
+  client.stop();
+  SerialMon.println(F("Server disconnected"));
+
+  mdm.gprsDisconnect();
+  SerialMon.println(F("GPRS disconnected"));
+
+  // Do nothing forevermore
+  while (true) {
+    delay(1000);
+  }
+}

.pio/libdeps/esp32dev/TinyGSM/examples/more/Industruino/Industruino.ino

@@ -0,0 +1,161 @@
+/**************************************************************
+ *
+ * This sketch connects to a website and downloads a page.
+ * It can be used to perform HTTP/RESTful API calls.
+ *
+ * For this example, you need to install ArduinoHttpClient library:
+ *   https://github.com/arduino-libraries/ArduinoHttpClient
+ *   or from http://librarymanager/all#ArduinoHttpClient
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ * For more HTTP API examples, see ArduinoHttpClient library
+ *
+ **************************************************************/
+
+// Industruino uses SIM800H
+#define TINY_GSM_MODEM_SIM800
+
+// Increase RX buffer if needed
+#if !defined(TINY_GSM_RX_BUFFER)
+#define TINY_GSM_RX_BUFFER 512
+#endif
+
+#include <TinyGsmClient.h>
+#include <ArduinoHttpClient.h>
+
+// Uncomment this if you want to see all AT commands
+// #define DUMP_AT_COMMANDS
+
+// Uncomment this if you want to use SSL
+// #define USE_SSL
+
+// Set serial for debug console (to the Serial Monitor, speed 115200)
+#define SerialMon SerialUSB
+
+// Select Serial1 or Serial depending on your module configuration
+#define SerialAT Serial1
+
+// Your GPRS credentials
+// Leave empty, if missing user or pass
+const char apn[]  = "YourAPN";
+const char user[] = "";
+const char pass[] = "";
+
+// Server details
+const char server[] = "vsh.pp.ua";
+const char resource[] = "/TinyGSM/logo.txt";
+
+#ifdef DUMP_AT_COMMANDS
+  #include <StreamDebugger.h>
+  StreamDebugger debugger(SerialAT, SerialMon);
+  TinyGsm modem(debugger);
+#else
+  TinyGsm modem(SerialAT);
+#endif
+
+#ifdef USE_SSL
+  TinyGsmClientSecure client(modem);
+  HttpClient http(client, server, 443);
+#else
+  TinyGsmClient client(modem);
+  HttpClient http(client, server, 80);
+#endif
+
+void setup() {
+  // Turn on modem with 1 second pulse on D6
+  pinMode(6, OUTPUT);
+  digitalWrite(6, HIGH);
+  delay(1000);
+  digitalWrite(6, LOW);
+
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // Set GSM module baud rate
+  SerialAT.begin(115200);
+  delay(6000);
+
+  // Restart takes quite some time
+  // To skip it, call init() instead of restart()
+  SerialMon.println(F("Initializing modem..."));
+  modem.restart();
+
+  String modemInfo = modem.getModemInfo();
+  SerialMon.print(F("Modem: "));
+  SerialMon.println(modemInfo);
+
+  // Unlock your SIM card with a PIN
+  //modem.simUnlock("1234");
+}
+
+void loop() {
+  SerialMon.print(F("Waiting for network..."));
+  if (!modem.waitForNetwork()) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  SerialMon.print(F("Connecting to "));
+  SerialMon.print(apn);
+  if (!modem.gprsConnect(apn, user, pass)) {
+    SerialMon.println(" fail");
+    delay(10000);
+    return;
+  }
+  SerialMon.println(" success");
+
+  SerialMon.print(F("Performing HTTP GET request... "));
+  int err = http.get(resource);
+  if (err != 0) {
+    SerialMon.println(F("failed to connect"));
+    delay(10000);
+    return;
+  }
+
+  int status = http.responseStatusCode();
+  SerialMon.println(status);
+  if (!status) {
+    delay(10000);
+    return;
+  }
+
+  while (http.headerAvailable()) {
+    String headerName = http.readHeaderName();
+    String headerValue = http.readHeaderValue();
+    //SerialMon.println(headerName + " : " + headerValue);
+  }
+
+  int length = http.contentLength();
+  if (length >= 0) {
+    SerialMon.print(F("Content length is: "));
+    SerialMon.println(length);
+  }
+  if (http.isResponseChunked()) {
+    SerialMon.println(F("The response is chunked"));
+  }
+
+  String body = http.responseBody();
+  SerialMon.println(F("Response:"));
+  SerialMon.println(body);
+
+  SerialMon.print(F("Body length is: "));
+  SerialMon.println(body.length());
+
+  // Shutdown
+
+  http.stop();
+  SerialMon.println(F("Server disconnected"));
+
+  modem.gprsDisconnect();
+  SerialMon.println(F("GPRS disconnected"));
+
+  // Do nothing forevermore
+  while (true) {
+    delay(1000);
+  }
+}

.pio/libdeps/esp32dev/TinyGSM/examples/more/SIM800_SslSetCert/COMODORSACertificationAuthority.h

@@ -0,0 +1,36 @@
+const char cert[] PROGMEM =
+"-----BEGIN CERTIFICATE-----\n"
+"MIIF2DCCA8CgAwIBAgIQTKr5yttjb+Af907YWwOGnTANBgkqhkiG9w0BAQwFADCB\n"
+"hTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G\n"
+"A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNV\n"
+"BAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMTE5\n"
+"MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgT\n"
+"EkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMR\n"
+"Q09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNh\n"
+"dGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCR\n"
+"6FSS0gpWsawNJN3Fz0RndJkrN6N9I3AAcbxT38T6KhKPS38QVr2fcHK3YX/JSw8X\n"
+"pz3jsARh7v8Rl8f0hj4K+j5c+ZPmNHrZFGvnnLOFoIJ6dq9xkNfs/Q36nGz637CC\n"
+"9BR++b7Epi9Pf5l/tfxnQ3K9DADWietrLNPtj5gcFKt+5eNu/Nio5JIk2kNrYrhV\n"
+"/erBvGy2i/MOjZrkm2xpmfh4SDBF1a3hDTxFYPwyllEnvGfDyi62a+pGx8cgoLEf\n"
+"Zd5ICLqkTqnyg0Y3hOvozIFIQ2dOciqbXL1MGyiKXCJ7tKuY2e7gUYPDCUZObT6Z\n"
+"+pUX2nwzV0E8jVHtC7ZcryxjGt9XyD+86V3Em69FmeKjWiS0uqlWPc9vqv9JWL7w\n"
+"qP/0uK3pN/u6uPQLOvnoQ0IeidiEyxPx2bvhiWC4jChWrBQdnArncevPDt09qZah\n"
+"SL0896+1DSJMwBGB7FY79tOi4lu3sgQiUpWAk2nojkxl8ZEDLXB0AuqLZxUpaVIC\n"
+"u9ffUGpVRr+goyhhf3DQw6KqLCGqR84onAZFdr+CGCe01a60y1Dma/RMhnEw6abf\n"
+"Fobg2P9A3fvQQoh/ozM6LlweQRGBY84YcWsr7KaKtzFcOmpH4MN5WdYgGq/yapiq\n"
+"crxXStJLnbsQ/LBMQeXtHT1eKJ2czL+zUdqnR+WEUwIDAQABo0IwQDAdBgNVHQ4E\n"
+"FgQUu69+Aj36pvE8hI6t7jiY7NkyMtQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB\n"
+"/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAArx1UaEt65Ru2yyTUEUAJNMnMvl\n"
+"wFTPoCWOAvn9sKIN9SCYPBMtrFaisNZ+EZLpLrqeLppysb0ZRGxhNaKatBYSaVqM\n"
+"4dc+pBroLwP0rmEdEBsqpIt6xf4FpuHA1sj+nq6PK7o9mfjYcwlYRm6mnPTXJ9OV\n"
+"2jeDchzTc+CiR5kDOF3VSXkAKRzH7JsgHAckaVd4sjn8OoSgtZx8jb8uk2Intzna\n"
+"FxiuvTwJaP+EmzzV1gsD41eeFPfR60/IvYcjt7ZJQ3mFXLrrkguhxuhoqEwWsRqZ\n"
+"CuhTLJK7oQkYdQxlqHvLI7cawiiFwxv/0Cti76R7CZGYZ4wUAc1oBmpjIXUDgIiK\n"
+"boHGhfKppC3n9KUkEEeDys30jXlYsQab5xoq2Z0B15R97QNKyvDb6KkBPvVWmcke\n"
+"jkk9u+UJueBPSZI9FoJAzMxZxuY67RIuaTxslbH9qh17f4a+Hg4yRvv7E491f0yL\n"
+"S0Zj/gA0QHDBw7mh3aZw4gSzQbzpgJHqZJx64SIDqZxubw5lT2yHh17zbqD5daWb\n"
+"QOhTsiedSrnAdyGN/4fy3ryM7xfft0kL0fJuMAsaDk527RH89elWsn2/x20Kk4yl\n"
+"0MC2Hb46TpSi125sC8KKfPog88Tk5c0NqMuRkrF8hey1FGlmDoLnzc7ILaZRfyHB\n"
+"NVOFBkpdn627G190\n"
+"-----END CERTIFICATE-----\n";
+

.pio/libdeps/esp32dev/TinyGSM/examples/more/SIM800_SslSetCert/DSTRootCAX3.der.h

@@ -0,0 +1,74 @@
+const char cert[] PROGMEM =
+{
+  0x30, 0x82, 0x03, 0x4a, 0x30, 0x82, 0x02, 0x32, 0xa0, 0x03, 0x02, 0x01,
+  0x02, 0x02, 0x10, 0x44, 0xaf, 0xb0, 0x80, 0xd6, 0xa3, 0x27, 0xba, 0x89,
+  0x30, 0x39, 0x86, 0x2e, 0xf8, 0x40, 0x6b, 0x30, 0x0d, 0x06, 0x09, 0x2a,
+  0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x3f,
+  0x31, 0x24, 0x30, 0x22, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x1b, 0x44,
+  0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, 0x20, 0x53, 0x69, 0x67, 0x6e, 0x61,
+  0x74, 0x75, 0x72, 0x65, 0x20, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20, 0x43,
+  0x6f, 0x2e, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
+  0x0e, 0x44, 0x53, 0x54, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41,
+  0x20, 0x58, 0x33, 0x30, 0x1e, 0x17, 0x0d, 0x30, 0x30, 0x30, 0x39, 0x33,
+  0x30, 0x32, 0x31, 0x31, 0x32, 0x31, 0x39, 0x5a, 0x17, 0x0d, 0x32, 0x31,
+  0x30, 0x39, 0x33, 0x30, 0x31, 0x34, 0x30, 0x31, 0x31, 0x35, 0x5a, 0x30,
+  0x3f, 0x31, 0x24, 0x30, 0x22, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x1b,
+  0x44, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, 0x20, 0x53, 0x69, 0x67, 0x6e,
+  0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x54, 0x72, 0x75, 0x73, 0x74, 0x20,
+  0x43, 0x6f, 0x2e, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x03,
+  0x13, 0x0e, 0x44, 0x53, 0x54, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43,
+  0x41, 0x20, 0x58, 0x33, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09,
+  0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03,
+  0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
+  0x00, 0xdf, 0xaf, 0xe9, 0x97, 0x50, 0x08, 0x83, 0x57, 0xb4, 0xcc, 0x62,
+  0x65, 0xf6, 0x90, 0x82, 0xec, 0xc7, 0xd3, 0x2c, 0x6b, 0x30, 0xca, 0x5b,
+  0xec, 0xd9, 0xc3, 0x7d, 0xc7, 0x40, 0xc1, 0x18, 0x14, 0x8b, 0xe0, 0xe8,
+  0x33, 0x76, 0x49, 0x2a, 0xe3, 0x3f, 0x21, 0x49, 0x93, 0xac, 0x4e, 0x0e,
+  0xaf, 0x3e, 0x48, 0xcb, 0x65, 0xee, 0xfc, 0xd3, 0x21, 0x0f, 0x65, 0xd2,
+  0x2a, 0xd9, 0x32, 0x8f, 0x8c, 0xe5, 0xf7, 0x77, 0xb0, 0x12, 0x7b, 0xb5,
+  0x95, 0xc0, 0x89, 0xa3, 0xa9, 0xba, 0xed, 0x73, 0x2e, 0x7a, 0x0c, 0x06,
+  0x32, 0x83, 0xa2, 0x7e, 0x8a, 0x14, 0x30, 0xcd, 0x11, 0xa0, 0xe1, 0x2a,
+  0x38, 0xb9, 0x79, 0x0a, 0x31, 0xfd, 0x50, 0xbd, 0x80, 0x65, 0xdf, 0xb7,
+  0x51, 0x63, 0x83, 0xc8, 0xe2, 0x88, 0x61, 0xea, 0x4b, 0x61, 0x81, 0xec,
+  0x52, 0x6b, 0xb9, 0xa2, 0xe2, 0x4b, 0x1a, 0x28, 0x9f, 0x48, 0xa3, 0x9e,
+  0x0c, 0xda, 0x09, 0x8e, 0x3e, 0x17, 0x2e, 0x1e, 0xdd, 0x20, 0xdf, 0x5b,
+  0xc6, 0x2a, 0x8a, 0xab, 0x2e, 0xbd, 0x70, 0xad, 0xc5, 0x0b, 0x1a, 0x25,
+  0x90, 0x74, 0x72, 0xc5, 0x7b, 0x6a, 0xab, 0x34, 0xd6, 0x30, 0x89, 0xff,
+  0xe5, 0x68, 0x13, 0x7b, 0x54, 0x0b, 0xc8, 0xd6, 0xae, 0xec, 0x5a, 0x9c,
+  0x92, 0x1e, 0x3d, 0x64, 0xb3, 0x8c, 0xc6, 0xdf, 0xbf, 0xc9, 0x41, 0x70,
+  0xec, 0x16, 0x72, 0xd5, 0x26, 0xec, 0x38, 0x55, 0x39, 0x43, 0xd0, 0xfc,
+  0xfd, 0x18, 0x5c, 0x40, 0xf1, 0x97, 0xeb, 0xd5, 0x9a, 0x9b, 0x8d, 0x1d,
+  0xba, 0xda, 0x25, 0xb9, 0xc6, 0xd8, 0xdf, 0xc1, 0x15, 0x02, 0x3a, 0xab,
+  0xda, 0x6e, 0xf1, 0x3e, 0x2e, 0xf5, 0x5c, 0x08, 0x9c, 0x3c, 0xd6, 0x83,
+  0x69, 0xe4, 0x10, 0x9b, 0x19, 0x2a, 0xb6, 0x29, 0x57, 0xe3, 0xe5, 0x3d,
+  0x9b, 0x9f, 0xf0, 0x02, 0x5d, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x42,
+  0x30, 0x40, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff,
+  0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0e, 0x06, 0x03, 0x55,
+  0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x06, 0x30,
+  0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xc4, 0xa7,
+  0xb1, 0xa4, 0x7b, 0x2c, 0x71, 0xfa, 0xdb, 0xe1, 0x4b, 0x90, 0x75, 0xff,
+  0xc4, 0x15, 0x60, 0x85, 0x89, 0x10, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86,
+  0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x82, 0x01,
+  0x01, 0x00, 0xa3, 0x1a, 0x2c, 0x9b, 0x17, 0x00, 0x5c, 0xa9, 0x1e, 0xee,
+  0x28, 0x66, 0x37, 0x3a, 0xbf, 0x83, 0xc7, 0x3f, 0x4b, 0xc3, 0x09, 0xa0,
+  0x95, 0x20, 0x5d, 0xe3, 0xd9, 0x59, 0x44, 0xd2, 0x3e, 0x0d, 0x3e, 0xbd,
+  0x8a, 0x4b, 0xa0, 0x74, 0x1f, 0xce, 0x10, 0x82, 0x9c, 0x74, 0x1a, 0x1d,
+  0x7e, 0x98, 0x1a, 0xdd, 0xcb, 0x13, 0x4b, 0xb3, 0x20, 0x44, 0xe4, 0x91,
+  0xe9, 0xcc, 0xfc, 0x7d, 0xa5, 0xdb, 0x6a, 0xe5, 0xfe, 0xe6, 0xfd, 0xe0,
+  0x4e, 0xdd, 0xb7, 0x00, 0x3a, 0xb5, 0x70, 0x49, 0xaf, 0xf2, 0xe5, 0xeb,
+  0x02, 0xf1, 0xd1, 0x02, 0x8b, 0x19, 0xcb, 0x94, 0x3a, 0x5e, 0x48, 0xc4,
+  0x18, 0x1e, 0x58, 0x19, 0x5f, 0x1e, 0x02, 0x5a, 0xf0, 0x0c, 0xf1, 0xb1,
+  0xad, 0xa9, 0xdc, 0x59, 0x86, 0x8b, 0x6e, 0xe9, 0x91, 0xf5, 0x86, 0xca,
+  0xfa, 0xb9, 0x66, 0x33, 0xaa, 0x59, 0x5b, 0xce, 0xe2, 0xa7, 0x16, 0x73,
+  0x47, 0xcb, 0x2b, 0xcc, 0x99, 0xb0, 0x37, 0x48, 0xcf, 0xe3, 0x56, 0x4b,
+  0xf5, 0xcf, 0x0f, 0x0c, 0x72, 0x32, 0x87, 0xc6, 0xf0, 0x44, 0xbb, 0x53,
+  0x72, 0x6d, 0x43, 0xf5, 0x26, 0x48, 0x9a, 0x52, 0x67, 0xb7, 0x58, 0xab,
+  0xfe, 0x67, 0x76, 0x71, 0x78, 0xdb, 0x0d, 0xa2, 0x56, 0x14, 0x13, 0x39,
+  0x24, 0x31, 0x85, 0xa2, 0xa8, 0x02, 0x5a, 0x30, 0x47, 0xe1, 0xdd, 0x50,
+  0x07, 0xbc, 0x02, 0x09, 0x90, 0x00, 0xeb, 0x64, 0x63, 0x60, 0x9b, 0x16,
+  0xbc, 0x88, 0xc9, 0x12, 0xe6, 0xd2, 0x7d, 0x91, 0x8b, 0xf9, 0x3d, 0x32,
+  0x8d, 0x65, 0xb4, 0xe9, 0x7c, 0xb1, 0x57, 0x76, 0xea, 0xc5, 0xb6, 0x28,
+  0x39, 0xbf, 0x15, 0x65, 0x1c, 0xc8, 0xf6, 0x77, 0x96, 0x6a, 0x0a, 0x8d,
+  0x77, 0x0b, 0xd8, 0x91, 0x0b, 0x04, 0x8e, 0x07, 0xdb, 0x29, 0xb6, 0x0a,
+  0xee, 0x9d, 0x82, 0x35, 0x35, 0x10
+};

.pio/libdeps/esp32dev/TinyGSM/examples/more/SIM800_SslSetCert/DSTRootCAX3.h

@@ -0,0 +1,22 @@
+const char cert[] PROGMEM =
+"-----BEGIN CERTIFICATE-----\n"
+"MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/\n"
+"MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT\n"
+"DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow\n"
+"PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD\n"
+"Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB\n"
+"AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O\n"
+"rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq\n"
+"OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b\n"
+"xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw\n"
+"7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD\n"
+"aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV\n"
+"HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG\n"
+"SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69\n"
+"ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr\n"
+"AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz\n"
+"R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5\n"
+"JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo\n"
+"Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ\n"
+"-----END CERTIFICATE-----\n";
+

.pio/libdeps/esp32dev/TinyGSM/examples/more/SIM800_SslSetCert/SIM800_SslSetCert.ino

@@ -0,0 +1,96 @@
+/**************************************************************
+ *
+ * This sketch uploads SSL certificates to the SIM8xx
+ *
+ * TinyGSM Getting Started guide:
+ *   https://tiny.cc/tinygsm-readme
+ *
+ **************************************************************/
+
+// This example is specific to SIM8xx
+#define TINY_GSM_MODEM_SIM800
+
+// Select your certificate:
+#include "DSTRootCAX3.h"
+//#include "DSTRootCAX3.der.h"
+//#include "COMODORSACertificationAuthority.h"
+
+// Select the file you want to write into
+// (the file is stored on the modem)
+#define CERT_FILE "C:\\USER\\CERT.CRT"
+
+#include <TinyGsmClient.h>
+
+// Set serial for debug console (to the Serial Monitor, speed 115200)
+#define SerialMon Serial
+
+// Use Hardware Serial for AT commands
+#define SerialAT Serial1
+
+// Uncomment this if you want to see all AT commands
+// #define DUMP_AT_COMMANDS
+
+
+#ifdef DUMP_AT_COMMANDS
+  #include <StreamDebugger.h>
+  StreamDebugger debugger(SerialAT, SerialMon);
+  TinyGsm modem(debugger);
+#else
+  TinyGsm modem(SerialAT);
+#endif
+
+void setup() {
+  // Set console baud rate
+  SerialMon.begin(115200);
+  delay(10);
+
+  // Set GSM module baud rate
+  SerialAT.begin(115200);
+  delay(6000);
+
+  SerialMon.println(F("Initializing modem..."));
+  modem.init();
+
+  modem.sendAT(GF("+FSCREATE=" CERT_FILE));
+  if (modem.waitResponse() != 1) return;
+
+  const int cert_size = sizeof(cert);
+
+  modem.sendAT(GF("+FSWRITE=" CERT_FILE ",0,"), cert_size, GF(",10"));
+  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.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;
+  const int retCode = modem.stream.readStringUntil('\n').toInt();
+
+
+  SerialMon.println();
+  SerialMon.println();
+  SerialMon.println(F("****************************"));
+  SerialMon.print(F("Setting Certificate: "));
+  SerialMon.println((0 == retCode) ? "OK" : "FAILED");
+  SerialMon.println(F("****************************"));
+}
+
+void loop() {
+  if (SerialAT.available()) {
+    SerialMon.write(SerialAT.read());
+  }
+  if (SerialMon.available()) {
+    SerialAT.write(SerialMon.read());
+  }
+  delay(0);
+}

.pio/libdeps/esp32dev/TinyGSM/keywords.txt

@@ -0,0 +1,29 @@
+#######################################
+# Data types (KEYWORD1)
+#######################################
+TinyGsm	KEYWORD1
+TinyGsmClient	KEYWORD1
+TinyGsmClientSecure	KEYWORD1
+
+SerialAT	KEYWORD1
+SerialMon	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+begin	KEYWORD2
+restart	KEYWORD2
+waitForNetwork	KEYWORD2
+getSimStatus	KEYWORD2
+gprsConnect	KEYWORD2
+gprsDisconnect	KEYWORD2
+isGprsConnected	KEYWORD2
+isNetworkConnected	KEYWORD2
+factoryReset	KEYWORD2
+
+#######################################
+# Literals (LITERAL1)
+#######################################
+DATE_FULL	LITERAL1
+DATE_TIME	LITERAL1
+DATE_DATE	LITERAL1

.pio/libdeps/esp32dev/TinyGSM/library.json

@@ -0,0 +1,32 @@
+{
+  "name": "TinyGSM",
+  "version": "0.11.5",
+  "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",
+      "url": "https://github.com/vshymanskyy",
+      "maintainer": true
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vshymanskyy/TinyGSM.git"
+  },
+  "homepage": "https://github.com/vshymanskyy/TinyGSM",
+  "export": {
+    "include": [
+      "LICENSE",
+      "library.json",
+      "library.properties",
+      "README.md",
+      "keywords.txt",
+      "src/*",
+      "examples/*"
+    ]
+  },
+  "frameworks": ["arduino", "energia", "wiringpi"],
+  "platforms": "*",
+  "headers": "TinyGsmClient.h"
+}

.pio/libdeps/esp32dev/TinyGSM/library.properties

@@ -0,0 +1,10 @@
+name=TinyGSM
+version=0.11.5
+author=Volodymyr Shymanskyy
+maintainer=Volodymyr Shymanskyy
+sentence=A small Arduino library for GPRS modules, that just works.
+paragraph=Includes examples for Blynk, MQTT, File Download, and Web Client. Supports many GSM, LTE, and WiFi modules with AT command interfaces.
+category=Communication
+url=https://github.com/vshymanskyy/TinyGSM
+architectures=*
+includes=TinyGsmClient.h

.pio/libdeps/esp32dev/TinyGSM/src/ArduinoCompat/Client.h

@@ -0,0 +1,47 @@
+/*
+  Client.h - Base class that provides Client
+  Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef client_h
+#define client_h
+#include "Print.h"
+#include "Stream.h"
+#include "ArduinoCompat/IPAddress.h"
+
+class Client : public Stream {
+ public:
+  virtual int     connect(IPAddress ip, uint16_t port)     = 0;
+  virtual int     connect(const char* host, uint16_t port) = 0;
+  virtual size_t  write(uint8_t)                           = 0;
+  virtual size_t  write(const uint8_t* buf, size_t size)   = 0;
+  virtual int     available()                              = 0;
+  virtual int     read()                                   = 0;
+  virtual int     read(uint8_t* buf, size_t size)          = 0;
+  virtual int     peek()                                   = 0;
+  virtual void    flush()                                  = 0;
+  virtual void    stop()                                   = 0;
+  virtual uint8_t connected()                              = 0;
+  virtual         operator bool()                          = 0;
+
+ protected:
+  uint8_t* rawIPAddress(IPAddress& addr) {
+    return addr.raw_address();
+  };
+};
+
+#endif