This repository has been archived by the owner on Feb 4, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 0
/
AsyncMultiWebServer_ESP32_ENC.ino
257 lines (194 loc) · 7.34 KB
/
AsyncMultiWebServer_ESP32_ENC.ino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
/****************************************************************************************************************************
AsyncMultiWebServer_ESP32_ENC.ino
For LwIP ENC28J60 Ethernet in ESP32_SC_ENC (ESP32_S2/3, ESP32_C3 + LwIP ENC28J60)
AsyncWebServer_ESP32_SC_ENC is a library for the LwIP Ethernet ENC28J60 in ESP32_S2/S3/C3 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_SC_ENC
Licensed under GPLv3 license
*****************************************************************************************************************************/
#if !( defined(ESP32) )
#error This code is designed for (ESP32_S2/3, ESP32_C3 + LwIP ENC28J60) to run on ESP32 platform! Please check your Tools->Board setting.
#endif
#include <Arduino.h>
#define _ASYNC_WEBSERVER_LOGLEVEL_ 4
// Enter a MAC address and IP address for your controller below.
#define NUMBER_OF_MAC 20
byte mac[][NUMBER_OF_MAC] =
{
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x01 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x02 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x03 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x04 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x05 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x06 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x07 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x08 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x09 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x0A },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x0B },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x0C },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x0D },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x0E },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x0F },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x10 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x11 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x12 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x13 },
{ 0xDE, 0xAD, 0xBE, 0xEF, 0xBE, 0x14 },
};
// Select the IP address according to your local network
IPAddress myIP(192, 168, 2, 232);
IPAddress myGW(192, 168, 2, 1);
IPAddress mySN(255, 255, 255, 0);
// Google DNS Server IP
IPAddress myDNS(8, 8, 8, 8);
//////////////////////////////////////////////////////////
// For ENC28J60 & ESP32-S3
// Optional values to override default settings
// Don't change unless you know what you're doing
//#define ETH_SPI_HOST SPI3_HOST
//#define SPI_CLOCK_MHZ 8
// Must connect INT to GPIOxx or not working
//#define INT_GPIO 4
//#define MISO_GPIO 13
//#define MOSI_GPIO 11
//#define SCK_GPIO 12
//#define CS_GPIO 10
//////////////////////////////////////////////////////////
#include <AsyncTCP.h>
#include <AsyncWebServer_ESP32_SC_ENC.h>
unsigned int analogReadPin [] = { 12, 13, 14 };
#define BUFFER_SIZE 500
#define HTTP_PORT1 8080
#define HTTP_PORT2 8081
#define HTTP_PORT3 8082
AsyncWebServer* server1;
AsyncWebServer* server2;
AsyncWebServer* server3;
AsyncWebServer* multiServer [] = { server1, server2, server3 };
uint16_t http_port [] = { HTTP_PORT1, HTTP_PORT2, HTTP_PORT3 };
#define NUM_SERVERS ( sizeof(multiServer) / sizeof(AsyncWebServer*) )
unsigned int serverIndex;
String createBuffer()
{
char temp[BUFFER_SIZE];
memset(temp, 0, sizeof(temp));
int sec = millis() / 1000;
int min = sec / 60;
int hr = min / 60;
int day = hr / 24;
snprintf(temp, BUFFER_SIZE - 1,
"<html>\
<head>\
<meta http-equiv='refresh' content='5'/>\
<title>%s</title>\
<style>\
body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }\
</style>\
</head>\
<body>\
<h1>Hello from %s</h1>\
<h2>running AsyncMultiWebServer_ESP32_SC_ENC</h2>\
<h3>on %s</h3>\
<h3>Uptime: %d d %02d:%02d:%02d</h3>\
</body>\
</html>", ARDUINO_BOARD, ARDUINO_BOARD, 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(500);
Serial.print(F("\nStart AsyncMultiWebServer_ESP32_ENC on "));
Serial.print(ARDUINO_BOARD);
Serial.print(F(" with "));
Serial.println(SHIELD_TYPE);
Serial.println(ASYNC_WEBSERVER_ESP32_SC_ENC_VERSION);
AWS_LOGWARN(F("Default SPI pinout:"));
AWS_LOGWARN1(F("SPI Host:"), ETH_SPI_HOST);
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, ETH_SPI_HOST );
ETH.begin( MISO_GPIO, MOSI_GPIO, SCK_GPIO, CS_GPIO, INT_GPIO, SPI_CLOCK_MHZ, ETH_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 += ARDUINO_BOARD;
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()
{
}