Bản hợp đồng cho mạng của Mokxi: một sketch có thể làm gì, điều gì là trung thực, và điều gì không hề tồn tại. Hợp đồng riêng của từng bo mạch có bảng thanh ghi (docs/esp32c3.md 3.8, docs/esp32c6.md 3.8, docs/esp32.md 3.8, docs/esp32s3.md 3.10, docs/esp8266.md 3.9, docs/picow.md 3.8). crates/net là mô hình; tệp này có hiệu lực cao hơn tất cả chúng.
Một câu thôi
The radio is simulated. There is no 802.11, there is no real internet, and
the WiFi runtime is Mokxi's own. Nothing in Mokxi transmits, receives, scans,
associates, encrypts or opens a socket to the outside (boards of one project
can open TCP connections to each other, below). A password is compared as a string. The
only names that resolve are four made-up ones under .mokxi and the board's
own address, and nothing a sketch does can reach the network the browser is on.
Every page that mentions WiFi says this, in the properties panel, in the Web and
Cloud panels' first line, in the help article, on the board page, and in the
examples themselves.
Ngoại lệ duy nhất là tùy chọn và luôn tắt ở mỗi lần tải trang: chế độ internet thật (bên dưới), trong đó trang, chứ không phải engine, gửi các yêu cầu của sketch cho các tên ngoài .mokxi qua cổng kết nối của chúng tôi, dành cho người đã đăng nhập (một mức dùng nhỏ trên gói Free, nhiều hơn với Pro). Khi tắt, vốn là mặc định và là chế độ duy nhất khi chưa đăng nhập, mọi câu trên vẫn đúng nguyên văn. Một bo mạch tham gia Wokwi-GUEST sẽ bật chế độ này khi bắt đầu chạy.
Vì sao là một hộp thư, và vì sao điều đó là trung thực
Trên ESP32 thật, phần cứng WiFi không phải là một bộ thanh ghi được ghi chép. Nó là một blob nhị phân đóng với giao diện lệnh, và mỗi dòng của WiFi.h trong Arduino đều kết thúc ở phía bên kia của một giao diện như vậy. Vậy nên mô hình là một hộp thư: một thanh ghi lệnh, một thanh ghi trạng thái, một bộ đệm vòng mỗi chiều và một bit ngắt, tại 0x6FFF_E000 trên ESP32-C3: khối riêng của Mokxi, không phải của chip, trên mọi ngoại vi thật, tại một địa chỉ mà C3 thật để trống, để một ảnh dùng nó sẽ lỗi trên silicon thay vì đọc thanh ghi của thứ khác.
Đó là toàn bộ điều bịa, và nó có cùng hình dạng với sự thật. Điều nó không là một MAC 802.11 giả: không có frame, không có kênh, không có tốc số liệu, không có khoảng beacon ở bất kỳ đâu trong code này, vì một mô hình của những thứ đó sẽ là một phát minh không có gì để đối chiếu.
Sáu bo mạch, và con số duy nhất khác nhau
Khối này không phụ thuộc bo mạch. crates/net không biết gì về bo mạch nào; SoC chọn một con số, địa chỉ cơ sở, và chuyển tiếp các truy cập từ. Sáu bo mạch làm vậy, và chúng chính là sáu bo có vô tuyến trên phần cứng thật:
| bo mạch | hộp thư nằm tại | phần thật có gì tại đó |
|---|---|---|
| ESP32-C3 DevKitM-1 | 0x6FFF_E000 |
không có gì: các ngoại vi của nó dừng lại thấp hơn nhiều |
| ESP32-C6-DevKitC-1 | 0x6FFF_E000 |
không có gì: cùng vị trí đó cũng trống trên phần này |
| ESP32 DevKit (WROOM-32) | 0x3FEF_E000 |
một khoảng dành riêng giữa các cửa sổ bộ nhớ ngoài và cửa sổ ngoại vi |
| ESP32-S3-DevKitC-1 | 0x6FFF_E000 |
không có gì: các ngoại vi kết thúc tại 0x600D_0FFF và bộ nhớ RTC FAST tại 0x600F_FFFF |
| ESP8266 NodeMCU | 0x6FFF_E000 |
không có gì: các khối thật của nó đều nằm trong vài kilobyte đầu tiên của cửa sổ đó |
| Raspberry Pi Pico W | 0x4FFF_E000 |
không có gì: trên mọi ngoại vi APB, dưới AHB-Lite |
Trên Pico W điểm nối có cùng hình dạng nhưng vì lý do khác: phần vô tuyến là một CYW43439 ở phía bên kia một liên kết kiểu SPI ba chân được điều khiển bởi một blob nhị phân đóng, thứ cũng chẳng phải bộ thanh ghi được ghi chép trên RP2040 hơn gì vô tuyến của ESP32 trên die của nó. Một giao diện lệnh là thứ thực sự có ở đó. (Các firmware MicroPython và CircuitPython chính thức cho Pico W tự điều khiển chip, và với chúng chip được mô hình hóa từ các chân của nó thay vì như vậy, với hộp thư không được ánh xạ: docs/cyw43.md.)
firmware/include/mokxi_net.h là định nghĩa duy nhất của mọi thanh ghi, bit và mã lệnh; header của từng bo mạch định nghĩa địa chỉ cơ sở và include nó, còn firmware/tools/check_registers.py ép sáu header tuân theo bảng trong hợp đồng của chúng, cả địa chỉ cơ sở. Một ngoại vi bịa đặt chính là thứ cần nhất việc ghim hai nửa lại với nhau.
Every other board refuses. A plain Raspberry Pi Pico, the Uno, the Nano,
the Mega, the Leonardo, the ATtiny85, the XIAO SAMD21, the Uno R4, the STM32s
and the micro:bit have no wireless part on them, so WiFi.h, HTTPClient.h
and WebServer.h fail to compile with a sentence pointing here, rather than
letting a sketch write to an address its chip does not have. A stub that answered
"not connected" would be a lie with a plausible shape; a compile error is not.
The Pico and the Pico W therefore carry different program strings
(elf32 arm rp2040 and elf32 arm rp2040 picow), as the Uno's and the Nano's
do, so the editor offers each board its own examples.
Học sinh có thể làm gì
Join the network
Cùng một code trên cả sáu bo mạch; header là WiFi.h trên tất cả, vì đó là tên của Arduino API trên họ ESP32 và trên Pico W.
#include <WiFi.h>
WiFi.mode(WIFI_STA);
WiFi.begin("Mokxi-Lab", "breadboard");
while (WiFi.status() != WL_CONNECTED) { Serial.print("."); delay(250); }
Serial.println(WiFi.localIP());
SSID và mật khẩu là thuộc tính của bo mạch: nhấn vào bo mạch trong trình soạn thảo và đặt wifiSsid, wifiPassword và wifiRssi. Cả sáu bo mạch đều có cùng ba thuộc tính này, từ crates/parts/src/wifi.rs, với cùng giá trị mặc định và cùng phần kiểm tra hợp lệ. Không có vô tuyến thì không có gì để quét và không có gì để chuyển thiết lập của một linh kiện riêng, nên điểm truy cập duy nhất mà một bo mạch thấy được là một cài đặt trên bo mạch. Bảng Cloud chỉnh cùng ba giá trị này khi sketch đang chạy.
WiFi.status() đi qua WL_IDLE_STATUS, rồi WL_DISCONNECTED trong khi kết nối, rồi WL_CONNECTED, đúng là chuỗi của Arduino, vì Arduino không có WL_CONNECTING và một linh kiện đang kết nối sẽ trả về WL_DISCONNECTED. WiFi.localIP() là 192.168.4.2, gatewayIP() là 192.168.4.1, RSSI() là thuộc tính wifiRssi, SSID() là tên của điểm truy cập còn macAddress() là MAC của chính bo mạch: thiết lập wifiMac của nó, hoặc nếu để trống thì engine tự suy ra từ id của linh kiện (02:4D:4F: và ba byte), giống nhau ở mỗi lần chạy và khác nhau cho từng bo mạch trên khung vẽ, để ESP-NOW phân biệt được chúng (docs/help/editor/esp-now.md).
Nhập sai mật khẩu thì WiFi.status() thành WL_CONNECT_FAILED. Nhập sai tên thì nó thành WL_NO_SSID_AVAIL. WiFi.disconnect() đưa nó về idle, và lần begin() tiếp theo sẽ thuê lại đúng địa chỉ đó.
Tải something
#include <HTTPClient.h>
WiFiClient client;
HTTPClient http;
http.begin(client, "http://weather.mokxi/");
int code = http.GET();
String body = http.getString();
http.end();
Có bốn origin, và không có origin nào khác:
| tên | câu trả lời |
|---|---|
http://time.mokxi/ |
giờ của kernel dạng chuỗi ISO, text/plain |
http://weather.mokxi/ |
JSON chứa nhiệt độ và độ ẩm do bảng Cloud đặt |
http://echo.mokxi/ |
chính phần body bạn đã gửi, gửi trở lại; đây cũng là máy chủ echo WebSocket mô phỏng cho WebSocketsClient |
http://api.mokxi/ |
trạng thái, kiểu nội dung và phần body phản hồi được cấu hình trong bảng Cloud |
http://192.168.4.2/ (và http://board.mokxi/) là máy chủ của chính sketch, là địa chỉ duy nhất mà sketch không thể gọi một cách hữu ích, vì nó sẽ phải tự trả lời chính mình; nó nhận về 404 với thông báo như vậy.
Bất kỳ .mokxi nào khác là 404. Những gì không nằm dưới .mokxi thì không phân giải được gì cả: http.GET() trả về HTTPC_ERROR_CONNECTION_REFUSED và
HTTPClient::errorToString() trả về đúng một câu mà toàn bộ tính năng này xoay quanh: không có internet thật: chỉ các tên dưới .mokxi. https:// trả về
HTTPC_ERROR_NO_TLS.
Phục vụ something
#include <WebServer.h>
WebServer server(80);
server.on("/", [](){ server.send(200, "text/html", "<h1>hello</h1>"); });
server.begin();
// in loop():
server.handleClient();
on(path, handler), onNotFound(), send(code, type, body), arg(name), hasArg(), uri(), method() và handleClient(). Khi không có yêu cầu nào đang chờ, handleClient() chờ 1 ms, giống như của ESP32 core và arduino-pico (của ESP8266 thì không), nên một loop() chỉ phục vụ sẽ rảnh trong delay() và chạy nhanh hơn thời gian thực; enableDelay(false) khiến nó quay liên tục, như trên đó. Vòng lặp thăm dò WiFiServer::available() thì quay liên tục cả trên chip thật lẫn ở đây. Các handler là code của bạn chạy trên core của bo mạch, theo đồng hồ của bo mạch. Bảng Web trong khung dưới chính là trình duyệt cho chúng: thanh địa chỉ tại http://192.168.4.2/, nút Làm mới, và trang được hiển thị trong một khung sandbox với scripts off. Liên kết và gửi form bên trong nó bị chặn lại và chuyển vào mạng mô phỏng, nên "bật LED từ trang web" chạy được từ đầu đến cuối.
Không gì ngoài tab trình duyệt có thể truy cập máy chủ đó. Không có socket lắng nghe. Bảng Web là máy khách duy nhất tồn tại.
Chạy điểm truy cập riêng của bo mạch (soft AP)
#include <WiFi.h>
#include <WebServer.h>
WebServer server(80);
WiFi.mode(WIFI_AP);
WiFi.softAP("MyESP", "12345678"); // true: the access point is up
Serial.println(WiFi.softAPIP()); // 192.168.4.1
server.on("/", [](){ server.send(200, "text/html", "<h1>hello from MyESP</h1>"); });
server.begin();
// in loop(): server.handleClient();
The soft AP is simulated the same way the station is: no beacon goes out, nothing associates, and the password is compared as a string. What is there is the board's own network, the Web panel's phone and any other ESP boards in the project that join it (below). When the access point comes up, the phone joins it 1.5 s later (a phone that has the network saved), and the Web panel shows a row under its address bar, Phone joined MyESP as 192.168.4.2, with Leave; left, the row has the password a phone would type (the sketch's, to start with) and Join. A wrong password is refused, wrong password for MyESP; an open network takes any. While the phone is joined:
- bảng truy cập máy chủ của sketch tại địa chỉ điểm truy cập (
http://192.168.4.1/, hoặc cái màsoftAPConfig()đặt), và thanh địa chỉ tự chuyển đến đó: nhấn Go.WebServer, mộtWiFiServerviết tay,AsyncWebServervà các máy chủ ESP8266, Pico W đều trả lời nó, vàserver.hostHeader()là địa chỉ (hoặc tên) mà bảng yêu cầu; WiFi.softAPgetStationNum()(andWiFi.AP.stationCount()) counts the phone, one less once it leaves (boards that joined count too);WiFi.onEvent()nhận các sự kiện của core theo thứ tự của nó:ARDUINO_EVENT_WIFI_AP_STARTsausoftAP(), rồiARDUINO_EVENT_WIFI_AP_STACONNECTED(MAC của điện thoại,02:50:48:4F:4E:45, aid 1) vàARDUINO_EVENT_WIFI_AP_STAIPASSIGNED(192.168.4.2, địa chỉ ngay sau địa chỉ của điểm truy cập, vì DHCP server của ESP-IDF cấp phát theo thứ tự) mỗi khi có thiết bị kết nối,ARDUINO_EVENT_WIFI_AP_STADISCONNECTED(lý do 8) mỗi khi ngắt kết nối, vàARDUINO_EVENT_WIFI_AP_STOPsausoftAPdisconnect()hoặc khi chuyển sang chế độ không có phần AP. Giống như của station, các sự kiện này được chạy từdelay(), khoảng 100 ms sau khi thay đổi, nên một vòng lặp hỏisoftAPgetStationNum()có thể thấy số lượng trước.
Những gì theo các core: softAP() từ chối tên rỗng và mật khẩu dài một đến bảy ký tự (hoặc trên 63), trả về false và nói lý do một lần trên Serial Monitor; softAPIP() là 0.0.0.0 khi điểm truy cập chưa hoạt động;
softAPConfig() trước hoặc sau softAP() di chuyển nó (và lease của điện thoại sang địa chỉ ngay sau nó), và softAPSubnetMask(), softAPBroadcastIP(),
softAPNetworkID() và softAPSubnetCIDR() theo; WiFi.getMode() là
WIFI_AP sau softAP() riêng, WIFI_AP_STA bằng begin() cũng vậy.
Các bo mạch khác trên khung vẽ cũng tham gia. Các bo ESP trong cùng một dự án dùng chung một sóng mô phỏng (cùng sóng mà ESP-NOW dùng), nên station trên bo này tham gia soft AP của bo khác: WiFi.begin("MyESP", "12345678") với tên và mật khẩu mà bo kia đặt softAP() kết thúc bằng WL_CONNECTED, với địa chỉ thuộc subnet của điểm truy cập (192.168.4.2, rồi .3, theo thứ tự yêu cầu), và softAPgetStationNum() đếm từng bo. Mật khẩu sai thì kết thúc bằng
WL_CONNECT_FAILED; station yêu cầu trước khi điểm truy cập hoạt động sẽ tiếp tục tìm và tham gia khi nó sẵn sàng. HTTPClient reaches the access point's
WebServer at its address (192.168.4.1); an HTTPClient request for any
other address on that network, or for a board with no server, is a refused
connection (-1). WiFiClient và WiFiServer carry TCP from board to board,
stations included (next section). The Web panel's phone still joins by itself and gets its own address, so it
counts as one more station. Not simulated: the access point board's own events
carrying the joined station's MAC and address (they still carry the phone's). A name that is the board's own wifiSsid
setting still joins that built-in network, and sends nothing over the air.
WIFI_AP_STA runs both: the station keeps its lease at 192.168.4.2 and the
simulated internet (HTTPClient, Blynk, real internet mode), and the panel
reaches the board at either address. On the Pico W, arduino-pico có
WiFi.beginAP() là softAP() (WL_CONNECTED khi hoạt động) và điểm truy cập ở 192.168.42.1, or 192.168.4.1 when the station is on too (WIFI_AP_STA), as arduino-pico's beginAP chooses (libraries/WiFi/src/WiFiClass.cpp), unless softAPConfig() đặt một, WiFi.localIP() trả lời ngay tại đó. Trên Uno R4 WiFi, WiFiS3's WiFi.beginAP() trả về WL_AP_LISTENING,
WiFi.config(ip) trước khi nó nêu địa chỉ, và WiFi.status() là
WL_AP_CONNECTED while the phone is joined, as its AP_SimpleWebServer
example waits for. The ESP8266's ESP8266WiFi soft AP là những lệnh gọi giống nhau.
Captive portal hoạt động như trên điện thoại. DNSServer (dns.start(53, "*", WiFi.softAPIP())) cho mạng biết tên nào mà máy chủ của nó trả lời; khi nó đang chạy, điện thoại phân giải mọi tên nó phụ trách về địa chỉ đó, và khi điện thoại tham gia, bảng Web tự mở portal, như điện thoại hiển thị trang đăng nhập của nó: điện thoại hỏi http://connectivitycheck.gstatic.com/generate_204, và onNotFound() của sketch (hoặc lệnh chuyển hướng đến chính địa chỉ của nó) trả lời. Mọi tên gõ vào thanh địa chỉ cũng đến bo mạch. Không có gói DNS nào tồn tại, nên các tên được phân giải dù loop() có gọi processNextRequest() hay không. Các tên .mokxi vẫn đến các trang mô phỏng khi không có máy chủ DNS nào phụ trách chúng, điều mà điện thoại thật trên mạng của bo mạch không làm được.
Under MicroPython (the ESP32, ESP32-S3, ESP32-C3 and ESP32-C6 builds, and
the Pico W's) network.WLAN(network.AP_IF) is the same access point, carried
the way the station is: the firmware's own lwIP and DHCP server run as built,
and the phone is a second IP end in crates/net/src/lan.rs that answers ARP and
opens TCP connections to the board's port 80. ap.config(essid=..., password=..., authmode=...) (ssid and key on the Pico W) and
ap.active(True) bring it up at 192.168.4.1; ap.status('stations') lists the
phone while it is joined; a socket server on port 80 shows in the Web panel and
sees the phone at 192.168.4.2. The phone finds the access point's address from
what the board sends, so ap.ifconfig() moving it is followed. The station's
network is 192.168.4.0/24 too, so to run both under MicroPython give the access
point another address with ap.ifconfig(), as a home router at 192.168.4.1
would make you do on a desk.
Boards talking to each other (TCP between boards)
Boards in one project that share a soft AP can open TCP connections to each
other, as ESP32s on one access point do. One board runs a WiFiServer, another
calls WiFiClient::connect(ip, port) with the address that board holds, and
the two exchange bytes both ways until one of them closes. The server can be a
station or the access point's own board, and the client can be either too. Two
stations reach each other through the access point's board, which passes on
what is meant for one of its other stations, as an access point does.
Server station (the second board in the project):
#include <WiFi.h>
WiFiServer server(5000);
void setup() {
Serial.begin(115200);
WiFi.begin("MyESP", "12345678"); // the name and password the access point board gave softAP()
while (WiFi.status() != WL_CONNECTED) delay(100);
Serial.println(WiFi.localIP()); // for example 192.168.4.2: the client connects here
server.begin();
}
void loop() {
WiFiClient client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
String line = client.readStringUntil('\n');
line.trim();
Serial.println("got: " + line);
client.println("echo: " + line);
}
}
client.stop();
}
}
Client station (the third board):
#include <WiFi.h>
void setup() {
Serial.begin(115200);
WiFi.begin("MyESP", "12345678");
while (WiFi.status() != WL_CONNECTED) delay(100);
WiFiClient client;
// Use the address the server station printed. Stations get 192.168.4.2,
// then .3, in the order they joined.
if (client.connect(IPAddress(192, 168, 4, 2), 5000)) {
client.println("hello");
while (!client.available()) delay(10);
Serial.println(client.readStringUntil('\n')); // echo: hello
client.stop();
} else {
Serial.println("connect failed");
}
}
void loop() {}
What a sketch sees matches the Arduino-ESP32 core:
connect()returns 1 when the server accepts. It returns 0 at once when the address is a board with noWiFiServeron that port, and after the core's three seconds (connect(ip, port, timeout)takes another) when nobody holds the address. A name is not looked up: only a dotted address connects.server.available()returns a client for the next waiting connection, or one that is false.client.connected(),available(),read(),peek(),readStringUntil(),readBytes(),print(),println(),write(),remoteIP(),remotePort(),localPort()andstop()work on it.- When one end closes, the other reads what was sent before the close, then
connected()goes false, as the core's does. A station that leaves its network (WiFi.disconnect()), or that the access point drops, ends its connections the same way. - Bytes arrive in order and none are lost while the link holds. A write waits (up to five seconds) while the radio has a great deal queued, as a full send buffer does.
- The board holds eight sockets. A
WiFiClienthas no destructor here, so one that goes out of scope withoutstop()keeps its connection until its other end closes and a new connection needs the slot. Callstop(). - The same ports serve the Web panel as before: its request reaches
server.available()as the bytes of an HTTP request. A raw connection to a port that only an HTTPWebServerserves is refused, as is a station'sHTTPClientrequest to another station'sWebServer.
What is not carried: UDP (WiFiUDP still sends nothing, below), a connection
to a name, TLS, and TCP to anything outside the project's boards. Two boards
that did not join the same soft AP have no way to reach each other.
Xem điều gì đã xảy ra
Bảng Cloud là tab mạng: mọi yêu cầu bo mạch gửi và mọi yêu cầu trang gửi vào bo mạch, kèm phương thức, URL, trạng thái, nội dung và, khi một yêu cầu thất bại, một dòng nói lý do. Nó cũng mang ba cài đặt của điểm truy cập và hai giá trị weather.mokxi. Nó còn có một phòng thí nghiệm API: chọn trạng thái HTTP, kiểu nội dung và phần thân phản hồi cho api.mokxi, rồi xem yêu cầu kế tiếp mang về đúng phản hồi đó. Giáo viên có thể mô phỏng thành công, đầu vào sai, thiếu dữ liệu và lỗi máy chủ mà không cần khóa API hay phần mềm nào ngoài bài học.
Dùng Blynk
#define BLYNK_TEMPLATE_ID "TMPLxxxxxx"
#define BLYNK_TEMPLATE_NAME "Light Intensity Monitor"
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h> // BlynkSimpleEsp32.h, or BlynkSimpleWifi.h on a Pico W or UNO R4 WiFi
BlynkTimer timer;
BLYNK_WRITE(V1) { digitalWrite(D1, param.asInt()); }
void sendLight() { Blynk.virtualWrite(V0, analogRead(A0)); }
void setup() {
Blynk.begin("token", "Mokxi-Lab", "breadboard");
timer.setInterval(1000L, sendLight);
}
void loop() { Blynk.run(); timer.run(); }
Real Blynk keeps a TCP connection to blynk.cloud, which this network does
not have, so the Blynk server is simulated (crates/net/src/blynk.rs), and
the library is Mokxi's own (firmware/lib/mokxi_blynk.h, the Blynk IoT
library's calls, v1.3). The sketch reaches the server through one mailbox
command, BLYNK, answered at once: there is no wire format and no latency to
model, because there is no wire. The Cloud panel's Blynk section, drawn
once a sketch logs in, is its console: each virtual pin the sketch wrote or
has a BLYNK_WRITE for, its value, who wrote it and when, and a box that sends
a value to it, as the Blynk app's switch or slider would. Blynk.logEvent's
events are listed under it.
Điều gì đi kèm theo thư viện: Blynk.begin() chặn cho đến khi bo mạch lên mạng và đăng nhập xong; BLYNK_WRITE chạy bên trong Blynk.run(), không bao giờ chạy giữa hai dòng của loop(); BLYNK_CONNECTED chạy mỗi lần đăng nhập; Blynk.syncVirtual() và syncAll() gửi các giá trị đã lưu trên máy chủ trở lại vào BLYNK_WRITE; một lệnh ghi khi bo mạch đang ngoại tuyến sẽ bị bỏ, và một giá trị gửi từ panel khi panel ngoại tuyến thì được lưu nhưng không được chuyển đi; một số float được gửi ra với ba chữ số thập phân và một số double với bảy chữ số; một bo mạch rời khỏi mạng sẽ mất máy chủ của nó, và Blynk.run() đăng nhập lại sau năm giây khi đã vào lại mạng. Các datastream vẫn còn sau khi bo mạch khởi động lại, giống như trên một máy chủ thật. BlynkTimer là của thư viện: mười sáu bộ đếm thời gian từ timer.run(). WidgetLED, WidgetTerminal và WidgetLCD ghi vào các chân của chúng như thư viện vẫn làm (WidgetLCD.h cùng các tệp header widget khác mà các sketch cũ thường khai báo theo tên cũng có ở đó); LCD không được vẽ ra, chân của nó hiển thị lệnh clr hoặc p, x, y, text cuối cùng.
Điều gì không: token, ID mẫu và tên máy chủ được hiển thị, không bao giờ được kiểm tra hay tra cứu (không có tài khoản Blynk ở đây); BLYNK_APP_CONNECTED biên dịch được nhưng không bao giờ chạy, vì không gì mở ứng dụng (BLYNK_READ đã biến mất từ Blynk 1.4.0, nên sketch dùng nó sẽ gặp lỗi biên dịch nêu Blynk.virtualWrite() từ BlynkTimer để thay); Blynk.Edgent, OTA và các header _SSL không có ở đây. Giá trị bị giới hạn ở 1024 byte, 64 lệnh ghi chờ một bo mạch không thăm dò, và bảng giữ 20 sự kiện cuối cùng. Lưu lượng của Blynk không có trong log yêu cầu, vì nó sẽ làm đầy log ấy.
Dùng WebSockets (máy chủ echo)
#include <WiFi.h>
#include <WebSocketsClient.h> // the WebSockets library, Markus Sattler
WebSocketsClient webSocket;
void webSocketEvent(WStype_t type, uint8_t *payload, size_t length) {
if (type == WStype_CONNECTED) webSocket.sendTXT("Connected");
if (type == WStype_TEXT) Serial.printf("[WSc] get text: %s\n", payload);
}
void setup() {
// join Mokxi-Lab first
webSocket.begin("echo.mokxi", 80, "/");
webSocket.onEvent(webSocketEvent);
}
void loop() { webSocket.loop(); }
This is not a WebSocket on a wire. A WebSocket is a TCP connection that
outlives its opening HTTP request, and this network has no TCP to a server on the internet. So the
library (firmware/lib/WebSocketsClient.h, the calls of 2.6.1) gives
echo.mokxi one more job: it is the simulated echo server. The first
loop() after begin() makes an HTTP GET to http://echo.mokxi<url>, and
its answer raises WStype_CONNECTED. Each sendTXT() is then an HTTP POST of
the text to that URL, and what the echo site sends back is handed to the
callback from the next loop() as WStype_TEXT, in the order sent;
sendBIN() travels as base64 text and comes back as WStype_BIN, decoded;
sendPing() comes back as WStype_PONG, so enableHeartbeat() keeps the
connection. Every message is a request in the Cloud panel's log, because that
is all it is. A send blocks for the request's 60 ms, where upstream's returns
once the frame is buffered.
Bất kỳ máy chủ nào khác, và beginSSL() đến bất kỳ máy chủ nào, không bao giờ kết nối và không tạo yêu cầu: loop() kích hoạt WStype_DISCONNECTED, thử lại mỗi setReconnectInterval(), và Serial Monitor nói một lần rằng WebSocket đến máy chủ đó cần bo mạch thật. Chế độ internet thật không thay đổi điều đó: cổng chuyển tiếp mang một yêu cầu HTTP và một câu trả lời. WebSocketsServer biên dịch và chạy được, và không máy khách nào kết nối đến nó, vì bảng Web hiển thị các trang với tệp lệnh tắt; nó cũng nói vậy một lần.
Hỏi giờ
#include <WiFiUdp.h>
#include <NTPClient.h>
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "europe.pool.ntp.org", 3600, 60000);
// after WiFi.begin() has connected:
timeClient.begin();
timeClient.update();
Serial.println(timeClient.getFormattedTime()); // "01:00:03"
Đây không phải thời gian thực. NTP là một trao đổi UDP với một máy chủ trên internet, còn mạng này thì không truyền UDP và không kết nối tới máy chủ nào; trình mô phỏng cũng không biết hôm nay là ngày mấy, và bịa ra một ngày thì sẽ là lời nói dối mà học sinh không thể kiểm chứng. Vì vậy NTP được mô phỏng, theo cùng một cách trên mọi bo mạch WiFi: configTime() trên các bo ESP32 và ESP8266, NTP.begin() trên Pico W, và NTPClient (firmware/lib/NTPClient.h, bản phát hành 3.2.1 của arduino-libraries) đều đặt đồng hồ thành chính thời gian của trình mô phỏng: 2026-01-01 00:00:00 UTC (epoch 1767225600) lúc bật nguồn, cộng với số giây bo mạch đã chạy, và đây cũng là giá trị mà http://time.mokxi/ trả về. Mỗi cái đều nói như vậy một lần trên Serial Monitor. getEpochTime() của NTPClient là giá trị đó cộng với offset của nó; update() hỏi khi khoảng thời gian đã trôi qua thì forceUpdate() hỏi ngay lập tức, và cả hai đều được trả lời khi bo mạch còn trên mạng, còn nếu không thì hết thời gian chờ sau khoảng một giây. Không có gói tin nào được gửi: WiFiUDP mà nó nhận vào không được dùng.
Dùng Ethernet có dây (ETH.h, các bo mạch ESP32)
#include <ETH.h>
Network.onEvent(onEvent); // ARDUINO_EVENT_ETH_START, _CONNECTED, _GOT_IP
ETH.begin(); // or the core 2.x / 3.x RMII and W5500 forms
Không có PHY, không có RMII, không có W5500 và không có cáp. ETH.begin() là NET_CMD_ETH của mailbox (thao tác 1): máy trạng thái station tham gia không có SSID và không có mật khẩu, sau WIRED_PS (1.5 s) thì nhận được lease, và mọi thứ chạy trên station (HTTP, server của sketch, Blynk, cổng Internet thực và giới hạn của nó) đều chạy trên đây mà không thay đổi. Có một đường nối duy nhất, nên WiFi.status() đọc được nó bất kể nó khởi động theo cách nào, và WiFi.begin() chuyển nó về WiFi. Khi đường nối là đường có dây, các handler của WiFi.onEvent() và Network.onEvent() nhận các sự kiện ETH của core thay vì của station. ETH.config() được giữ để localIP() báo cáo; bo mạch vẫn trả lời Web panel tại 192.168.4.2. Cáp luôn được cắm.
Những gì được giữ trung thực
- API. Các lời gọi và chữ ký của chúng đúng như những gì học sinh sao chép từ một hướng dẫn ESP32:
WiFi.begin/status/localIP/gatewayIP/RSSI/SSID/ macAddress/disconnect/mode,WiFiClient,HTTPClient::begin/GET/POST/ addHeader/getString/getStream/getSize/end/errorToString,WebServer::on/onNotFound/ begin/handleClient/send/arg/hasArg/uri/method, và các route có mẫu trong đó:UriBraces("/toggle/{}")vớipathArg(0)vàUriGlob("/files/*")(uri/UriBraces.h,uri/UriGlob.h; không cóUriRegex). - Các mã trạng thái.
wl_status_tlà enum của Arduino, đúng từng giá trị. Các mã âm củaHTTPClientlà của Arduino ở những lỗi mà Mokxi có cùng hiện tượng (-1bị từ chối,-4chưa kết nối,-11hết thời gian chờ). - Khung thời gian. Một lần kết nối mất từ một đến ba giây, và mật khẩu sai thì thất bại sau năm giây. Cả hai đều nằm trong khoảng mà một ESP32-C3 thật trên một mạng yên tĩnh hoạt động, và cả hai đều được giữ trong khoảng đó bằng một bài kiểm thử.
- Thứ tự các trạng thái, là căn cứ để viết một vòng lặp kết nối.
- Cái giá phải trả. Một lệnh
http.GET()bị chặn thực sự làm sketch mất đúng 60 ms thời gian mô phỏng, vì phần còn lại của mạch chạy xuyên qua nó. Một sketch quênhandleClient()thì thực sự không bao giờ trả lời.http.setTimeout()ngắn hơn con số đó sẽ hết thời gian chờ (-11), và yêu cầu bị bỏ cuộc sẽ bị hủy và ghi log khi yêu cầu kế tiếp bắt đầu, giống như một client thật đóng kết nối mà nó ngừng chờ; yêu cầu kế tiếp không bị từ chối. - Mỗi
HTTPClientgiữ phản hồi riêng của mình. Hai client mà mỗi cáiGET()trước khi bên nào đọc đều nhận lại phần thân riêng của mình, vàgetString()hai lần thì nhận phần thân hai lần, như của core ESP32.
Những gì không có
- Không có sóng vô tuyến, và vì vậy không hề có 802.11. Không kênh, không quét thật, không beacon, không khung liên kết, không WPA2, không PMK, không mã hóa ở bất kỳ đâu. Mật khẩu là một phép so sánh chuỗi.
WiFi.scanNetworks()biên dịch được và "tìm thấy" đúng một điểm truy cập mà bo mạch thấy được,wifiSsidcủa nó, và nói trên Serial Monitor rằng lượt quét là mô phỏng (firmware/include/WiFi.h). - No real internet. No DNS protocol, no IP stack, no sockets to anything outside the project's boards. The
four origins are Rust functions. No request in Mokxi ever leaves the tab,
and the Web panel's frame is served with
default-src 'none'so it cannot fetch an image from outside either. - Không có TLS.
WiFiClientSecurebiên dịch được nhưng rồi thất bại:connect()trả về 0 vàwhyNot()nói TLS không được mô phỏng trong Mokxi: ở đây không có https, chỉ có http:// dưới .mokxi. MộtHTTPClientđược đưa vào đó, hoặc được đưa bất kỳ URLhttps://nào, sẽ trả vềHTTPC_ERROR_NO_TLSkèm cùng một câu. Một TLS tin tưởng mọi thứ sẽ dạy học sinh rằng https là miễn phí. - No raw TCP to the internet.
WiFiClient::connect()reaches another board of the project (above) and nothing else: to a name or to an address outside the project's boards it returns 0. The type is also whathttp.begin(client, url)takes, the spelling every modern tutorial uses. So no WebSocket either: the WebSockets library's client reaches only the simulated echo server atecho.mokxi, each message carried as one HTTP request (above), and nothing can connect to its server. The server side works for HTTP too: a hand-writtenWiFiServer(the Random Nerd Tutorials web server, on the ESP32 and the ESP8266 alike) gets each Web panel request fromserver.available()as the bytes a browser sends, and what it prints untilstop()is read back as the HTTP response the panel shows. - Một điện thoại trên soft AP, và đó là Web panel. Không thiết bị nào khác và không có điện thoại thứ hai nào tham gia được điểm truy cập của bo mạch;
maxConnections,hiddenvà kênh được chấp nhận nhưng không thay đổi điều gì mà sketch có thể thấy. Điện thoại nhận lease mà không hỏi DHCP server của bo mạch, không gửi lưu lượng nào của riêng mình ngoài các yêu cầu của panel, và không gì đi ra Internet qua bo mạch (WiFi.AP.enableNAPT()trả về yes nhưng không định tuyến gì).WiFi.mode(WIFI_AP)mà không cósoftAP()sẽ không khởi động gì.wifi.radio.start_ap()của CircuitPython không được mô phỏng. - A second board joins a network only through a soft AP. Every board has
its own private simulated network, and the Web and Cloud panels follow the
first one they find. What connects boards is the air every ESP board on the
canvas shares: ESP-NOW (
docs/help/editor/esp-now.md) and a station joining another board's soft AP (above), withHTTPClientto the access point'sWebServerand TCP between boards. Two boards that joined the same access point reach each other; nothing else routes between them. - Bluetooth là một trình mô phỏng riêng với cùng sự trung thực (
docs/bluetooth.md): Bluetooth Classic và LE của các bo ESP32 nói chuyện với một điện thoại trong ô Bluetooth của trình soạn thảo, qua các thanh ghi riêng của chúng trong cùng khối này. Bluetooth của Pico W không được mô hình hóa. - Không có ngắt trên bốn trong sáu bo mạch. Trên ESP32 kinh điển, ESP32-S3, ESP8266 và Pico W, mailbox không hề tạo ngắt CPU nào: một số nguồn của ma trận ngắt và một số IRQ của NVIC là của con chip, mà khối này không phải là con chip, nên không có số nào trung thực để gán. Runtime dùng polling, và một core đang ngủ vẫn được đánh thức khi mạng có điều gì để nói.
- Các con số này là cấu hình, không phải phép đo.
RSSI()là giá trị của thuộc tínhwifiRssi; không có gì tính độ suy hao đường truyền cả, và di chuyển bo mạch trên khung vẽ chẳng thay đổi gì. - Đồng hồ ở
time.mokxilà đồng hồ của kernel,, đếm từ2026-01-01T00:00:00Z, không phải giờ trong ngày. Trình mô phỏng không biết hôm nay là ngày nào và bịa ra một ngày sẽ là điều nói dối mà học sinh không thể kiểm chứng. Phần thân cũng nóisimulatednhư vậy, vàconfigTime(),NTP.begin()và NTPClient đặt cùng một đồng hồ ("Hỏi giờ", phần trên). Stringlà của Arduino,, từ core dùng chung (firmware/lib/WString.h), với văn bản nằm trên heap. Phần thân vẫn bị giới hạn bởi các kích thước dưới đây.- Kích thước bị giới hạn. Mỗi vòng đệm (ring) mailbox là 4096 byte, phần thân yêu cầu tối đa 2048 và phần hồi đáp 4096; bảng Cloud giữ 512 byte của mỗi phần thân và 100 yêu cầu gần nhất. Một trang do server của sketch gửi chia sẻ vòng đệm với content type của nó, nên bị cắt ngắn vài byte so với 4096, và khi bị cắt thì cả bảng Web lẫn bảng Cloud đều nói rõ điều đó.
Phần cuối trang
Các bảng tiếp cận mạng qua Component::ask, kênh tổng quát thứ ba của kernel bên cạnh poke và debug: một chuỗi JSON mờ đục đi xuống, một chuỗi JSON mờ đục quay lại, và kernel không đọc cả hai. Các thao tác là state, log, setAp, setWeather, setApi, blynkWrite, clearLog, fetch, result, và apJoin cùng apLeave (chiếc điện thoại của bảng Web trên soft AP); state và log đều trả lời kèm "simulated": true, nên một bảng không thể hiển thị nếu thiếu nó. crates/net/src/lib.rs là danh sách.
Chế độ Internet thật
Một chế độ tự chọn (worker/pro-pack.ts): công tắc Real internet trong bảng Cloud, chỉ bật sau khi GET /api/gateway xác nhận tài khoản được phép và trả về các giới hạn áp dụng. Gói Free, đã đăng nhập với địa chỉ email đã xác nhận, được FREE_GATEWAY; gói Pro (Pro, Student, Teacher, Classroom, lớp học trả phí, bản dùng thử Pro) được GATEWAY; học sinh của lớp học hoặc trẻ dưới 13 tuổi chỉ khi giáo viên có công cụ lớp học bật tính năng này cho lớp của mình (classes.real_internet, mặc định tắt), với GATEWAY; tài khoản đã đăng xuất hoặc bị đình chỉ thì không bao giờ. Một bo mạch có wifiSsid là Wokwi-GUEST, tên điểm truy cập mà Wokwi cấp cho bo mạch và bản import từ Wokwi đặt, sẽ tự bật công tắc khi bắt đầu chạy (autoFor), vì trên Wokwi điểm truy cập đó nối được ra internet; nếu bị tắt thủ công thì nó giữ tắt đến hết phiên.
Trong engine (crates/net): setReal {on} đặt chế độ này. Khi đang bật, một CMD_REQUEST có URL được phép đi ra ngoài (http::routes_out: bất kỳ host nào ngoài .mokxi, kể cả https://, và mqtt.mokxi) sẽ không được phục vụ sau HTTP_LATENCY_PS. Nó chờ, không có đồng hồ riêng, đợi trang web: outbound trả lời đúng một yêu cầu đang chờ (id, method, url, contentType, body), và outboundResult {id, status, contentType, body, note} hoàn tất nó qua đúng đường đi mà một câu trả lời mô phỏng dùng (ring, log, CMD_POLL). Trạng thái 0 là từ chối kết nối và đến sketch dưới dạng HTTPC_ERROR_CONNECTION_REFUSED. Một sketch bỏ cuộc (timeout riêng của HTTPClient, mặc định năm giây) rồi yêu cầu lại sẽ làm mất yêu cầu cũ thay vì nhận BUSY, và câu trả lời muộn cho nó không còn ai chờ. Các origin mô phỏng và chính địa chỉ của bo mạch không bao giờ được đi ra ngoài.
Trong trang (web/src/ui/real-internet.ts): một vòng bơm hỏi outbound mỗi 80 ms, gửi những gì tìm thấy tới POST /api/gateway, và đưa câu trả lời trở lại.
Trong Worker (worker/gateway.ts): một yêu cầu vào, một câu trả lời ra. Chỉ GET và POST, http và https trên cổng 80, 443, 8080 và 8443, không có thông tin đăng nhập trong URL; các host bị từ chối theo dải IP (riêng tư, loopback, link-local, CGNAT, tài liệu, đo hiệu năng, multicast, dự phòng; IPv6 ngoài global unicast, và địa chỉ mapped hay NAT64 xét theo phần IPv4 của chúng), theo tên (một nhãn, localhost, .local, .internal và các hậu tố cục bộ khác, tên nền tảng của Cloudflare, mokxi.com), rồi lại theo kết quả phân giải tên qua DNS over HTTPS, và danh sách chặn của chủ sở hữu (GATEWAY_DENY_HOSTS, một biến công khai: mỗi tên chặn chính nó và mọi tên dưới nó, kể cả broker). Không bao giờ theo redirect. Chỉ content type của sketch được gửi ra dưới dạng header. Body bị giới hạn: trên Pro theo kích thước của mailbox, 2048 byte ra và 4096 byte về, trên Free bằng một nửa; body không phải văn bản bị bỏ. Host có bốn giây. Theo từng tài khoản và từng dự án: một phút burst trong bộ nhớ (Pro 30 và 20, Free 10 và 10) và tổng theo ngày UTC trong gateway_counts (Pro 1000 và 500, Free 100 và 50). Free còn bị giới hạn theo từng địa chỉ (FREE_GATEWAY_PER_IP: 20 mỗi phút trong bộ nhớ, 300 mỗi ngày), nên một đống tài khoản vứt bỏ trên một kết nối không cộng dồn được; Pro thì không, nên một lớp học sau một địa chỉ vẫn chạy bình thường. Bảng đó là thứ duy nhất được ghi: số lượng theo ngày theo phạm vi, phạm vi của địa chỉ là một hash có muối thay đổi mỗi ngày, không bao giờ có URL, host, body hay địa chỉ.
MQTT: POST http://mqtt.mokxi/publish?broker=<name>&topic=<topic> với nội dung tin nhắn là phần thân. Cổng kết nối sẽ xuất bản nó ở QoS 0 qua MQTT qua WebSockets (worker/mqtt.ts) tới một trong các địa chỉ test.mosquitto.org, broker.hivemq.com hoặc broker.emqx.io; Worker không thể mở socket TCP tới cổng 1883, nên PubSubClient và TCP thuần vẫn không hoạt động, và không có gì được đăng ký nhận hay nhận lại cả. Chủ đề ký tự đại diện sẽ bị từ chối; tin nhắn tối đa 1024 byte trên gói Pro và 512 byte trên gói Free.
WiFiClientSecure vẫn bị runtime từ chối; http.begin("https://...") và một WiFiClient thường đến được gateway, và gateway thực hiện phần TLS.
Telegram (UniversalTelegramBot.h, Brian Lough's library, 1.3.0) is the
one library built on that path. Telegram is a real service, so a bot reaches
it only in this mode: each call (getMe, getUpdates?offset=...&limit=1,
sendMessage and the rest as a POST of JSON) is one HTTPClient request to
https://api.telegram.org/bot<token>/<method>, which the gateway sends and
answers. The WiFiClientSecure a sketch hands the bot, and the
TELEGRAM_CERTIFICATE_ROOT it gives that client, carry nothing: the gateway
checks Telegram's certificate. With real internet off, every call fails at
once (false, 0 or "") and the serial monitor says once: Telegram needs
the real internet: switch on Real internet in the Cloud panel (signed in), or
run this on a real board. A refusal, a 429 from the caps above, a wrong
token and an answer cut at the size cap each say what they were, once. The
caps shape a bot: the upstream EchoBot polls every second, which is twice
Pro's minute and six times Free's, so Mokxi's copy of it polls every ten
seconds, and on Free a project's 50 a day last about eight minutes of that.
longPoll is held to three seconds, since the host gets four. Photos and
files sent as bytes are not carried (the gateway takes text). The library
reads Telegram's answers with a small reader of its own rather than an
ArduinoJson document, which keeps the EchoBot small on every board.
Các ví dụ
wificonnect: vòng lặp kết nối, địa chỉ, tín hiệu, và mật khẩu sai cố ý.wifiweather:HTTPClientchống lạiweather.mokxi, giá trị lấy ra từ JSON, và một yêu cầu cố ý tớiexample.comđể học sinh tự đọc lời từ chối trong serial monitor của mình.wifiapi: một GET thông thường tớiapi.mokxi, với trạng thái và JSON in ra Serial. Hãy đổi phản hồi trong Cloud rồi chạy lại yêu cầu.wifilamp:WebServervới hai liên kết và một form, bật tắt LED ở chân GPIO 8 từ bảng điều khiển Web.softapserver(ESP32 kinh điển, dự án ESP32 access point web server):WiFi.softAP("MyESP", "12345678")trong thư viện, một trang đếm số máy truy cập, và các nút ON, OFF cho LED ở chân GPIO 26, duyệt bằng điện thoại của bảng điều khiển Web tại 192.168.4.1.
wificonnect, wifiweather và wifilamp có cho cả sáu bo mạch, còn wifiapi cho ESP32-C3, ESP32-C6, ESP32-S3 và Pico W, tổng cộng hai mươi hai sketch, mỗi sketch điều khiển đúng chân mà ví dụ blink trên bo mạch của nó điều khiển, nên mạch theo dõi cái này cũng theo dõi được cái kia. Trên Pico W đó là LED_BUILTIN và GP15, vì LED trên bo nằm ở chip CYW43439 chứ không có trên header. Trên ESP32-S3 đó là LED RGB trên bo, sáng màu trắng, và chân GPIO 2.
Mọi bo mạch WiFi đều biên dịch chúng ngay trong trình duyệt: các header nằm trong các bundle runtime, được dựng lại bằng node web/scripts/bundle-runtime.mjs. ESP32 kinh điển, ESP32-S3 và ESP8266 dựng bằng clang-v3, bản wasm của bản fork LLVM của Espressif, từ 2026-09-28. Các ví dụ chưa chỉnh của chúng vẫn chạy các ELF dựng sẵn do GCC của Espressif dựng (deploy/fetch-xtensa.sh); docs/compile.md giải thích lý do.