Table of contents

Important Note from v1.6.0

voidsend(int code,const String& contentType = String(),const String& content = String());

request->send(200, textPlainStr, ArduinoStr);

voidsend(int code,const String& contentType,constchar *content,bool nonCopyingSend =true);// RSMOD

request->send(200, textPlainStr, cStr);

voidsend(int code,const String& contentType,constchar *content,bool nonCopyingSend =true);// RSMOD

request->send(200, textPlainStr, cStr,false);

Why do we need thisAsyncWebServer_Teensy41 library

Features

Why Async is better

Currently supported Boards

Prerequisites

Installation

Use Arduino Library Manager

Manual Install

VS Code & PlatformIO:

Packages' Patches

1. For Teensy boards

Important things to remember

Principles of operation

The Async Web server

Request Life Cycle

Rewrites and how do they work

Handlers and how do they work

Responses and how do they work

Template processing

Request Variables

Common Variables

request->version();// uint8_t: 0 = HTTP/1.0, 1 = HTTP/1.1request->method();// enum:    HTTP_GET, HTTP_POST, HTTP_DELETE, HTTP_PUT, HTTP_PATCH, HTTP_HEAD, HTTP_OPTIONSrequest->url();// String:  URL of the request (not including host, port or GET parameters)request->host();// String:  The requested host (can be used for virtual hosting)request->contentType();// String:  ContentType of the request (not available in Handler::canHandle)request->contentLength();// size_t:  ContentLength of the request (not available in Handler::canHandle)request->multipart();// bool:    True if the request has content type "multipart"

Headers

//List all collected headersint headers = request->headers();int i;for (i=0;i<headers;i++){  AsyncWebHeader* h = request->getHeader(i);  Serial.printf("HEADER[%s]: %s\n", h->name().c_str(), h->value().c_str());}//get specific header by nameif (request->hasHeader("MyHeader")){  AsyncWebHeader* h = request->getHeader("MyHeader");  Serial.printf("MyHeader: %s\n", h->value().c_str());}//List all collected headers (Compatibility)int headers = request->headers();int i;for (i=0;i<headers;i++){  Serial.printf("HEADER[%s]: %s\n", request->headerName(i).c_str(), request->header(i).c_str());}//get specific header by name (Compatibility)if (request->hasHeader("MyHeader")){  Serial.printf("MyHeader: %s\n", request->header("MyHeader").c_str());}

GET, POST and FILE parameters

//List all parametersint params = request->params();for (int i=0;i<params;i++){  AsyncWebParameter* p = request->getParam(i);if (p->isFile())  {//p->isPost() is also true    Serial.printf("FILE[%s]: %s, size: %u\n", p->name().c_str(), p->value().c_str(), p->size());  }elseif (p->isPost())  {    Serial.printf("POST[%s]: %s\n", p->name().c_str(), p->value().c_str());  }else   {    Serial.printf("GET[%s]: %s\n", p->name().c_str(), p->value().c_str());  }}//Check if GET parameter existsif (request->hasParam("download"))  AsyncWebParameter* p = request->getParam("download");//Check if POST (but not File) parameter existsif (request->hasParam("download",true))  AsyncWebParameter* p = request->getParam("download",true);//Check if FILE was uploadedif (request->hasParam("download",true,true))  AsyncWebParameter* p = request->getParam("download",true,true);//List all parameters (Compatibility)int args = request->args();for (int i=0;i<args;i++){  Serial.printf("ARG[%s]: %s\n", request->argName(i).c_str(), request->arg(i).c_str());}//Check if parameter exists (Compatibility)if (request->hasArg("download"))  String arg = request->arg("download");

JSON body handling with ArduinoJson

#include"AsyncJson.h"#include"ArduinoJson.h"AsyncCallbackJsonWebHandler* handler =new AsyncCallbackJsonWebHandler("/rest/endpoint", [](AsyncWebServerRequest *request, JsonVariant &json) {  JsonObject& jsonObj = json.as<JsonObject>();// ...});server.addHandler(handler);

Responses

Redirect to another URL

//to local urlrequest->redirect("/login");//to external urlrequest->redirect("http://esp8266.com");

Basic response with HTTP Code

request->send(404);//Sends 404 File Not Found

Basic response with HTTP Code and extra headers

AsyncWebServerResponse *response = request->beginResponse(404);//Sends 404 File Not Foundresponse->addHeader("Server","AsyncWebServer_Teensy41");request->send(response);

Basic response with string content

request->send(200,"text/plain","Hello World!");

Basic response with string content and extra headers

AsyncWebServerResponse *response = request->beginResponse(200,"text/plain","Hello World!");response->addHeader("Server","AsyncWebServer");request->send(response);

Respond with content coming from a Stream

//read 12 bytes from Serial and send them as Content Type text/plainrequest->send(Serial,"text/plain",12);

Respond with content coming from a Stream and extra headers

//read 12 bytes from Serial and send them as Content Type text/plainAsyncWebServerResponse *response = request->beginResponse(Serial,"text/plain",12);response->addHeader("Server","AsyncWebServer_Teensy41");request->send(response);

Respond with content coming from a Stream containing templates

Stringprocessor(const String& var){if (var =="HELLO_FROM_TEMPLATE")returnF("Hello world!");returnString();}// ...//read 12 bytes from Serial and send them as Content Type text/plainrequest->send(Serial,"text/plain",12, processor);

Respond with content coming from a Stream containing templates and extra headers

Stringprocessor(const String& var){if (var =="HELLO_FROM_TEMPLATE")returnF("Hello world!");returnString();}// ...//read 12 bytes from Serial and send them as Content Type text/plainAsyncWebServerResponse *response = request->beginResponse(Serial,"text/plain",12, processor);response->addHeader("Server","AsyncWebServer_Teensy41");request->send(response);

Respond with content using a callback

//send 128 bytes as plain textrequest->send("text/plain",128, [](uint8_t *buffer,size_t maxLen,size_t index) -> size_t {//Write up to "maxLen" bytes into "buffer" and return the amount written.//index equals the amount of bytes that have been already sent//You will not be asked for more bytes once the content length has been reached.//Keep in mind that you can not delay or yield waiting for more data!//Send what you currently have and you will be asked for more againreturn mySource.read(buffer, maxLen);});

Respond with content using a callback and extra headers

//send 128 bytes as plain textAsyncWebServerResponse *response = request->beginResponse("text/plain",128, [](uint8_t *buffer,size_t maxLen,size_t index) -> size_t {//Write up to "maxLen" bytes into "buffer" and return the amount written.//index equals the amount of bytes that have been already sent//You will not be asked for more bytes once the content length has been reached.//Keep in mind that you can not delay or yield waiting for more data!//Send what you currently have and you will be asked for more againreturn mySource.read(buffer, maxLen);});response->addHeader("Server","AsyncWebServer_Teensy41");request->send(response);

Respond with content using a callback containing templates

Stringprocessor(const String& var){if (var =="HELLO_FROM_TEMPLATE")returnF("Hello world!");returnString();}// ...//send 128 bytes as plain textrequest->send("text/plain",128, [](uint8_t *buffer,size_t maxLen,size_t index) -> size_t {//Write up to "maxLen" bytes into "buffer" and return the amount written.//index equals the amount of bytes that have been already sent//You will not be asked for more bytes once the content length has been reached.//Keep in mind that you can not delay or yield waiting for more data!//Send what you currently have and you will be asked for more againreturn mySource.read(buffer, maxLen);}, processor);

Respond with content using a callback containing templates and extra headers

Stringprocessor(const String& var){if (var =="HELLO_FROM_TEMPLATE")returnF("Hello world!");returnString();}// ...//send 128 bytes as plain textAsyncWebServerResponse *response = request->beginResponse("text/plain",128, [](uint8_t *buffer,size_t maxLen,size_t index) -> size_t {//Write up to "maxLen" bytes into "buffer" and return the amount written.//index equals the amount of bytes that have been already sent//You will not be asked for more bytes once the content length has been reached.//Keep in mind that you can not delay or yield waiting for more data!//Send what you currently have and you will be asked for more againreturn mySource.read(buffer, maxLen);}, processor);response->addHeader("Server","AsyncWebServer_Teensy41");request->send(response);

Chunked Response

AsyncWebServerResponse *response = request->beginChunkedResponse("text/plain", [](uint8_t *buffer,size_t maxLen,size_t index) -> size_t {//Write up to "maxLen" bytes into "buffer" and return the amount written.//index equals the amount of bytes that have been already sent//You will be asked for more data until 0 is returned//Keep in mind that you can not delay or yield waiting for more data!return mySource.read(buffer, maxLen);});response->addHeader("Server","AsyncWebServer_Teensy41");request->send(response);

Chunked Response containing templates

Stringprocessor(const String& var){if (var =="HELLO_FROM_TEMPLATE")returnF("Hello world!");returnString();}// ...AsyncWebServerResponse *response = request->beginChunkedResponse("text/plain", [](uint8_t *buffer,size_t maxLen,size_t index) -> size_t {//Write up to "maxLen" bytes into "buffer" and return the amount written.//index equals the amount of bytes that have been already sent//You will be asked for more data until 0 is returned//Keep in mind that you can not delay or yield waiting for more data!return mySource.read(buffer, maxLen);}, processor);response->addHeader("Server","AsyncWebServer_Teensy41");request->send(response);

Print to response

AsyncResponseStream *response = request->beginResponseStream("text/html");response->addHeader("Server","AsyncWebServer_Teensy41");response->printf("<!DOCTYPE html><html><head><title>Webpage at %s</title></head><body>", request->url().c_str());response->print("<h2>Hello");response->print(request->client()->remoteIP());response->print("</h2>");response->print("<h3>General</h3>");response->print("<ul>");response->printf("<li>Version: HTTP/1.%u</li>", request->version());response->printf("<li>Method: %s</li>", request->methodToString());response->printf("<li>URL: %s</li>", request->url().c_str());response->printf("<li>Host: %s</li>", request->host().c_str());response->printf("<li>ContentType: %s</li>", request->contentType().c_str());response->printf("<li>ContentLength: %u</li>", request->contentLength());response->printf("<li>Multipart: %s</li>", request->multipart()?"true":"false");response->print("</ul>");response->print("<h3>Headers</h3>");response->print("<ul>");int headers = request->headers();for (int i=0;i<headers;i++){  AsyncWebHeader* h = request->getHeader(i);  response->printf("<li>%s: %s</li>", h->name().c_str(), h->value().c_str());}response->print("</ul>");response->print("<h3>Parameters</h3>");response->print("<ul>");int params = request->params();for (int i=0;i<params;i++){  AsyncWebParameter* p = request->getParam(i);if (p->isFile())  {    response->printf("<li>FILE[%s]: %s, size: %u</li>", p->name().c_str(), p->value().c_str(), p->size());  }elseif (p->isPost())  {    response->printf("<li>POST[%s]: %s</li>", p->name().c_str(), p->value().c_str());  }else   {    response->printf("<li>GET[%s]: %s</li>", p->name().c_str(), p->value().c_str());  }}response->print("</ul>");response->print("</body></html>");//send the response lastrequest->send(response);

ArduinoJson Basic Response

#include"AsyncJson.h"#include"ArduinoJson.h"AsyncResponseStream *response = request->beginResponseStream("application/json");DynamicJsonBuffer jsonBuffer;JsonObject &root = jsonBuffer.createObject();root["heap"] = ESP.getFreeHeap();root["ssid"] = WiFi.SSID();root.printTo(*response);request->send(response);

ArduinoJson Advanced Response

#include"AsyncJson.h"#include"ArduinoJson.h"AsyncJsonResponse * response =new AsyncJsonResponse();response->addHeader("Server","AsyncWebServer");JsonObject& root = response->getRoot();root["IP"] = Ethernet.localIP();response->setLength();request->send(response);

Param Rewrite With Matching

classOneParamRewrite :publicAsyncWebRewrite{protected:    String _urlPrefix;int _paramIndex;    String _paramsBackup;public:OneParamRewrite(constchar* from,constchar* to)    : AsyncWebRewrite(from, to)     {      _paramIndex = _from.indexOf('{');if ( _paramIndex >=0 && _from.endsWith("}"))       {        _urlPrefix = _from.substring(0, _paramIndex);int index = _params.indexOf('{');if (index >=0)         {          _params = _params.substring(0, index);        }      }else       {        _urlPrefix = _from;      }            _paramsBackup = _params;  }boolmatch(AsyncWebServerRequest *request)override   {if (request->url().startsWith(_urlPrefix))     {if (_paramIndex >=0)       {        _params = _paramsBackup + request->url().substring(_paramIndex);      }else       {        _params = _paramsBackup;      }returntrue;    }else     {returnfalse;    }  }};

  server.addRewrite(new OneParamRewrite("/radio/{frequency}","/radio?f={frequency}") );

Using filters

Bad Responses

Respond with content using a callback without content length to HTTP/1.0 clients

//This is used as fallback for chunked responses to HTTP/1.0 Clientsrequest->send("text/plain",0, [](uint8_t *buffer,size_t maxLen,size_t index) -> size_t {//Write up to "maxLen" bytes into "buffer" and return the amount written.//You will be asked for more data until 0 is returned//Keep in mind that you can not delay or yield waiting for more data!return mySource.read(buffer, maxLen);});

Async WebSocket Plugin

Async WebSocket Event

voidonEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type,void * arg,uint8_t *data,size_t len){if (type == WS_EVT_CONNECT)  {//client connected    Serial.printf("ws[%s][%u] connect\n", server->url(), client->id());    client->printf("Hello Client %u :)", client->id());    client->ping();  }elseif (type == WS_EVT_DISCONNECT)  {//client disconnected    Serial.printf("ws[%s][%u] disconnect: %u\n", server->url(), client->id());  }elseif (type == WS_EVT_ERROR)  {//error was received from the other end    Serial.printf("ws[%s][%u] error(%u): %s\n", server->url(), client->id(), *((uint16_t*)arg), (char*)data);  }elseif (type == WS_EVT_PONG)  {//pong message was received (in response to a ping request maybe)    Serial.printf("ws[%s][%u] pong[%u]: %s\n", server->url(), client->id(), len, (len)?(char*)data:"");  }elseif (type == WS_EVT_DATA)  {//data packet    AwsFrameInfo * info = (AwsFrameInfo*)arg;if (info->final && info->index ==0 && info->len == len)    {//the whole message is in a single frame and we got all of it's data      Serial.printf("ws[%s][%u] %s-message[%llu]:", server->url(), client->id(), (info->opcode == WS_TEXT)?"text":"binary", info->len);if (info->opcode == WS_TEXT)      {        data[len] =0;        Serial.printf("%s\n", (char*)data);      }else       {for (size_t i=0; i < info->len; i++)        {          Serial.printf("%02x", data[i]);        }                Serial.printf("\n");      }if (info->opcode == WS_TEXT)        client->text("I got your text message");else        client->binary("I got your binary message");    }else     {//message is comprised of multiple frames or the frame is split into multiple packetsif (info->index ==0)      {if (info->num ==0)          Serial.printf("ws[%s][%u] %s-message start\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary");                  Serial.printf("ws[%s][%u] frame[%u] start[%llu]\n", server->url(), client->id(), info->num, info->len);      }      Serial.printf("ws[%s][%u] frame[%u] %s[%llu - %llu]:", server->url(), client->id(), info->num, (info->message_opcode == WS_TEXT)?"text":"binary", info->index, info->index + len);if (info->message_opcode == WS_TEXT)      {        data[len] =0;        Serial.printf("%s\n", (char*)data);      }else       {for (size_t i=0; i < len; i++){          Serial.printf("%02x", data[i]);        }        Serial.printf("\n");      }if ((info->index + len) == info->len)      {        Serial.printf("ws[%s][%u] frame[%u] end[%llu]\n", server->url(), client->id(), info->num, info->len);if (info->final)        {          Serial.printf("ws[%s][%u] %s-message end\n", server->url(), client->id(), (info->message_opcode == WS_TEXT)?"text":"binary");if (info->message_opcode == WS_TEXT)            client->text("I got your text message");else            client->binary("I got your binary message");        }      }    }  }}

Methods for sending data to a socket client

//Server methodsAsyncWebSocketws("/ws");//printf to a clientws.printf((uint32_t)client_id, arguments...);//printf to all clientsws.printfAll(arguments...);//send text to a clientws.text((uint32_t)client_id, (char*)text);ws.text((uint32_t)client_id, (uint8_t*)text, (size_t)len);//send text to all clientsws.textAll((char*)text);ws.textAll((uint8_t*)text, (size_t)len);//send binary to a clientws.binary((uint32_t)client_id, (char*)binary);ws.binary((uint32_t)client_id, (uint8_t*)binary, (size_t)len);ws.binary((uint32_t)client_id, flash_binary,4);//send binary to all clientsws.binaryAll((char*)binary);ws.binaryAll((uint8_t*)binary, (size_t)len);//HTTP Authenticate before switch to Websocket protocolws.setAuthentication("user","pass");//client methodsAsyncWebSocketClient * client;//printfclient->printf(arguments...);//send textclient->text((char*)text);client->text((uint8_t*)text, (size_t)len);//send binaryclient->binary((char*)binary);client->binary((uint8_t*)binary, (size_t)len);

Direct access to web socket message buffer

voidsendDataWs(AsyncWebSocketClient * client){  DynamicJsonBuffer jsonBuffer;  JsonObject& root = jsonBuffer.createObject();  root["a"] ="abc";  root["b"] ="abcd";  root["c"] ="abcde";  root["d"] ="abcdef";  root["e"] ="abcdefg";size_t len = root.measureLength();  AsyncWebSocketMessageBuffer * buffer = ws.makeBuffer(len);//  creates a buffer (len + 1) for you.if (buffer)   {    root.printTo((char *)buffer->get(), len +1);if (client)     {        client->text(buffer);    }else     {        ws.textAll(buffer);    }  }}

Limiting the number of web socket clients

voidloop(){  ws.cleanupClients();}

Async Event Source Plugin

Setup Event Source on the server

AsyncWebServerserver(80);AsyncEventSourceevents("/events");voidsetup(){// setup ......  events.onConnect([](AsyncEventSourceClient *client)  {if (client->lastId())    {      Serial.printf("Client reconnected! Last message ID that it got is: %u\n", client->lastId());    }//send event with message "hello!", id current millis// and set reconnect delay to 1 second    client->send("hello!",NULL,millis(),1000);  });//HTTP Basic authentication  events.setAuthentication("user","pass");  server.addHandler(&events);// setup ......}voidloop(){if (eventTriggered){// your logic here//send event "myevent"    events.send("my event content","myevent",millis());  }}

Setup Event Source in the browser

if(!!window.EventSource){varsource=newEventSource('/events');source.addEventListener('open',function(e){console.log("Events Connected");},false);source.addEventListener('error',function(e){if(e.target.readyState!=EventSource.OPEN){console.log("Events Disconnected");}},false);source.addEventListener('message',function(e){console.log("message",e.data);},false);source.addEventListener('myevent',function(e){console.log("myevent",e.data);},false);}

Remove handlers and rewrites

// save callback for particular URL pathauto handler = server.on("/some/path", [](AsyncWebServerRequest *request){//do something useful});// when you don't need handler anymore remove itserver.removeHandler(&handler);// same with rewritesserver.removeRewrite(&someRewrite);server.onNotFound([](AsyncWebServerRequest *request){  request->send(404);});// remove server.onNotFound handlerserver.onNotFound(NULL);// remove all rewrites, handlers and onNotFound/onFileUpload/onRequestBody callbacksserver.reset();

Setting up the server

Setup global and class functions as request handlers

#include"QNEthernet.h"// https://github.com/ssilverman/QNEthernetusingnamespaceqindesign::network;#include<AsyncWebServer_Teensy41.h>AsyncWebServerserver(80);...voidhandleRequest(AsyncWebServerRequest *request){}classWebClass {public :  AsyncWebServer classWebServer = AsyncWebServer(81);WebClass(){};voidclassRequest (AsyncWebServerRequest *request){}voidbegin()  {// attach global request handler    classWebServer.on("/example", HTTP_ANY, handleRequest);// attach class request handler    classWebServer.on("/example", HTTP_ANY,std::bind(&WebClass::classRequest,this, std::placeholders::_1));  }};AsyncWebServerglobalWebServer(80);WebClass webClassInstance;voidsetup() {// attach global request handler  globalWebServer.on("/example", HTTP_ANY, handleRequest);// attach class request handler  globalWebServer.on("/example", HTTP_ANY,std::bind(&WebClass::classRequest, webClassInstance, std::placeholders::_1));}voidloop() {}

Methods for controlling websocket connections

// Disable client connections if it was activatedif ( ws.enabled() )  ws.enable(false);// enable client connections if it was disabledif ( !ws.enabled() )  ws.enable(true);

Adding Default Headers

DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin","*");webServer.begin();

webServer.onNotFound([](AsyncWebServerRequest *request) {if (request->method() == HTTP_OPTIONS)   {    request->send(200);  }else   {    request->send(404);  }});

Path variable

  server.on("^\\/sensor\\/([0-9]+)$", HTTP_GET, [] (AsyncWebServerRequest *request)   {      String sensorId = request->pathArg(0);  });

  compiler.cpp.extra_flags=-DDASYNCWEBSERVER_REGEX

[env:myboard]build_flags =   -DASYNCWEBSERVER_REGEX

Examples

ExampleAsync_AdvancedWebServer

Debug Terminal Output Samples

1. Async_AdvancedWebServer on Teensy4.1 QNEthernet

Start Async_AdvancedWebServer on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.107HTTP EthernetWebServer is @ IP :192.168.2.107

2. WebClient on Teensy4.1 QNEthernet

Start WebClient on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.107Starting connection to server...Connected to serverHTTP/1.1200 OKServer: nginx/1.4.2Date: Fri,18 Mar202214:44:27 GMTContent-Type: text/plainContent-Length:2317Last-Modified: Thu,24 Feb202211:33:32 GMTConnection: closeVary: Accept-EncodingETag:"62176d0c-90d"Accept-Ranges: bytesPlease use http://arduino.tips/asciilogo.txt via HTTP           `:;;;,`                      .:;;:.                   .;;;;;;;;;;;`                :;;;;;;;;;;:     TM       `;;;;;;;;;;;;;;;`            :;;;;;;;;;;;;;;;           :;;;;;;;;;;;;;;;;;;         `;;;;;;;;;;;;;;;;;;         ;;;;;;;;;;;;;;;;;;;;;       .;;;;;;;;;;;;;;;;;;;;       ;;;;;;;;:`   `;;;;;;;;;     ,;;;;;;;;.`   .;;;;;;;;     .;;;;;;,         :;;;;;;;   .;;;;;;;          ;;;;;;;    ;;;;;;             ;;;;;;;  ;;;;;;,            ;;;;;;.  ,;;;;;               ;;;;;;.;;;;;;`              ;;;;;;  ;;;;;.                ;;;;;;;;;;;`      ```       ;;;;;` ;;;;;                  ;;;;;;;;;,       ;;;       .;;;;;`;;;;:                  `;;;;;;;;        ;;;        ;;;;;,;;;;`    `,,,,,,,,      ;;;;;;;      .,,;;;,,,     ;;;;;:;;;;`    .;;;;;;;;       ;;;;;,      :;;;;;;;;     ;;;;;:;;;;`    .;;;;;;;;      `;;;;;;      :;;;;;;;;     ;;;;;.;;;;.                   ;;;;;;;.        ;;;        ;;;;; ;;;;;                  ;;;;;;;;;        ;;;        ;;;;; ;;;;;                 .;;;;;;;;;;       ;;;       ;;;;;, ;;;;;;               `;;;;;;;;;;;;                ;;;;;  `;;;;;,             .;;;;;; ;;;;;;;              ;;;;;;   ;;;;;;:           :;;;;;;.  ;;;;;;;            ;;;;;;     ;;;;;;;`       .;;;;;;;,    ;;;;;;;;        ;;;;;;;:      ;;;;;;;;;:,:;;;;;;;;;:      ;;;;;;;;;;:,;;;;;;;;;;       `;;;;;;;;;;;;;;;;;;;.        ;;;;;;;;;;;;;;;;;;;;          ;;;;;;;;;;;;;;;;;           :;;;;;;;;;;;;;;;;:            ,;;;;;;;;;;;;;,              ;;;;;;;;;;;;;;                .;;;;;;;;;`                  ,;;;;;;;;:                                                                                                                                                                                                                                                 ;;;   ;;;;;`  ;;;;:  .;;  ;; ,;;;;;, ;;. `;,  ;;;;       ;;;   ;;:;;;  ;;;;;; .;;  ;; ,;;;;;: ;;; `;, ;;;:;;     ,;:;   ;;  ;;  ;;  ;; .;;  ;;   ,;,   ;;;,`;, ;;  ;;     ;; ;:  ;;  ;;  ;;  ;; .;;  ;;   ,;,   ;;;;`;, ;;  ;;.    ;: ;;  ;;;;;:  ;;  ;; .;;  ;;   ,;,   ;;`;;;, ;;  ;;`   ,;;;;;  ;;`;;   ;;  ;; .;;  ;;   ,;,   ;; ;;;, ;;  ;;    ;;  ,;, ;; .;;  ;;;;;:  ;;;;;: ,;;;;;: ;;  ;;, ;;;;;;    ;;   ;; ;;  ;;` ;;;;.   `;;;:  ,;;;;;, ;;  ;;,  ;;;;   Disconnecting from server...

3. MQTTClient_Auth on Teensy4.1 QNEthernet

Start MQTTClient_Auth on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.107Attempting MQTT connection to broker.emqx.io...connectedMessage Send : MQTT_Pub => Hello from MQTTClient_Auth on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Auth on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Auth on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Auth on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Auth on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Auth on TEENSY4.1 with Teensy4.1 QNEthernet

4. MQTTClient_Basic on Teensy4.1 QNEthernet

Start MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.107Attempting MQTT connection to broker.emqx.io...connectedMessage Send : MQTT_Pub => Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage Send : MQTT_Pub => Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernetMessage arrived [MQTT_Pub] Hello from MQTTClient_Basic on TEENSY4.1 with Teensy4.1 QNEthernet

5. MQTT_ThingStream on Teensy4.1 QNEthernet

Start MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.107***************************************Teensy41_Pub***************************************Attempting MQTT connection to broker.emqx.io...connectedPublished connection message successfully!Subscribed to: Teensy41_SubMQTT Message Send : Teensy41_Pub => Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message receive [Teensy41_Pub] Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message Send : Teensy41_Pub => Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message receive [Teensy41_Pub] Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message Send : Teensy41_Pub => Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message receive [Teensy41_Pub] Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message Send : Teensy41_Pub => Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message receive [Teensy41_Pub] Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message Send : Teensy41_Pub => Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernetMQTT Message receive [Teensy41_Pub] Hello from MQTT_ThingStream on TEENSY4.1 with Teensy4.1 QNEthernet

6. Async_AdvancedWebServer_MemoryIssues_Send_CString on Teensy4.1 QNEthernet

Using CString ===> smaller heap (61,440 bytes) for 40,000-byte buffer

Start Async_AdvancedWebServer_MemoryIssues_Send_CString on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0HEAP DATA - Start =>  Free heap:483328  Used heap:0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.83HTTP EthernetWebServer is @ IP :192.168.2.83HEAP DATA - Pre Create Arduino String  Free heap:442368  Used heap:40960.HEAP DATA - Pre Send  Free heap:438272  Used heap:45056HEAP DATA - Post Send  Free heap:421888  Used heap:61440......Out String Length=31243.....

Async_AdvancedWebServer_MemoryIssues_SendArduinoString ===> larger heap (65,536 bytes) while buffer len is only 12K Bytes

Start Async_AdvancedWebServer_MemoryIssues_SendArduinoString on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0HEAP DATA - Start =>  Free heap:483328  Used heap:0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.83HTTP EthernetWebServer is @ IP :192.168.2.83.HEAP DATA - Pre Send  Free heap:438272  Used heap:45056HEAP DATA - Post Send  Free heap:417792  Used heap:65536......Out String Length=11191... ...Out String Length=11233....... Out String Length=11192.......Out String Length=11204... ...Out String Length=11214

7. Async_AdvancedWebServer_SendChunked on Teensy4.1 QNEthernet

Start Async_AdvancedWebServer_SendChunked on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.92AsyncWebServer is @ IP :192.168.2.92.[AWS] Total length to send in chunks =31235[AWS] Bytes sent in chunk =5716[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =2191[AWS] Bytes sent in chunk =0[AWS] Total length to send in chunks =31238[AWS] Bytes sent in chunk =5716[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =2194[AWS] Bytes sent in chunk =0.[AWS] Total length to send in chunks =31243[AWS] Bytes sent in chunk =5716[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =2199[AWS] Bytes sent in chunk =0[AWS] Total length to send in chunks =31263[AWS] Bytes sent in chunk =5716[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832.[AWS] Total length to send in chunks =31233[AWS] Bytes sent in chunk =5716[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =2189[AWS] Bytes sent in chunk =0[AWS] Total length to send in chunks =31226[AWS] Bytes sent in chunk =5716[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =2182[AWS] Bytes sent in chunk =0

8. AsyncWebServer_SendChunked on Teensy4.1 QNEthernet

Start AsyncWebServer_SendChunked on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.92AsyncWebServer is @ IP :192.168.2.92.[AWS] Total length to send in chunks =46302[AWS] Bytes sent in chunk =5720[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5590[AWS] Bytes sent in chunk =0[AWS] Total length to send in chunks =46302[AWS] Bytes sent in chunk =5720[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5590[AWS] Bytes sent in chunk =0.[AWS] Total length to send in chunks =46302[AWS] Bytes sent in chunk =5720[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5590[AWS] Bytes sent in chunk =0[AWS] Total length to send in chunks =46302[AWS] Bytes sent in chunk =5720[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5832[AWS] Bytes sent in chunk =5590[AWS] Bytes sent in chunk =0

9. Async_WebSocketsServer on Teensy4.1 QNEthernet

Starting Async_WebSocketsServer on TEENSY4.1 with Teensy4.1 QNEthernetAsyncWebServer_Teensy41 v1.7.0Initialize Ethernetusing DHCP => Connected! IP address:192.168.2.119ws[Server: /ws][ClientID:1] WSClient connectedws[Server: /ws][ClientID:1] text-message[len:13]: Hello, Serverws[Server: /ws][ClientID:1] WSClient disconnectedws[Server: /ws][ClientID:2] WSClient connectedws[Server: /ws][ClientID:2] text-message[len:13]: Hello, Serverws[Server: /ws][ClientID:2] WSClient disconnectedws[Server: /ws][ClientID:3] WSClient connectedws[Server: /ws][ClientID:3] text-message[len:13]: Hello, Server

Debug

// Use this to output debug msgs to Serial#defineASYNCWEBSERVER_TEENSY41_DEBUG_PORT       Serial// Debug Level from 0 to 4#define_TEENSY41_ASYNC_TCP_LOGLEVEL_1#define_AWS_TEENSY41_LOGLEVEL_1

Troubleshooting

Issues

TO DO

DONE

Contributions and Thanks

Contributing

License

Copyright