+
+
+
+
+---
+---
+
+## Table of contents
+
+* [Table of contents](#table-of-contents)
+* [Important Note from v1.6.2](#Important-Note-from-v162)
+* [Why do we need this AsyncWebServer_ESP32_ENC library](#why-do-we-need-this-asyncwebserver_ESP32_ENC-library)
+ * [Features](#features)
+ * [Why Async is better](#why-async-is-better)
+ * [Currently supported Boards](#currently-supported-boards)
+* [Changelog](changelog.md)
+* [Prerequisites](#prerequisites)
+* [Installation](#installation)
+ * [Use Arduino Library Manager](#use-arduino-library-manager)
+ * [Manual Install](#manual-install)
+ * [VS Code & PlatformIO](#vs-code--platformio)
+* [Important things to remember](#important-things-to-remember)
+* [Principles of operation](#principles-of-operation)
+ * [The Async Web server](#the-async-web-server)
+ * [Request Life Cycle](#request-life-cycle)
+ * [Rewrites and how do they work](#rewrites-and-how-do-they-work)
+ * [Handlers and how do they work](#handlers-and-how-do-they-work)
+ * [Responses and how do they work](#responses-and-how-do-they-work)
+ * [Template processing](#template-processing)
+* [Request Variables](#request-variables)
+ * [Common Variables](#common-variables)
+ * [Headers](#headers)
+ * [GET, POST and FILE parameters](#get-post-and-file-parameters)
+ * [JSON body handling with ArduinoJson](#json-body-handling-with-arduinojson)
+* [Responses](#responses)
+ * [Redirect to another URL](#redirect-to-another-url)
+ * [Basic response with HTTP Code](#basic-response-with-http-code)
+ * [Basic response with HTTP Code and extra headers](#basic-response-with-http-code-and-extra-headers)
+ * [Basic response with string content](#basic-response-with-string-content)
+ * [Basic response with string content and extra headers](#basic-response-with-string-content-and-extra-headers)
+ * [Respond with content coming from a Stream](#respond-with-content-coming-from-a-stream)
+ * [Respond with content coming from a Stream and extra headers](#respond-with-content-coming-from-a-stream-and-extra-headers)
+ * [Respond with content coming from a Stream containing templates](#respond-with-content-coming-from-a-stream-containing-templates)
+ * [Respond with content coming from a Stream containing templates and extra headers](#respond-with-content-coming-from-a-stream-containing-templates-and-extra-headers)
+ * [Respond with content using a callback](#respond-with-content-using-a-callback)
+ * [Respond with content using a callback and extra headers](#respond-with-content-using-a-callback-and-extra-headers)
+ * [Respond with content using a callback containing templates](#respond-with-content-using-a-callback-containing-templates)
+ * [Respond with content using a callback containing templates and extra headers](#respond-with-content-using-a-callback-containing-templates-and-extra-headers)
+ * [Chunked Response](#chunked-response)
+ * [Chunked Response containing templates](#chunked-response-containing-templates)
+ * [Print to response](#print-to-response)
+ * [ArduinoJson Basic Response](#arduinojson-basic-response)
+ * [ArduinoJson Advanced Response](#arduinojson-advanced-response)
+* [Param Rewrite With Matching](#param-rewrite-with-matching)
+* [Using filters](#using-filters)
+* [Bad Responses](#bad-responses)
+ * [Respond with content using a callback without content length to HTTP/1.0 clients](#respond-with-content-using-a-callback-without-content-length-to-http10-clients)
+* [Async WebSocket Plugin](#async-websocket-plugin)
+ * [Async WebSocket Event](#async-websocket-event)
+ * [Methods for sending data to a socket client](#methods-for-sending-data-to-a-socket-client)
+ * [Direct access to web socket message buffer](#direct-access-to-web-socket-message-buffer)
+ * [Limiting the number of web socket clients](#limiting-the-number-of-web-socket-clients)
+* [Async Event Source Plugin](#async-event-source-plugin)
+ * [Setup Event Source on the server](#setup-event-source-on-the-server)
+ * [Setup Event Source in the browser](#setup-event-source-in-the-browser)
+* [Remove handlers and rewrites](#remove-handlers-and-rewrites)
+* [Setting up the server](#setting-up-the-server)
+ * [Setup global and class functions as request handlers](#setup-global-and-class-functions-as-request-handlers)
+ * [Methods for controlling websocket connections](#methods-for-controlling-websocket-connections)
+ * [Adding Default Headers](#adding-default-headers)
+ * [Path variable](#path-variable)
+* [Examples](#examples)
+ * [ 1. Async_AdvancedWebServer](examples/Async_AdvancedWebServer)
+ * [ 2. Async_HelloServer](examples/Async_HelloServer)
+ * [ 3. Async_HelloServer2](examples/Async_HelloServer2)
+ * [ 4. AsyncMultiWebServer_ESP32_ENC](examples/AsyncMultiWebServer_ESP32_ENC)
+ * [ 5. Async_PostServer](examples/Async_PostServer)
+ * [ 6. Async_RegexPatterns_ESP32_ENC](examples/Async_RegexPatterns_ESP32_ENC)
+ * [ 7. AsyncSimpleServer_ESP32_ENC](examples/AsyncSimpleServer_ESP32_ENC)
+ * [ 8. Async_AdvancedWebServer_MemoryIssues_SendArduinoString](examples/Async_AdvancedWebServer_MemoryIssues_SendArduinoString)
+ * [ 9. Async_AdvancedWebServer_MemoryIssues_Send_CString](examples/Async_AdvancedWebServer_MemoryIssues_Send_CString)
+ * [10. Async_AdvancedWebServer_SendChunked](examples/Async_AdvancedWebServer_SendChunked)
+ * [11. AsyncWebServer_SendChunked](examples/AsyncWebServer_SendChunked)
+* [Example Async_AdvancedWebServer](#Example-Async_AdvancedWebServer)
+* [Debug Terminal Output Samples](#debug-terminal-output-samples)
+ * [1. AsyncMultiWebServer_ESP32_ENC on ESP32_DEV with ESP32_ENC28J60](#1-AsyncMultiWebServer_ESP32_ENC-on-ESP32_DEV-with-ESP32_ENC28J60)
+ * [2. Async_AdvancedWebServer_MemoryIssues_Send_CString on ESP32_DEV with ESP32_ENC28J60](#2-Async_AdvancedWebServer_MemoryIssues_Send_CString-on-ESP32_DEV-with-ESP32_ENC28J60)
+ * [3. Async_AdvancedWebServer_SendChunked on ESP32_DEV with ESP32_ENC28J60](#3-Async_AdvancedWebServer_SendChunked-on-ESP32_DEV-with-ESP32_ENC28J60)
+ * [4. AsyncWebServer_SendChunked on ESP32_DEV with ESP32_ENC28J60](#4-AsyncWebServer_SendChunked-on-ESP32_DEV-with-ESP32_ENC28J60)
+* [Debug](#debug)
+* [Troubleshooting](#troubleshooting)
+* [Issues](#issues)
+* [TO DO](#to-do)
+* [DONE](#done)
+* [Contributions and Thanks](#contributions-and-thanks)
+* [Contributing](#contributing)
+* [License](#license)
+* [Copyright](#copyright)
+
+---
+---
+
+### Important Note from v1.6.2
+
+The new `v1.6.2+` has added a new and powerful feature to permit using `CString` to save heap to send `very large data`.
+
+Check the `marvelleous` PRs of **@salasidis** in [Portenta_H7_AsyncWebServer library](https://github.com/khoih-prog/Portenta_H7_AsyncWebServer)
+- [request->send(200, textPlainStr, jsonChartDataCharStr); - Without using String Class - to save heap #8](https://github.com/khoih-prog/Portenta_H7_AsyncWebServer/pull/8)
+- [All memmove() removed - string no longer destroyed #11](https://github.com/khoih-prog/Portenta_H7_AsyncWebServer/pull/11)
+
+and these new examples
+
+1. [Async_AdvancedWebServer_MemoryIssues_Send_CString](https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC/tree/main/examples/Async_AdvancedWebServer_MemoryIssues_Send_CString)
+2. [Async_AdvancedWebServer_MemoryIssues_SendArduinoString](https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC/tree/main/examples/Async_AdvancedWebServer_MemoryIssues_SendArduinoString)
+
+If using Arduino String, to send a buffer around 30 KBytes, the used `Max Heap` is around **152,136 bytes**
+
+If using CString in regular memory, with the same 30 KBytes, the used `Max Heap` is around **120,880 bytes, saving around a buffer size (30 KBytes)**
+
+This is very critical in use-cases where sending `very large data` is necessary, without `heap-allocation-error`.
+
+
+1. The traditional function used to send `Arduino String` is
+
+https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC/blob/6c499f1d3e91b1e33f86f3d9c6a36fa60470a38f/src/AsyncWebServer_ESP32_ENC.h#L518
+
+```cpp
+void send(int code, const String& contentType = String(), const String& content = String());
+```
+
+such as
+
+```cpp
+request->send(200, textPlainStr, ArduinoStr);
+```
+The required additional HEAP is about **3 times of the String size**
+
+
+2. To use `CString` with copying while sending. Use function
+
+https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC/blob/6c499f1d3e91b1e33f86f3d9c6a36fa60470a38f/src/AsyncWebServer_ESP32_ENC.h#L520
+
+```cpp
+void send(int code, const String& contentType, const char *content, bool nonDetructiveSend = true); // RSMOD
+```
+
+such as
+
+```cpp
+request->send(200, textPlainStr, cStr);
+```
+
+The required additional HEAP is also about **2 times of the CString size** because of `unnecessary copies` of the CString in HEAP. Avoid this `unefficient` way.
+
+
+3. To use `CString` without copying while sending. Use function
+
+https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC/blob/6c499f1d3e91b1e33f86f3d9c6a36fa60470a38f/src/AsyncWebServer_ESP32_ENC.h#L520
+
+```cpp
+void send(int code, const String& contentType, const char *content, bool nonDetructiveSend = true); // RSMOD
+```
+
+such as
+
+```cpp
+request->send(200, textPlainStr, cStr, false);
+```
+
+The required additional HEAP is about **1 times of the CString size**. This way is the best and **most efficient way** to use by avoiding of `unnecessary copies` of the CString in HEAP
+
+
+---
+---
+
+### Why do we need this [AsyncWebServer_ESP32_ENC library](https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC)
+
+
+#### Features
+
+This library is based on, modified from:
+
+1. [Hristo Gochkov's ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer)
+
+to apply the better and faster **asynchronous** feature of the **powerful** [ESPAsyncWebServer Library](https://github.com/me-no-dev/ESPAsyncWebServer) into **(ESP32 + ENC28J60)**.
+
+
+#### Why Async is better
+
+- Using asynchronous network means that you can handle **more than one connection at the same time**
+- **You are called once the request is ready and parsed**
+- When you send the response, you are **immediately ready** to handle other connections while the server is taking care of sending the response in the background
+- **Speed is OMG**
+- **Easy to use API, HTTP Basic and Digest MD5 Authentication (default), ChunkedResponse**
+- Easily extensible to handle **any type of content**
+- Supports Continue 100
+- **Async WebSocket plugin offering different locations without extra servers or ports**
+- Async EventSource (Server-Sent Events) plugin to send events to the browser
+- URL Rewrite plugin for conditional and permanent url rewrites
+- ServeStatic plugin that supports cache, Last-Modified, default index and more
+- Simple template processing engine to handle templates
+
+
+---
+
+#### Currently supported Boards
+
+1. **(ESP32 + ENC28J60 Ethernet) boards**
+
+---
+---
+
+
+## Prerequisites
+
+ 1. [`Arduino IDE 1.8.19+` for Arduino](https://github.com/arduino/Arduino). [](https://github.com/arduino/Arduino/releases/latest)
+ 2. [`ESP32 Core 2.0.5+`](https://github.com/espressif/arduino-esp32) for ESP32-based boards. ESP32 Latest Core [](https://github.com/espressif/arduino-esp32/releases/latest/)
+ 3. [`AsyncTCP library v1.1.1+`](https://github.com/me-no-dev/AsyncTCP).
+
+---
+
+## Installation
+
+### Use Arduino Library Manager
+
+The best and easiest way is to use `Arduino Library Manager`. Search for `AsyncWebServer_ESP32_ENC`, then select / install the latest version. You can also use this link [](https://www.ardu-badge.com/AsyncWebServer_ESP32_ENC) for more detailed instructions.
+
+### Manual Install
+
+1. Navigate to [AsyncWebServer_ESP32_ENC](https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC) page.
+2. Download the latest release `AsyncWebServer_ESP32_ENC-main.zip`.
+3. Extract the zip file to `AsyncWebServer_ESP32_ENC-main` directory
+4. Copy the whole `AsyncWebServer_ESP32_ENC-main` folder to Arduino libraries' directory such as `~/Arduino/libraries/`.
+
+### VS Code & PlatformIO:
+
+1. Install [VS Code](https://code.visualstudio.com/)
+2. Install [PlatformIO](https://platformio.org/platformio-ide)
+3. Install [**AsyncWebServer_ESP32_ENC** library](https://registry.platformio.org/libraries/khoih-prog/AsyncWebServer_ESP32_ENC) by using [Library Manager](https://registry.platformio.org/libraries/khoih-prog/AsyncWebServer_ESP32_ENC/installation). Search for **AsyncWebServer_ESP32_ENC** in [Platform.io Author's Libraries](https://platformio.org/lib/search?query=author:%22Khoi%20Hoang%22)
+4. Use included [platformio.ini](platformio/platformio.ini) file from examples to ensure that all dependent libraries will installed automatically. Please visit documentation for the other options and examples at [Project Configuration File](https://docs.platformio.org/page/projectconf.html)
+
+
+---
+---
+
+## Important things to remember
+
+- This is **fully asynchronous server** and as such does not run on the `loop()` thread.
+- You can not use `yield()` or `delay()` or any function that uses them inside the callbacks
+- The server is smart enough to know when to close the connection and free resources
+- You can not send more than one response to a single request
+
+---
+
+## Principles of operation
+
+### The Async Web server
+
+- Listens for connections
+- Wraps the new clients into `Request`
+- Keeps track of clients and cleans memory
+- Manages `Rewrites` and apply them on the request url
+- Manages `Handlers` and attaches them to Requests
+
+### Request Life Cycle
+
+- TCP connection is received by the server
+- The connection is wrapped inside `Request` object
+- When the request head is received (type, url, get params, http version and host),
+ the server goes through all `Rewrites` (in the order they were added) to rewrite the url and inject query parameters,
+ next, it goes through all attached `Handlers` (in the order they were added) trying to find one
+ that `canHandle` the given request. If none are found, the default(catch-all) handler is attached.
+- The rest of the request is received, calling the `handleUpload` or `handleBody` methods of the `Handler` if they are needed (POST+File/Body)
+- When the whole request is parsed, the result is given to the `handleRequest` method of the `Handler` and is ready to be responded to
+- In the `handleRequest` method, to the `Request` is attached a `Response` object (see below) that will serve the response data back to the client
+- When the `Response` is sent, the client is closed and freed from the memory
+
+### Rewrites and how do they work
+
+- The `Rewrites` are used to rewrite the request url and/or inject get parameters for a specific request url path.
+- All `Rewrites` are evaluated on the request in the order they have been added to the server.
+- The `Rewrite` will change the request url only if the request url (excluding get parameters) is fully match
+ the rewrite url, and when the optional `Filter` callback return true.
+- Setting a `Filter` to the `Rewrite` enables to control when to apply the rewrite, decision can be based on
+ request url, http version, request host/port/target host, get parameters or the request client's localIP or remoteIP.
+- The `Rewrite` can specify a target url with optional get parameters, e.g. `/to-url?with=params`
+
+### Handlers and how do they work
+
+- The `Handlers` are used for executing specific actions to particular requests
+- One `Handler` instance can be attached to any request and lives together with the server
+- Setting a `Filter` to the `Handler` enables to control when to apply the handler, decision can be based on
+ request url, http version, request host/port/target host, get parameters or the request client's localIP or remoteIP.
+- The `canHandle` method is used for handler specific control on whether the requests can be handled
+ and for declaring any interesting headers that the `Request` should parse. Decision can be based on request
+ method, request url, http version, request host/port/target host and get parameters
+- Once a `Handler` is attached to given `Request` (`canHandle` returned true)
+ that `Handler` takes care to receive any file/data upload and attach a `Response`
+ once the `Request` has been fully parsed
+- `Handlers` are evaluated in the order they are attached to the server. The `canHandle` is called only
+ if the `Filter` that was set to the `Handler` return true.
+- The first `Handler` that can handle the request is selected, not further `Filter` and `canHandle` are called.
+
+### Responses and how do they work
+
+- The `Response` objects are used to send the response data back to the client
+- The `Response` object lives with the `Request` and is freed on end or disconnect
+- Different techniques are used depending on the response type to send the data in packets
+ returning back almost immediately and sending the next packet when this one is received.
+ Any time in between is spent to run the user loop and handle other network packets
+- Responding asynchronously is probably the most difficult thing for most to understand
+- Many different options exist for the user to make responding a background task
+
+### Template processing
+
+- `AsyncWebServer_ESP32_ENC` contains simple template processing engine.
+- Template processing can be added to most response types.
+- Currently it supports only replacing template placeholders with actual values. No conditional processing, cycles, etc.
+- Placeholders are delimited with `%` symbols. Like this: `%TEMPLATE_PLACEHOLDER%`.
+- It works by extracting placeholder name from response text and passing it to user provided function which should return actual value to be used instead of placeholder.
+- Since it's user provided function, it is possible for library users to implement conditional processing and cycles themselves.
+- Since it's impossible to know the actual response size after template processing step in advance (and, therefore, to include it in response headers), the response becomes [chunked](#chunked-response).
+
+---
+
+## Request Variables
+
+### Common Variables
+
+```cpp
+request->version(); // uint8_t: 0 = HTTP/1.0, 1 = HTTP/1.1
+request->method(); // enum: HTTP_GET, HTTP_POST, HTTP_DELETE, HTTP_PUT, HTTP_PATCH, HTTP_HEAD, HTTP_OPTIONS
+request->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 avaiable in Handler::canHandle)
+request->contentLength(); // size_t: ContentLength of the request (not avaiable in Handler::canHandle)
+request->multipart(); // bool: True if the request has content type "multipart"
+```
+
+### Headers
+
+```cpp
+//List all collected headers
+int headers = request->headers();
+int i;
+
+for (i=0;iHello "); +response->print(request->client()->remoteIP()); +response->print("
"); + +response->print("General
"); +response->print("- ");
+response->printf("
- Version: HTTP/1.%u ", request->version()); +response->printf("
- Method: %s ", request->methodToString()); +response->printf("
- URL: %s ", request->url().c_str()); +response->printf("
- Host: %s ", request->host().c_str()); +response->printf("
- ContentType: %s ", request->contentType().c_str()); +response->printf("
- ContentLength: %u ", request->contentLength()); +response->printf("
- Multipart: %s ", request->multipart()?"true":"false"); +response->print("
Headers
"); +response->print("- ");
+int headers = request->headers();
+
+for (int i=0;i
- %s: %s ", h->name().c_str(), h->value().c_str()); +} + +response->print("
Parameters
"); +response->print("- ");
+
+int params = request->params();
+
+for (int i=0;i
- FILE[%s]: %s, size: %u ", p->name().c_str(), p->value().c_str(), p->size()); + } + else if (p->isPost()) + { + response->printf("
- POST[%s]: %s ", p->name().c_str(), p->value().c_str()); + } + else + { + response->printf("
- GET[%s]: %s ", p->name().c_str(), p->value().c_str()); + } +} + +response->print("
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
 ⭐️⭐️ Hristo Gochkov |
+  tobozo |
+
+
+
+
+
+---
+---
+
+## Table of contents
+
+* [Changelog](#changelog)
+ * [Releases v1.6.2](#releases-v162)
+
+
+
+---
+---
+
+## Changelog
+
+#### Releases v1.6.2
+
+1. Initial coding to port [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer) to ESP32 boards using ENC28J60 Ethernet.
+2. Bump up to `v1.6.2` to sync with [AsyncWebServer_ESP32_ENC v1.6.2](https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC).
+3. Use `allman astyle`
+
diff --git a/examples/AsyncMultiWebServer_ESP32_ENC/AsyncMultiWebServer_ESP32_ENC.ino b/examples/AsyncMultiWebServer_ESP32_ENC/AsyncMultiWebServer_ESP32_ENC.ino
new file mode 100644
index 0000000..ed7c89c
--- /dev/null
+++ b/examples/AsyncMultiWebServer_ESP32_ENC/AsyncMultiWebServer_ESP32_ENC.ino
@@ -0,0 +1,250 @@
+/****************************************************************************************************************************
+ AsyncMultiWebServer_ESP32_ENC.ino
+
+ For ENC28J60 Ethernet in ESP32 (ESP32 + ENC28J60)
+
+ AsyncWebServer_ESP32_ENC is a library for the Ethernet ENC28J60 in ESSP32 to run AsyncWebServer
+
+ Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer)
+ Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC
+ Licensed under GPLv3 license
+ *****************************************************************************************************************************/
+
+#if !( defined(ESP32) )
+ #error This code is designed for (ESP32 + ENC28J60) to run on ESP32 platform! Please check your Tools->Board setting.
+#endif
+
+#include Hello from %s
\ +running AsyncMultiWebServer_ESP32_ENC
\ +on %s
\ +Uptime: %d d %02d:%02d:%02d
\ +\ +", BOARD_NAME, BOARD_NAME, SHIELD_TYPE, day, hr, min % 60, sec % 60); + + return temp; +} + + +void handleRoot(AsyncWebServerRequest * request) +{ + String message = createBuffer(); + request->send(200, F("text/html"), message); +} + +String createNotFoundBuffer(AsyncWebServerRequest * request) +{ + String message; + + message.reserve(500); + + message = F("File Not Found\n\n"); + + message += F("URI: "); + message += request->url(); + message += F("\nMethod: "); + message += (request->method() == HTTP_GET) ? F("GET") : F("POST"); + message += F("\nArguments: "); + message += request->args(); + message += F("\n"); + + for (uint8_t i = 0; i < request->args(); i++) + { + message += " " + request->argName(i) + ": " + request->arg(i) + "\n"; + } + + return message; +} + +void handleNotFound(AsyncWebServerRequest * request) +{ + String message = createNotFoundBuffer(request); + request->send(404, F("text/plain"), message); +} + +void setup() +{ + Serial.begin(115200); + + while (!Serial && millis() < 5000); + + delay(200); + + Serial.print(F("\nStart AsyncMultiWebServer_ESP32_ENC on ")); + Serial.print(BOARD_NAME); + Serial.print(F(" with ")); + Serial.println(SHIELD_TYPE); + Serial.println(ASYNC_WEBSERVER_ESP32_ENC_VERSION); + + AWS_LOGWARN(F("Default SPI pinout:")); + AWS_LOGWARN1(F("MOSI:"), MOSI_GPIO); + AWS_LOGWARN1(F("MISO:"), MISO_GPIO); + AWS_LOGWARN1(F("SCK:"), SCK_GPIO); + AWS_LOGWARN1(F("CS:"), CS_GPIO); + AWS_LOGWARN1(F("INT:"), INT_GPIO); + AWS_LOGWARN1(F("SPI Clock (MHz):"), SPI_CLOCK_MHZ); + AWS_LOGWARN(F("=========================")); + + /////////////////////////////////// + + // To be called before ETH.begin() + ESP32_ENC_onEvent(); + + // start the ethernet connection and the server: + // Use DHCP dynamic IP and random mac + uint16_t index = millis() % NUMBER_OF_MAC; + + //bool begin(int MISO_GPIO, int MOSI_GPIO, int SCLK_GPIO, int CS_GPIO, int INT_GPIO, int SPI_CLOCK_MHZ, + // int SPI_HOST, uint8_t *ENC28J60_Mac = ENC28J60_Default_Mac); + //ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST ); + ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST, mac[index] ); + + // Static IP, leave without this line to get IP via DHCP + //bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = 0, IPAddress dns2 = 0); + ETH.config(myIP, myGW, mySN, myDNS); + + ESP32_ENC_waitForConnect(); + + /////////////////////////////////// + + + Serial.print("\nConnected to network. IP = "); + Serial.println(ETH.localIP()); + + for (serverIndex = 0; serverIndex < NUM_SERVERS; serverIndex++) + { + multiServer[serverIndex] = new AsyncWebServer(http_port[serverIndex]); + + if (multiServer[serverIndex]) + { + Serial.printf("Initialize multiServer OK, serverIndex = %d, port = %d\n", serverIndex, http_port[serverIndex]); + } + else + { + Serial.printf("Error initialize multiServer, serverIndex = %d\n", serverIndex); + + while (1); + } + + multiServer[serverIndex]->on("/", HTTP_GET, [](AsyncWebServerRequest * request) + { + handleRoot(request); + }); + + multiServer[serverIndex]->on("/hello", HTTP_GET, [](AsyncWebServerRequest * request) + { + String message = F("Hello from AsyncMultiWebServer_ESP32_ENC using ENC28J60 Ethernet, running on "); + message += BOARD_NAME; + + request->send(200, "text/plain", message); + }); + + multiServer[serverIndex]->onNotFound([](AsyncWebServerRequest * request) + { + handleNotFound(request); + }); + + multiServer[serverIndex]->begin(); + + Serial.printf("HTTP server started at ports %d\n", http_port[serverIndex]); + } +} + +void loop() +{ +} diff --git a/examples/AsyncSimpleServer_ESP32_ENC/AsyncSimpleServer_ESP32_ENC.ino b/examples/AsyncSimpleServer_ESP32_ENC/AsyncSimpleServer_ESP32_ENC.ino new file mode 100644 index 0000000..a9f4d51 --- /dev/null +++ b/examples/AsyncSimpleServer_ESP32_ENC/AsyncSimpleServer_ESP32_ENC.ino @@ -0,0 +1,171 @@ +/**************************************************************************************************************************** + AsyncSimpleServer_ESP32_ENC.ino + + For ENC28J60 Ethernet in ESP32 (ESP32 + ENC28J60) + + AsyncWebServer_ESP32_ENC is a library for the Ethernet ENC28J60 in ESSP32 to run AsyncWebServer + + Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer) + Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC + Licensed under GPLv3 license + *****************************************************************************************************************************/ + +#if !( defined(ESP32) ) + #error This code is designed for ESP32_ENC to run on ESP32 platform! Please check your Tools->Board setting. +#endif + +#includeAsyncWebServer_SendChunked_ESP32_ENC!
\ +running on %s
\ +Uptime: %d d %02d:%02d:%02d
\ +\ +", BOARD_NAME, BOARD_NAME, day, hr % 24, min % 60, sec % 60); + + pageInput = temp; +} + +void handleNotFound(AsyncWebServerRequest *request) +{ + 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); +} + +String out; + +void handleRoot(AsyncWebServerRequest *request) +{ + out.reserve(STRING_SIZE); + char temp[70]; + + // clear the String to start over + out = String(); + + createPage(out); + + out += "\r\n| INDEX | DATA |
|---|---|
| "; + out += String(lineIndex); + out += " | "; + out += "ESP32_ENC_AsyncWebServer_SendChunked_ABCDEFGHIJKLMNOPQRSTUVWXYZ |
AsyncWebServer_ESP32_ENC!
\ +running on %s
\ +Uptime: %d d %02d:%02d:%02d
\ +![](\"/test.svg\")
\
+\
+", BOARD_NAME, BOARD_NAME, day, hr % 24, min % 60, sec % 60);
+
+ request->send(200, "text/html", temp);
+}
+
+void handleNotFound(AsyncWebServerRequest *request)
+{
+ 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);
+}
+
+void drawGraph(AsyncWebServerRequest *request)
+{
+ String out;
+
+ out.reserve(3000);
+ char temp[70];
+
+ out += "\n";
+
+ request->send(200, "image/svg+xml", out);
+}
+
+
+void setup()
+{
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(200);
+
+ Serial.print(F("\nStart AsyncSimpleServer_ESP32_ENC on "));
+ Serial.print(BOARD_NAME);
+ Serial.print(F(" with "));
+ Serial.println(SHIELD_TYPE);
+ Serial.println(ASYNC_WEBSERVER_ESP32_ENC_VERSION);
+
+ AWS_LOGWARN(F("Default SPI pinout:"));
+ AWS_LOGWARN1(F("MOSI:"), MOSI_GPIO);
+ AWS_LOGWARN1(F("MISO:"), MISO_GPIO);
+ AWS_LOGWARN1(F("SCK:"), SCK_GPIO);
+ AWS_LOGWARN1(F("CS:"), CS_GPIO);
+ AWS_LOGWARN1(F("INT:"), INT_GPIO);
+ AWS_LOGWARN1(F("SPI Clock (MHz):"), SPI_CLOCK_MHZ);
+ AWS_LOGWARN(F("========================="));
+
+ ///////////////////////////////////
+
+ // To be called before ETH.begin()
+ ESP32_ENC_onEvent();
+
+ // start the ethernet connection and the server:
+ // Use DHCP dynamic IP and random mac
+ uint16_t index = millis() % NUMBER_OF_MAC;
+
+ //bool begin(int MISO_GPIO, int MOSI_GPIO, int SCLK_GPIO, int CS_GPIO, int INT_GPIO, int SPI_CLOCK_MHZ,
+ // int SPI_HOST, uint8_t *ENC28J60_Mac = ENC28J60_Default_Mac);
+ //ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST );
+ ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST, mac[index] );
+
+ // Static IP, leave without this line to get IP via DHCP
+ //bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = 0, IPAddress dns2 = 0);
+ ETH.config(myIP, myGW, mySN, myDNS);
+
+ ESP32_ENC_waitForConnect();
+
+ ///////////////////////////////////
+
+ 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(ETH.localIP());
+}
+
+void loop()
+{
+}
diff --git a/examples/Async_AdvancedWebServer_MemoryIssues_SendArduinoString/Async_AdvancedWebServer_MemoryIssues_SendArduinoString.ino b/examples/Async_AdvancedWebServer_MemoryIssues_SendArduinoString/Async_AdvancedWebServer_MemoryIssues_SendArduinoString.ino
new file mode 100644
index 0000000..ac7a6a4
--- /dev/null
+++ b/examples/Async_AdvancedWebServer_MemoryIssues_SendArduinoString/Async_AdvancedWebServer_MemoryIssues_SendArduinoString.ino
@@ -0,0 +1,334 @@
+/****************************************************************************************************************************
+ Async_AdvancedWebServer_MemoryIssues_SendArduinoString.ino
+
+ For ENC28J60 Ethernet in ESP32 (ESP32 + ENC28J60)
+
+ AsyncWebServer_ESP32_ENC is a library for the Ethernet ENC28J60 in ESSP32 to run AsyncWebServer
+
+ Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer)
+ Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC
+ Licensed under GPLv3 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.
+ *****************************************************************************************************************************/
+
+#if !( defined(ESP32) )
+ #error This code is designed for (ESP32 + ENC28J60) to run on ESP32 platform! Please check your Tools->Board setting.
+#endif
+
+#include AsyncWebServer_ESP32_ENC!
\ +running on %s
\ +Uptime: %d d %02d:%02d:%02d
\ +\
+\
+", BOARD_NAME, BOARD_NAME, day, hr % 24, min % 60, sec % 60);
+
+ request->send(200, "text/html", temp);
+}
+
+void handleNotFound(AsyncWebServerRequest *request)
+{
+ 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);
+}
+
+void PrintHeapData(String hIn)
+{
+ static uint32_t maxFreeHeap = 0xFFFFFFFF;
+ static uint32_t totalHeap = ESP.getHeapSize();
+
+ uint32_t freeHeap = ESP.getFreeHeap();
+
+ // Print and update only when larger heap
+ if (maxFreeHeap > freeHeap)
+ {
+ maxFreeHeap = freeHeap;
+
+ Serial.print("\nHEAP DATA - ");
+ Serial.print(hIn);
+
+ Serial.print(" Max heap: ");
+ Serial.print(totalHeap);
+ Serial.print(" Free heap: ");
+ Serial.print(ESP.getFreeHeap());
+ Serial.print(" Used heap: ");
+ Serial.println(totalHeap - freeHeap);
+ }
+}
+
+void PrintStringSize(String & out)
+{
+ static uint32_t count = 0;
+
+ // Print only when cStr length too large and corrupting memory or every (20 * 5) s
+ if ( (out.length() >= STRING_SIZE) || (++count > 20) )
+ {
+ Serial.print("\nOut String Length=");
+ Serial.println(out.length());
+
+ count = 0;
+ }
+}
+
+void drawGraph(AsyncWebServerRequest *request)
+{
+ String out;
+
+ out.reserve(STRING_SIZE);
+ char temp[70];
+
+ out += "\n";
+
+ PrintHeapData("Pre Send");
+
+ PrintStringSize(out);
+
+ request->send(200, "image/svg+xml", out);
+
+ PrintHeapData("Post Send");
+}
+
+void setup()
+{
+ 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_ESP32_ENC_VERSION);
+
+ AWS_LOGWARN(F("Default SPI pinout:"));
+ AWS_LOGWARN1(F("MOSI:"), MOSI_GPIO);
+ AWS_LOGWARN1(F("MISO:"), MISO_GPIO);
+ AWS_LOGWARN1(F("SCK:"), SCK_GPIO);
+ AWS_LOGWARN1(F("CS:"), CS_GPIO);
+ AWS_LOGWARN1(F("INT:"), INT_GPIO);
+ AWS_LOGWARN1(F("SPI Clock (MHz):"), SPI_CLOCK_MHZ);
+ AWS_LOGWARN(F("========================="));
+
+ ///////////////////////////////////
+
+ // To be called before ETH.begin()
+ ESP32_ENC_onEvent();
+
+ // start the ethernet connection and the server:
+ // Use DHCP dynamic IP and random mac
+ uint16_t index = millis() % NUMBER_OF_MAC;
+
+ //bool begin(int MISO_GPIO, int MOSI_GPIO, int SCLK_GPIO, int CS_GPIO, int INT_GPIO, int SPI_CLOCK_MHZ,
+ // int SPI_HOST, uint8_t *ENC28J60_Mac = ENC28J60_Default_Mac);
+ //ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST );
+ ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST, mac[index] );
+
+ // Static IP, leave without this line to get IP via DHCP
+ //bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = 0, IPAddress dns2 = 0);
+ ETH.config(myIP, myGW, mySN, myDNS);
+
+ ESP32_ENC_waitForConnect();
+
+ ///////////////////////////////////
+
+
+ ///////////////////////////////////
+
+ 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(ETH.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();
+}
diff --git a/examples/Async_AdvancedWebServer_MemoryIssues_Send_CString/Async_AdvancedWebServer_MemoryIssues_Send_CString.ino b/examples/Async_AdvancedWebServer_MemoryIssues_Send_CString/Async_AdvancedWebServer_MemoryIssues_Send_CString.ino
new file mode 100644
index 0000000..a950052
--- /dev/null
+++ b/examples/Async_AdvancedWebServer_MemoryIssues_Send_CString/Async_AdvancedWebServer_MemoryIssues_Send_CString.ino
@@ -0,0 +1,344 @@
+/****************************************************************************************************************************
+ Async_AdvancedWebServer_MemoryIssues_Send_CString.ino
+
+ For ENC28J60 Ethernet in ESP32 (ESP32 + ENC28J60)
+
+ AsyncWebServer_ESP32_ENC is a library for the Ethernet ENC28J60 in ESSP32 to run AsyncWebServer
+
+ Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer)
+ Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC
+ Licensed under GPLv3 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.
+ *****************************************************************************************************************************/
+
+#if !( defined(ESP32) )
+ #error This code is designed for (ESP32 + ENC28J60) to run on ESP32 platform! Please check your Tools->Board setting.
+#endif
+
+#include AsyncWebServer_ESP32_ENC!
\ +running on %s
\ +Uptime: %d d %02d:%02d:%02d
\ +\
+\
+", BOARD_NAME, BOARD_NAME, day, hr % 24, min % 60, sec % 60);
+
+ request->send(200, "text/html", temp);
+}
+
+void handleNotFound(AsyncWebServerRequest *request)
+{
+ 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);
+}
+
+void PrintHeapData(String hIn)
+{
+ static uint32_t maxFreeHeap = 0xFFFFFFFF;
+ static uint32_t totalHeap = ESP.getHeapSize();
+
+ uint32_t freeHeap = ESP.getFreeHeap();
+
+ // Print and update only when larger heap
+ if (maxFreeHeap > freeHeap)
+ {
+ maxFreeHeap = freeHeap;
+
+ Serial.print("\nHEAP DATA - ");
+ Serial.print(hIn);
+
+ Serial.print(" Max heap: ");
+ Serial.print(totalHeap);
+ Serial.print(" Free heap: ");
+ Serial.print(ESP.getFreeHeap());
+ Serial.print(" Used heap: ");
+ Serial.println(totalHeap - freeHeap);
+ }
+}
+
+void PrintStringSize(const char* cStr)
+{
+ Serial.print("\nOut String Length=");
+ Serial.println(strlen(cStr));
+}
+
+void drawGraph(AsyncWebServerRequest *request)
+{
+ char temp[80];
+
+ cStr[0] = '\0';
+
+ strcat(cStr, "\n");
+
+ PrintHeapData("Pre Send");
+
+ // Print only when cStr length too large and corrupting memory
+ if ( (strlen(cStr) >= CSTRING_SIZE))
+ {
+ PrintStringSize(cStr);
+ }
+
+ request->send(200, "image/svg+xml", cStr, false);
+
+ PrintHeapData("Post Send");
+}
+
+void setup()
+{
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(200);
+
+ Serial.print("\nStart Async_AdvancedWebServer_MemoryIssues_Send_CString on ");
+ Serial.print(BOARD_NAME);
+ Serial.print(" with ");
+ Serial.println(SHIELD_TYPE);
+ Serial.println(ASYNC_WEBSERVER_ESP32_ENC_VERSION);
+
+ AWS_LOGWARN(F("Default SPI pinout:"));
+ AWS_LOGWARN1(F("MOSI:"), MOSI_GPIO);
+ AWS_LOGWARN1(F("MISO:"), MISO_GPIO);
+ AWS_LOGWARN1(F("SCK:"), SCK_GPIO);
+ AWS_LOGWARN1(F("CS:"), CS_GPIO);
+ AWS_LOGWARN1(F("INT:"), INT_GPIO);
+ AWS_LOGWARN1(F("SPI Clock (MHz):"), SPI_CLOCK_MHZ);
+ AWS_LOGWARN(F("========================="));
+
+ ///////////////////////////////////
+
+ cStr = (char *) malloc(CSTRING_SIZE); // make a little larger than required
+
+ if (cStr == NULL)
+ {
+ Serial.println("Unable top Allocate RAM");
+
+ for (;;);
+ }
+
+ ///////////////////////////////////
+
+ // To be called before ETH.begin()
+ ESP32_ENC_onEvent();
+
+ // start the ethernet connection and the server:
+ // Use DHCP dynamic IP and random mac
+ uint16_t index = millis() % NUMBER_OF_MAC;
+
+ //bool begin(int MISO_GPIO, int MOSI_GPIO, int SCLK_GPIO, int CS_GPIO, int INT_GPIO, int SPI_CLOCK_MHZ,
+ // int SPI_HOST, uint8_t *ENC28J60_Mac = ENC28J60_Default_Mac);
+ //ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST );
+ ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST, mac[index] );
+
+ // Static IP, leave without this line to get IP via DHCP
+ //bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = 0, IPAddress dns2 = 0);
+ ETH.config(myIP, myGW, mySN, myDNS);
+
+ ESP32_ENC_waitForConnect();
+
+ ///////////////////////////////////
+
+
+ ///////////////////////////////////
+
+ 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(ETH.localIP());
+
+ PrintHeapData("Pre Create Arduino String");
+}
+
+void heartBeatPrint()
+{
+ static int num = 1;
+
+ Serial.print(F("."));
+
+ if (num == 80)
+ {
+ //Serial.println();
+ PrintStringSize(cStr);
+ 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();
+}
diff --git a/examples/Async_AdvancedWebServer_SendChunked/Async_AdvancedWebServer_SendChunked.ino b/examples/Async_AdvancedWebServer_SendChunked/Async_AdvancedWebServer_SendChunked.ino
new file mode 100644
index 0000000..c35e05f
--- /dev/null
+++ b/examples/Async_AdvancedWebServer_SendChunked/Async_AdvancedWebServer_SendChunked.ino
@@ -0,0 +1,301 @@
+/****************************************************************************************************************************
+ Async_AdvancedWebServer_SendChunked.ino
+
+ For ENC28J60 Ethernet in ESP32 (ESP32 + ENC28J60)
+
+ AsyncWebServer_ESP32_ENC is a library for the Ethernet ENC28J60 in ESSP32 to run AsyncWebServer
+
+ Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer)
+ Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC
+ Licensed under GPLv3 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.
+ *****************************************************************************************************************************/
+
+#if !( defined(ESP32) )
+ #error This code is designed for (ESP32 + ENC28J60) to run on ESP32 platform! Please check your Tools->Board setting.
+#endif
+
+#include Async_AdvancedWebServer_SendChunked!
\ +running on %s
\ +Uptime: %d d %02d:%02d:%02d
\ +\
+\
+", BOARD_NAME, BOARD_NAME, day, hr % 24, min % 60, sec % 60);
+
+ request->send(200, "text/html", temp);
+}
+
+void handleNotFound(AsyncWebServerRequest *request)
+{
+ 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);
+}
+
+String out;
+
+void drawGraph(AsyncWebServerRequest *request)
+{
+ out.reserve(STRING_SIZE);
+ char temp[70];
+
+ out = String();
+
+ out += "\n";
+
+ AWS_LOGDEBUG1("Total length to send in chunks =", out.length());
+
+ AsyncWebServerResponse *response = request->beginChunkedResponse("image/svg+xml", [](uint8_t *buffer, size_t maxLen,
+ size_t filledLength) -> size_t
+ {
+ size_t len = min(maxLen, out.length() - filledLength);
+ memcpy(buffer, out.c_str() + filledLength, len);
+
+ AWS_LOGDEBUG1("Bytes sent in chunk =", len);
+
+ return len;
+ });
+
+ request->send(response);
+}
+
+
+void setup()
+{
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(200);
+
+ Serial.print("\nStart Async_AdvancedWebServer_SendChunked on ");
+ Serial.print(BOARD_NAME);
+ Serial.print(" with ");
+ Serial.println(SHIELD_TYPE);
+ Serial.println(ASYNC_WEBSERVER_ESP32_ENC_VERSION);
+
+ AWS_LOGWARN(F("Default SPI pinout:"));
+ AWS_LOGWARN1(F("MOSI:"), MOSI_GPIO);
+ AWS_LOGWARN1(F("MISO:"), MISO_GPIO);
+ AWS_LOGWARN1(F("SCK:"), SCK_GPIO);
+ AWS_LOGWARN1(F("CS:"), CS_GPIO);
+ AWS_LOGWARN1(F("INT:"), INT_GPIO);
+ AWS_LOGWARN1(F("SPI Clock (MHz):"), SPI_CLOCK_MHZ);
+ AWS_LOGWARN(F("========================="));
+
+ ///////////////////////////////////
+
+ // To be called before ETH.begin()
+ ESP32_ENC_onEvent();
+
+ // start the ethernet connection and the server:
+ // Use DHCP dynamic IP and random mac
+ uint16_t index = millis() % NUMBER_OF_MAC;
+
+ //bool begin(int MISO_GPIO, int MOSI_GPIO, int SCLK_GPIO, int CS_GPIO, int INT_GPIO, int SPI_CLOCK_MHZ,
+ // int SPI_HOST, uint8_t *ENC28J60_Mac = ENC28J60_Default_Mac);
+ //ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST );
+ ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST, mac[index] );
+
+ // Static IP, leave without this line to get IP via DHCP
+ //bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = 0, IPAddress dns2 = 0);
+ //ETH.config(myIP, myGW, mySN, myDNS);
+
+ ESP32_ENC_waitForConnect();
+
+ ///////////////////////////////////
+
+ 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("AsyncWebServer is @ IP : "));
+ Serial.println(ETH.localIP());
+}
+
+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();
+}
diff --git a/examples/Async_HelloServer/Async_HelloServer.ino b/examples/Async_HelloServer/Async_HelloServer.ino
new file mode 100644
index 0000000..2ba8cc4
--- /dev/null
+++ b/examples/Async_HelloServer/Async_HelloServer.ino
@@ -0,0 +1,167 @@
+/****************************************************************************************************************************
+ Async_HelloServer.h
+
+ For ENC28J60 Ethernet in ESP32 (ESP32 + ENC28J60)
+
+ AsyncWebServer_ESP32_ENC is a library for the Ethernet ENC28J60 in ESSP32 to run AsyncWebServer
+
+ Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer)
+ Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC
+ Licensed under GPLv3 license
+ *****************************************************************************************************************************/
+
+#if !( defined(ESP32) )
+ #error This code is designed for (ESP32 + ENC28J60) to run on ESP32 platform! Please check your Tools->Board setting.
+#endif
+
+#include POST plain text to /postplain/
\ +\ +
POST form data to /postform/
\ +\ +\ +"; + +void handleRoot(AsyncWebServerRequest *request) +{ + digitalWrite(led, 1); + request->send(200, "text/html", postForms); + digitalWrite(led, 0); +} + +void handlePlain(AsyncWebServerRequest *request) +{ + if (request->method() != HTTP_POST) + { + digitalWrite(led, 1); + request->send(405, "text/plain", "Method Not Allowed"); + digitalWrite(led, 0); + } + else + { + digitalWrite(led, 1); + request->send(200, "text/plain", "POST body was:\n" + request->arg("plain")); + digitalWrite(led, 0); + } +} + +void handleForm(AsyncWebServerRequest *request) +{ + if (request->method() != HTTP_POST) + { + digitalWrite(led, 1); + request->send(405, "text/plain", "Method Not Allowed"); + digitalWrite(led, 0); + } + else + { + digitalWrite(led, 1); + String message = "POST form was:\n"; + + for (uint8_t i = 0; i < request->args(); i++) + { + message += " " + request->argName(i) + ": " + request->arg(i) + "\n"; + } + + request->send(200, "text/plain", message); + 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 setup() +{ + pinMode(led, OUTPUT); + digitalWrite(led, 0); + + Serial.begin(115200); + + while (!Serial && millis() < 5000); + + delay(200); + + Serial.print(F("\nStart Async_PostServer on ")); + Serial.print(BOARD_NAME); + Serial.print(F(" with ")); + Serial.println(SHIELD_TYPE); + Serial.println(ASYNC_WEBSERVER_ESP32_ENC_VERSION); + + AWS_LOGWARN(F("Default SPI pinout:")); + AWS_LOGWARN1(F("MOSI:"), MOSI_GPIO); + AWS_LOGWARN1(F("MISO:"), MISO_GPIO); + AWS_LOGWARN1(F("SCK:"), SCK_GPIO); + AWS_LOGWARN1(F("CS:"), CS_GPIO); + AWS_LOGWARN1(F("INT:"), INT_GPIO); + AWS_LOGWARN1(F("SPI Clock (MHz):"), SPI_CLOCK_MHZ); + AWS_LOGWARN(F("=========================")); + + /////////////////////////////////// + + // To be called before ETH.begin() + ESP32_ENC_onEvent(); + + // start the ethernet connection and the server: + // Use DHCP dynamic IP and random mac + uint16_t index = millis() % NUMBER_OF_MAC; + + //bool begin(int MISO_GPIO, int MOSI_GPIO, int SCLK_GPIO, int CS_GPIO, int INT_GPIO, int SPI_CLOCK_MHZ, + // int SPI_HOST, uint8_t *ENC28J60_Mac = ENC28J60_Default_Mac); + //ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST ); + ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, SPI_HOST, mac[index] ); + + // Static IP, leave without this line to get IP via DHCP + //bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = 0, IPAddress dns2 = 0); + ETH.config(myIP, myGW, mySN, myDNS); + + ESP32_ENC_waitForConnect(); + + /////////////////////////////////// + + + server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) + { + handleRoot(request); + }); + + //server.on("/postplain/", handlePlain); + server.on("/postplain/", HTTP_POST, [](AsyncWebServerRequest * request) + { + handlePlain(request); + }); + + //server.on("/postform/", handleForm); + server.on("/postform/", HTTP_POST, [](AsyncWebServerRequest * request) + { + handleForm(request); + }); + + server.onNotFound(handleNotFound); + + server.begin(); + + Serial.print(F("HTTP EthernetWebServer started @ IP : ")); + Serial.println(ETH.localIP()); +} + +void loop() +{ +} diff --git a/examples/Async_RegexPatterns_ESP32_ENC/Async_RegexPatterns_ESP32_ENC.ino b/examples/Async_RegexPatterns_ESP32_ENC/Async_RegexPatterns_ESP32_ENC.ino new file mode 100644 index 0000000..90b6392 --- /dev/null +++ b/examples/Async_RegexPatterns_ESP32_ENC/Async_RegexPatterns_ESP32_ENC.ino @@ -0,0 +1,174 @@ +/**************************************************************************************************************************** + Async_RegexPatterns_ESP32_ENC.ino + + For ENC28J60 Ethernet in ESP32 (ESP32 + ENC28J60) + + AsyncWebServer_ESP32_ENC is a library for the Ethernet ENC28J60 in ESSP32 to run AsyncWebServer + + Based on and modified from ESPAsyncWebServer (https://github.com/me-no-dev/ESPAsyncWebServer) + Built by Khoi Hoang https://github.com/khoih-prog/AsyncWebServer_ESP32_ENC + Licensed under GPLv3 license + *****************************************************************************************************************************/ +// +// A simple server implementation with regex routes: +// * serve static messages +// * read GET and POST parameters +// * handle missing pages / 404s +// +// Add buildflag ASYNCWEBSERVER_REGEX to enable the regex support +// +// For platformio: platformio.ini: +// build_flags = +// -DASYNCWEBSERVER_REGEX +// +// For arduino IDE: create/update platform.local.txt +// Windows: C:\Users\(username)\AppData\Local\Arduino15\packages\espxxxx\hardware\espxxxx\{version}\platform.local.txt +// Linux: ~/.arduino15/packages/espxxxx/hardware/espxxxx/{version}/platform.local.txt +// +// compiler.cpp.extra_flags=-DASYNCWEBSERVER_REGEX=1 + +#define ASYNCWEBSERVER_REGEX true + +#if !( defined(ESP32) ) + #error This code is designed for ESP32_ENC to run on ESP32 platform! Please check your Tools->Board setting. +#endif + +#include