v1.6.0 to save heap when sending large data

### Releases v1.6.0

1. Support using `CString` to save heap to send `very large data`. Check [request->send(200, textPlainStr, jsonChartDataCharStr); - Without using String Class - to save heap #8](khoih-prog/Portenta_H7_AsyncWebServer#8)
2. Add functions and example `Async_AdvancedWebServer_favicon` to support `favicon.ico`
3. Add multiple examples to demo the new feature
4. Fix issue with slow browsers or network
5. Change license from `MIT` to `GPLv3` to match with original [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer) license

Author: khoih-prog

examples/Async_AdvancedWebServer_MemoryIssues_SendArduinoString/Async_AdvancedWebServer_MemoryIssues_SendArduinoString.ino

@@ -0,0 +1,393 @@
+/****************************************************************************************************************************
+  Async_AdvancedWebServer_MemoryIssues_SendArduinoString.ino - Dead simple AsyncWebServer for STM32 LAN8720 or built-in LAN8742A Ethernet
+  
+  For STM32 with LAN8720 (STM32F4/F7) or built-in LAN8742A Ethernet (Nucleo-144, DISCOVERY, etc)
+  
+  AsyncWebServer_STM32 is a library for the STM32 with LAN8720 or built-in LAN8742A Ethernet WebServer
+  
+  Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer)
+  Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_STM32
+  Licensed under MIT license
+  
+  Copyright (c) 2015, Majenko Technologies
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without modification,
+  are permitted provided that the following conditions are met:
+  
+  Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+  
+  Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+  
+  Neither the name of Majenko Technologies nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************************************************************/
+/*
+   Currently support
+   1) STM32 boards with built-in Ethernet (to use USE_BUILTIN_ETHERNET = true) such as :
+      - Nucleo-144 (F429ZI, F767ZI)
+      - Discovery (STM32F746G-DISCOVERY)
+      - STM32 boards (STM32F/L/H/G/WB/MP1) with 32K+ Flash, with Built-in Ethernet, 
+      - See How To Use Built-in Ethernet at (https://github.com/khoih-prog/EthernetWebServer_STM32/issues/1)
+   2) STM32F/L/H/G/WB/MP1 boards (with 64+K Flash) running ENC28J60 shields (to use USE_BUILTIN_ETHERNET = false)
+   3) STM32F/L/H/G/WB/MP1 boards (with 64+K Flash) running W5x00 shields
+   4) STM32F4 and STM32F7 boards (with 64+K Flash) running LAN8720 shields
+*/
+
+#if !( defined(STM32F0) || defined(STM32F1) || defined(STM32F2) || defined(STM32F3)  ||defined(STM32F4) || defined(STM32F7) || \
+       defined(STM32L0) || defined(STM32L1) || defined(STM32L4) || defined(STM32H7)  ||defined(STM32G0) || defined(STM32G4) || \
+       defined(STM32WB) || defined(STM32MP1) )
+  #error This code is designed to run on STM32F/L/H/G/WB/MP1 platform! Please check your Tools->Board setting.
+#endif
+
+#define _ASYNCWEBSERVER_STM32_LOGLEVEL_       4
+
+#if defined(STM32F0)
+  #warning STM32F0 board selected
+  #define BOARD_TYPE  "STM32F0"
+#elif defined(STM32F1)
+  #warning STM32F1 board selected
+  #define BOARD_TYPE  "STM32F1"
+#elif defined(STM32F2)
+  #warning STM32F2 board selected
+  #define BOARD_TYPE  "STM32F2"
+#elif defined(STM32F3)
+  #warning STM32F3 board selected
+  #define BOARD_TYPE  "STM32F3"
+#elif defined(STM32F4)
+  #warning STM32F4 board selected
+  #define BOARD_TYPE  "STM32F4"
+#elif defined(STM32F7)
+  #warning STM32F7 board selected
+  #define BOARD_TYPE  "STM32F7"
+#elif defined(STM32L0)
+  #warning STM32L0 board selected
+  #define BOARD_TYPE  "STM32L0"
+#elif defined(STM32L1)
+  #warning STM32L1 board selected
+  #define BOARD_TYPE  "STM32L1"
+#elif defined(STM32L4)
+  #warning STM32L4 board selected
+  #define BOARD_TYPE  "STM32L4"
+#elif defined(STM32H7)
+  #warning STM32H7 board selected
+  #define BOARD_TYPE  "STM32H7"
+#elif defined(STM32G0)
+  #warning STM32G0 board selected
+  #define BOARD_TYPE  "STM32G0"
+#elif defined(STM32G4)
+  #warning STM32G4 board selected
+  #define BOARD_TYPE  "STM32G4"
+#elif defined(STM32WB)
+  #warning STM32WB board selected
+  #define BOARD_TYPE  "STM32WB"
+#elif defined(STM32MP1)
+  #warning STM32MP1 board selected
+  #define BOARD_TYPE  "STM32MP1"
+#else
+  #warning STM32 unknown board selected
+  #define BOARD_TYPE  "STM32 Unknown"
+#endif
+
+#ifndef BOARD_NAME
+  #define BOARD_NAME    BOARD_TYPE
+#endif
+
+#define SHIELD_TYPE     "LAN8742A built-in Ethernet"
+
+#include <LwIP.h>
+#include <STM32Ethernet.h>
+#include <AsyncWebServer_STM32.h>
+
+// Enter a MAC address and IP address for your controller below.
+#define NUMBER_OF_MAC      20
+
+byte mac[][NUMBER_OF_MAC] =
+{
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x01 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x02 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x03 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x04 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x05 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x06 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x07 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x08 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x09 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x0A },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x0B },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x0C },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x0D },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x0E },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x0F },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x10 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x11 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x12 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x13 },
+  { 0xDE, 0xAD, 0xBE, 0xEF, 0x32, 0x14 },
+};
+// Select the IP address according to your local network
+IPAddress ip(192, 168, 2, 232);
+
+// In bytes
+#define STRING_SIZE                    40000
+//#define STRING_SIZE                    12000
+
+AsyncWebServer    server(80);
+
+int reqCount = 0;                // number of requests received
+
+const int led = 13;
+
+////////////////////////////////////////////////////
+
+#include <malloc.h>
+
+extern "C" char *sbrk(int i);
+/* Use linker definition */
+extern char _estack;
+extern char _Min_Stack_Size;
+
+void PrintHeapData(String hIn)
+{
+  static char *ramend   = &_estack;
+  static char *minSP    = (char*)(ramend - &_Min_Stack_Size);
+
+  static uint32_t maxUsedHeap = 0;
+
+  char *heapend = (char*)sbrk(0);
+  char * stack_ptr = (char*)__get_MSP();
+
+  struct mallinfo memoryInfoCurrent = mallinfo();
+
+  uint32_t usedHeap = memoryInfoCurrent.uordblks;
+  
+  // Print and update only when larger heap
+  if (usedHeap > maxUsedHeap)
+  {
+    maxUsedHeap = usedHeap;
+  
+    Serial.print("\nHEAP DATA - ");
+    Serial.print(hIn);
+    
+    Serial.print("  Free RAM: ");
+    Serial.print(((stack_ptr < minSP) ? stack_ptr : minSP) - heapend + memoryInfoCurrent.fordblks);
+    Serial.print("  Used heap: ");
+    Serial.println(usedHeap);
+  }
+}
+
+////////////////////////////////////////////////////
+
+#define BUFFER_SIZE         768
+char temp[BUFFER_SIZE];
+
+void handleRoot(AsyncWebServerRequest *request)
+{
+  digitalWrite(led, 1);
+
+  int sec = millis() / 1000;
+  int min = sec / 60;
+  int hr = min / 60;
+  int day = hr / 24;
+
+  snprintf(temp, BUFFER_SIZE - 1,
+           "<html>\
+<head>\
+<meta http-equiv='refresh' content='5'/>\
+<title>AsyncWebServer-%s</title>\
+<style>\
+body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }\
+</style>\
+</head>\
+<body>\
+<h2>AsyncWebServer_STM32!</h2>\
+<h3>running on %s</h3>\
+<p>Uptime: %d d %02d:%02d:%02d</p>\
+<img src=\"/test.svg\" />\
+</body>\
+</html>", BOARD_NAME, BOARD_NAME, day, hr % 24, min % 60, sec % 60);
+
+  request->send(200, "text/html", temp);
+
+  digitalWrite(led, 0);
+}
+
+void handleNotFound(AsyncWebServerRequest *request)
+{
+  digitalWrite(led, 1);
+  String message = "File Not Found\n\n";
+
+  message += "URI: ";
+  message += request->url();
+  message += "\nMethod: ";
+  message += (request->method() == HTTP_GET) ? "GET" : "POST";
+  message += "\nArguments: ";
+  message += request->args();
+  message += "\n";
+
+  for (uint8_t i = 0; i < request->args(); i++)
+  {
+    message += " " + request->argName(i) + ": " + request->arg(i) + "\n";
+  }
+
+  request->send(404, "text/plain", message);
+  digitalWrite(led, 0);
+}
+
+void PrintStringSize(String & out)
+{ 
+  static uint32_t count = 0;
+
+  // Print only when cStr length too large and corrupting memory or every (12 * 5) s
+  if ( (out.length() >= STRING_SIZE) || (++count > 12) )
+  {
+    Serial.print("\nOut String Length=");
+    Serial.println(out.length());
+
+    count = 0;
+  }
+}
+
+void drawGraph(AsyncWebServerRequest *request)
+{
+  String out;
+
+  out.reserve(STRING_SIZE);
+  char temp[80];
+
+  out += "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" width=\"910\" height=\"150\">\n";
+  out += "<rect width=\"910\" height=\"150\" fill=\"rgb(250, 230, 210)\" stroke-width=\"2\" stroke=\"rgb(0, 0, 0)\" />\n";
+  out += "<g stroke=\"blue\">\n";
+  int y = rand() % 130;
+
+  // Won't work if using 5000 because of heap memory
+  //for (int x = 10; x < 5000; x += 10)
+  for (int x = 10; x < 900; x += 10)
+  {
+    int y2 = rand() % 130;
+    sprintf(temp, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" stroke-width=\"2\" />\n", x, 140 - y, x + 10, 140 - y2);
+    out += temp;
+    y = y2;
+  }
+  
+  out += "</g>\n</svg>\n";
+
+  PrintHeapData("Pre Send");
+
+  PrintStringSize(out);
+
+  request->send(200, "image/svg+xml", out);
+
+  PrintHeapData("Post Send");
+}
+
+void setup()
+{
+  pinMode(led, OUTPUT);
+  digitalWrite(led, 0);
+
+  Serial.begin(115200);
+  while (!Serial && millis() < 5000);
+
+  delay(200);
+
+  Serial.print("\nStart Async_AdvancedWebServer_MemoryIssues_SendArduinoString on "); Serial.print(BOARD_NAME);
+  Serial.print(" with "); Serial.println(SHIELD_TYPE);
+  Serial.println(ASYNC_WEBSERVER_STM32_VERSION);
+
+  PrintHeapData("Start =>");
+
+  ///////////////////////////////////
+
+#if (_ASYNCWEBSERVER_STM32_LOGLEVEL_ > 2)
+  Serial.print("STM32 Core version v"); Serial.print(STM32_CORE_VERSION_MAJOR);
+  Serial.print("."); Serial.print(STM32_CORE_VERSION_MINOR); 
+  Serial.print("."); Serial.println(STM32_CORE_VERSION_PATCH);
+#endif
+
+  // start the ethernet connection and the server
+  // Use random mac
+  uint16_t index = millis() % NUMBER_OF_MAC;
+
+  // Use Static IP
+  //Ethernet.begin(mac[index], ip);
+  // Use DHCP dynamic IP and random mac
+  Ethernet.begin(mac[index]);
+
+  ///////////////////////////////////
+ 
+  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request)
+  {
+    handleRoot(request);
+  });
+
+  server.on("/test.svg", HTTP_GET, [](AsyncWebServerRequest * request)
+  {
+    drawGraph(request);
+  });
+
+  server.on("/inline", [](AsyncWebServerRequest * request)
+  {
+    request->send(200, "text/plain", "This works as well");
+  });
+
+  server.onNotFound(handleNotFound);
+
+  server.begin();
+
+  Serial.print(F("HTTP EthernetWebServer is @ IP : "));
+  Serial.println(Ethernet.localIP());
+
+  PrintHeapData("Pre Create Arduino String");
+}
+
+void heartBeatPrint()
+{
+  static int num = 1;
+
+  Serial.print(F("."));
+
+  if (num == 80)
+  {
+    Serial.println();
+    num = 1;
+  }
+  else if (num++ % 10 == 0)
+  {
+    Serial.print(F(" "));
+  }
+}
+
+void check_status()
+{
+  static unsigned long checkstatus_timeout = 0;
+
+#define STATUS_CHECK_INTERVAL     10000L
+
+  // Send status report every STATUS_REPORT_INTERVAL (60) seconds: we don't need to send updates frequently if there is no status change.
+  if ((millis() > checkstatus_timeout) || (checkstatus_timeout == 0))
+  {
+    heartBeatPrint();
+    checkstatus_timeout = millis() + STATUS_CHECK_INTERVAL;
+  }
+}
+
+void loop()
+{
+  check_status();
+}