Kontrak untuk jaringan Mokxi: apa yang bisa dilakukan sebuah sketch, apa yang setia pada kenyataan, dan apa yang sama sekali tidak ada. Kontrak masing-masing board punya tabel register (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 adalah modelnya; file ini menang atas semuanya.
Satu kalimatnya
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.
Satu-satunya pengecualian bersifat opt-in dan mati setiap kali halaman dimuat: mode internet sungguhan (di bawah), tempat halaman, bukan engine, yang mengirim permintaan sketch untuk nama di luar .mokxi lewat gateway kita, untuk siapa pun yang masuk (kuota kecil di paket Gratis, lebih banyak dengan Pro). Saat mode ini mati, yang merupakan bawaan dan satu-satunya mode saat tidak masuk, setiap kalimat di atas berlaku persis. Board yang bergabung dengan Wokwi-GUEST menyalakannya saat sebuah run dimulai.
Kenapa mailbox, dan kenapa itu jujur
Di ESP32 sungguhan, hardware WiFi bukan sekumpulan register terdokumentasi. Ia adalah blob biner tertutup dengan antarmuka perintah, dan setiap baris WiFi.h milik Arduino berakhir di sisi satunya. Jadi modelnya adalah mailbox: register perintah, register status, ring buffer dua arah dan satu bit interrupt, di 0x6FFF_E000 pada ESP32-C3: blok buatan Mokxi sendiri, bukan milik chip, di atas setiap peripheral sungguhan, pada alamat yang dibiarkan tak terpetakan oleh C3 sungguhan supaya image yang memakainya gagal di silikon alih-alih membaca register milik yang lain.
Itulah seluruh kebohongannya, dan bentuknya sama dengan kebenaran. Yang model ini bukan adalah MAC 802.11 palsu: tidak ada frame, tidak ada channel, tidak ada rate, dan tidak ada interval beacon di mana pun dalam kode ini, karena model dari semua itu akan menjadi karangan tanpa apa pun untuk diperiksanya.
Enam board, dan satu angka yang berbeda
Blok ini tidak bergantung pada board. crates/net tidak tahu apa-apa tentang board mana pun; SoC memilih satu angka, alamat dasar, dan meneruskan akses word. Enam board melakukannya, dan keenamnya persis board yang punya radio di hardware sungguhan:
| board | mailbox berada di | yang ada di bagian sungguhan |
|---|---|---|
| ESP32-C3 DevKitM-1 | 0x6FFF_E000 |
tidak ada apa-apa: peripheralnya berhenti jauh di bawah |
| ESP32-C6-DevKitC-1 | 0x6FFF_E000 |
tidak ada apa-apa: tempat yang sama juga kosong di komponen ini |
| ESP32 DevKit (WROOM-32) | 0x3FEF_E000 |
celah reserved di antara jendela memori eksternal dan jendela peripheral |
| ESP32-S3-DevKitC-1 | 0x6FFF_E000 |
tidak ada apa-apa: peripheralnya berakhir di 0x600D_0FFF dan memori RTC FAST di 0x600F_FFFF |
| ESP8266 NodeMCU | 0x6FFF_E000 |
tidak ada apa-apa: blok sungguhannya semua ada di beberapa kilobyte pertama jendela itu |
| Raspberry Pi Pico W | 0x4FFF_E000 |
tidak ada apa-apa: di atas setiap peripheral APB, di bawah AHB-Lite |
Di Pico W sambungannya berbentuk sama karena alasan berbeda: bagian nirkabelnya adalah CYW43439 di ujung tautan SPI-tiga-pin yang digerakkan blob biner tertutup, yang sama bukannya sekumpulan register terdokumentasi di RP2040 sebagaimana radio ESP32 di die-nya sendiri. Antarmuka perintah itulah yang sungguhan. (Firmware MicroPython dan CircuitPython resmi untuk Pico W menggerakkan chip itu sendiri, dan untuk mereka chip itu dimodelkan dari pin-pinnya, dengan mailbox tak terpetakan: docs/cyw43.md.)
firmware/include/mokxi_net.h adalah satu-satunya definisi setiap register, bit, dan kode perintah; header tiap board mendefinisikan alamat dasar dan meng-include-nya, dan firmware/tools/check_registers.py menuntut keenam header sesuai tabel kontraknya, alamat dasar termasuk. Peripheral buatan adalah yang paling butuh kedua setengahnya dipaku bersama.
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.
Apa yang bisa dilakukan siswa
Join the network
Kode yang sama di keenam board; headernya WiFi.h di semuanya, karena itulah nama API Arduino di keluarga ESP32 dan di 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 dan kata sandi adalah properti board: klik board di editor dan atur wifiSsid, wifiPassword, dan wifiRssi. Keenam board membawa ketiganya yang sama, dari crates/parts/src/wifi.rs, dengan nilai bawaan dan validasi yang sama. Tanpa radio tidak ada yang bisa dipindai dan tidak ada yang membawa pengaturan komponen terpisah, jadi satu-satunya access point yang bisa dilihat board adalah pengaturan di board itu. Panel Cloud menyunting ketiga nilai yang sama saat sketch berjalan.
WiFi.status() berjalan lewat WL_IDLE_STATUS, lalu WL_DISCONNECTED saat berasosiasi, lalu WL_CONNECTED, urutan milik Arduino sendiri, karena Arduino tidak punya WL_CONNECTING dan komponen yang sedang berasosiasi melaporkan WL_DISCONNECTED. WiFi.localIP() adalah 192.168.4.2, gatewayIP() adalah 192.168.4.1, RSSI() adalah properti wifiRssi, SSID() adalah nama access point, dan macAddress() adalah MAC board itu sendiri: pengaturan wifiMac, atau jika dibiarkan kosong, satu yang dihitung engine dari id komponen (02:4D:4F: dan tiga byte), sama di setiap run dan berbeda untuk tiap board di kanvas, jadi ESP-NOW bisa membedakan mereka (docs/help/editor/esp-now.md).
Salah kata sandi dan WiFi.status() menjadi WL_CONNECT_FAILED. Salah nama dan ia menjadi WL_NO_SSID_AVAIL. WiFi.disconnect() mengembalikannya ke idle, dan begin() berikutnya menyewa alamat yang sama lagi.
Ambil sesuatu
#include <HTTPClient.h>
WiFiClient client;
HTTPClient http;
http.begin(client, "http://weather.mokxi/");
int code = http.GET();
String body = http.getString();
http.end();
Ada empat origin, dan tidak ada yang lain:
| nama | menjawab |
|---|---|
http://time.mokxi/ |
jam kernel sebagai string ISO, text/plain |
http://weather.mokxi/ |
JSON dengan suhu dan kelembapan yang diatur panel Cloud |
http://echo.mokxi/ |
isi yang kamu posting, dikirim balik; juga server echo WebSocket tersimulasi untuk WebSocketsClient |
http://api.mokxi/ |
status, jenis konten, dan isi respons yang diatur di panel Cloud |
http://192.168.4.2/ (dan http://board.mokxi/) adalah server milik sketch itu sendiri, satu-satunya alamat yang tidak bisa dipanggil secara berguna oleh sketch, karena ia harus menjawab dirinya sendiri; ia mendapat 404 yang mengatakan hal itu.
Nama lain apa pun .mokxi adalah 404. Apa pun yang tidak berada di bawah .mokxi tidak resolve sama sekali: http.GET() mengembalikan HTTPC_ERROR_CONNECTION_REFUSED dan
HTTPClient::errorToString() mengembalikan satu kalimat yang menjadi inti seluruh fitur ini: tanpa internet sungguhan: hanya nama di bawah .mokxi. https:// mengembalikan
HTTPC_ERROR_NO_TLS.
Sajikan sesuatu
#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() dan handleClient(). Kalau tidak ada request yang menunggu, handleClient() menunggu 1 ms, seperti di core ESP32 dan arduino-pico (yang ESP8266 tidak), jadi loop() yang hanya melayani request akan menganggur di delay() dan berjalan lebih cepat dari waktu nyata; enableDelay(false) membuatnya berputar tanpa henti, seperti di sana. Loop yang melakukan polling WiFiServer::available() berputar tanpa henti di chip asli dan di sini. Handler-nya adalah kode-mu di core board, dengan clock board. Panel Web di bottom sheet adalah browser untuk handler tersebut: address bar di http://192.168.4.2/, tombol Refresh, dan halaman yang dirender dalam frame sandbox dengan script dimatikan. Link dan form post di dalamnya ditangkap dan diarahkan kembali ke jaringan simulasi, jadi "nyalakan LED dari halaman web" bekerja dari ujung ke ujung.
Tidak ada apa pun di luar tab browser yang bisa mencapai server itu. Tidak ada listening socket. Panel Web adalah satu-satunya klien yang ada.
Jalankan access point milik board sendiri (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:
- panel mencapai server sketch di alamat access point (
http://192.168.4.1/, atau yang diatursoftAPConfig()), dan address bar pindah ke sana dengan sendirinya: tekan Go.WebServer,WiFiServerbuatan sendiri,AsyncWebServerserta server ESP8266 dan Pico W semuanya menjawabnya, danserver.hostHeader()adalah alamat (atau nama) yang diminta panel; WiFi.softAPgetStationNum()(andWiFi.AP.stationCount()) counts the phone, one less once it leaves (boards that joined count too);- handler
WiFi.onEvent()menerima event core dalam urutannya:ARDUINO_EVENT_WIFI_AP_STARTsetelahsoftAP(), laluARDUINO_EVENT_WIFI_AP_STACONNECTED(MAC HP,02:50:48:4F:4E:45, aid 1) danARDUINO_EVENT_WIFI_AP_STAIPASSIGNED(192.168.4.2, alamat setelah access point, seperti yang dibagikan DHCP server ESP-IDF lebih dulu) pada setiap kali bergabung,ARDUINO_EVENT_WIFI_AP_STADISCONNECTED(reason 8) pada setiap keluar, danARDUINO_EVENT_WIFI_AP_STOPsetelahsoftAPdisconnect()atau mode tanpa bagian AP. Seperti milik station, handler ini berjalan daridelay(), sekitar 100 ms setelah perubahan, jadi loop yang memanggilsoftAPgetStationNum()bisa melihat angkanya lebih dulu.
Yang mengikuti core: softAP() menolak nama kosong dan password satu sampai tujuh karakter (atau lebih dari 63), mengembalikan false dan menyebut alasannya sekali di serial monitor; softAPIP() adalah 0.0.0.0 selama access point mati;
softAPConfig() sebelum atau sesudah softAP() memindahkannya (dan lease HP ke alamat setelahnya), dan softAPSubnetMask(), softAPBroadcastIP(),
softAPNetworkID() dan softAPSubnetCIDR() mengikuti; WiFi.getMode() adalah
WIFI_AP setelah softAP() saja, WIFI_AP_STA dengan begin() juga.
Board lain di kanvas bergabung juga. Board ESP dari satu proyek berbagi satu udara simulasi (yang sama dengan yang dipakai ESP-NOW), jadi station di satu board bisa bergabung ke soft AP board lain: WiFi.begin("MyESP", "12345678") dengan nama dan password yang diberikan board lain softAP() berakhir dengan WL_CONNECTED, dengan alamat dari subnet access point (192.168.4.2, lalu .3, sesuai urutan permintaan), dan softAPgetStationNum() menghitung masing-masing. Password yang salah berakhir dengan
WL_CONNECT_FAILED; station yang meminta sebelum access point aktif akan terus mencari dan bergabung saat sudah aktif. 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 dan 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 punya
WiFi.beginAP() adalah softAP() (WL_CONNECTED saat aktif) dan access point berada di 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() mengaturnya; WiFi.localIP() menjawabnya di sana. Di Uno R4 WiFi, WiFiS3's WiFi.beginAP() mengembalikan WL_AP_LISTENING,
WiFi.config(ip) sebelum memberi nama alamat, dan WiFi.status() adalah
WL_AP_CONNECTED while the phone is joined, as its AP_SimpleWebServer
example waits for. The ESP8266's ESP8266WiFi soft AP menggunakan panggilan yang sama.
Captive portal bekerja seperti di HP. DNSServer (dns.start(53, "*", WiFi.softAPIP())) memberi tahu jaringan nama mana saja yang dijawab servernya; selama server itu berjalan, HP mengarahkan setiap nama yang dicakupnya ke alamat itu, dan saat HP bergabung, panel Web membuka portalnya sendiri, seperti HP menampilkan halaman login-nya: HP meminta http://connectivitycheck.gstatic.com/generate_204, yang dijawab oleh onNotFound() milik sketch (atau pengalihannya ke alamatnya sendiri). Nama apa pun yang diketik di address bar juga menuju board. Tidak ada paket DNS, jadi nama-nama itu terjawab baik loop() memanggil processNextRequest() maupun tidak. Nama .mokxi tetap sampai ke situs-situs simulasi saat tidak ada server DNS yang mencakupnya, hal yang tidak bisa dilakukan HP sungguhan di jaringan board.
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.
Lihat apa yang terjadi
Panel Cloud adalah tab jaringan: setiap permintaan yang dibuat board dan setiap permintaan halaman ke board, dengan method, URL, status, body, dan saat sebuah permintaan gagal, satu baris yang menjelaskan alasannya. Panel ini juga membawa tiga pengaturan access point dan dua nilai weather.mokxi. Ada juga lab API: pilih status HTTP, content type dan body respons untuk api.mokxi, lalu lihat permintaan berikutnya membawa balik respons itu persis. Seorang guru bisa memperagakan sukses, input yang salah, data yang hilang dan error server tanpa kunci API atau dependensi lain di luar pelajaran.
Gunakan 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.
Apa yang diikuti dari library: Blynk.begin() memblokir sampai board terhubung ke jaringan dan masuk; BLYNK_WRITE berjalan di dalam Blynk.run(), tidak pernah di antara dua baris loop(); BLYNK_CONNECTED berjalan setiap kali masuk; Blynk.syncVirtual() dan syncAll() mengirim kembali nilai tersimpan server ke BLYNK_WRITE; penulisan saat board offline akan dibuang, dan nilai yang dikirim dari panel saat offline disimpan tapi tidak dikirim; float keluar dengan tiga desimal dan double dengan tujuh; board yang keluar dari jaringan kehilangan server-nya, dan Blynk.run() masuk lagi lima detik setelah kembali. Datastream tetap bertahan saat board di-reset, seperti pada server sungguhan. BlynkTimer milik library: enam belas timer dari timer.run(). WidgetLED, WidgetTerminal dan WidgetLCD menulis pin-nya seperti yang dilakukan library (WidgetLCD.h dan header widget lain yang disebut namanya oleh sketch lama juga ada); LCD tidak digambar, pin-nya menampilkan clr atau p, x, y, text terakhir.
Yang tidak: token, template ID dan nama server ditampilkan, tidak pernah diperiksa atau dicari (tidak ada akun Blynk di sini); BLYNK_APP_CONNECTED dikompilasi dan tidak pernah berjalan, karena tidak ada yang membuka aplikasi (BLYNK_READ hilang sejak Blynk 1.4.0, jadi sketch yang memakainya mendapat error build yang menyarankan Blynk.virtualWrite() dari BlynkTimer); Blynk.Edgent, OTA dan header _SSL tidak ada di sini. Nilai dibatasi 1024 byte, 64 penulisan menunggu board yang tidak polling, dan panel menyimpan 20 event terakhir. Lalu lintas Blynk tidak ada di log permintaan, yang akan penuh karenanya.
Gunakan WebSockets (server 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.
Host lain apa pun, dan beginSSL() ke host mana pun, tidak pernah terhubung dan tidak membuat permintaan: loop() membangkitkan WStype_DISCONNECTED, mencoba lagi setiap setReconnectInterval(), dan Serial Monitor menyebut sekali bahwa WebSocket ke host itu butuh board sungguhan. Mode internet sungguhan tidak mengubah itu: gateway hanya membawa satu permintaan HTTP dan satu jawaban. WebSocketsServer berhasil dikompilasi dan berjalan, tapi tidak ada klien yang pernah tersambung, karena panel Web menampilkan halaman dengan skrip mati; panel juga menyebutnya sekali.
Minta waktu saat itu
#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"
Ini bukan waktu nyata yang sebenarnya. NTP adalah pertukaran UDP dengan server di internet, dan jaringan ini tidak membawa UDP dan tidak menjangkau server mana pun; simulasi juga tidak tahu tanggal hari ini, dan mengarang satu tanggal akan menjadi kebohongan yang tidak bisa dibuktikan oleh siswa. Jadi NTP disimulasikan, dengan cara yang sama di setiap board WiFi: configTime() di board ESP32 dan ESP8266, NTP.begin() di Pico W, dan NTPClient (firmware/lib/NTPClient.h, rilis arduino-libraries 3.2.1) semuanya mengatur jam ke milik simulasi itu sendiri: 2026-01-01 00:00:00 UTC (epoch 1767225600) saat dinyalakan, ditambah detik board telah berjalan, yang juga dilaporkan oleh http://time.mokxi/. Masing-masing menyatakannya sekali di serial monitor. getEpochTime() dari NTPClient adalah nilai itu, ditambah offset-nya; update() bertanya ketika intervalnya sudah terlewati dan forceUpdate() bertanya sekarang, dan keduanya dijawab selama board berada di jaringan serta habis waktunya setelah sekitar satu detik saat tidak. Tidak ada paket yang dikirim: WiFiUDP yang diberikan tidak digunakan.
Gunakan Ethernet kabel (ETH.h, board 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
Tidak ada PHY, tidak ada RMII, tidak ada W5500, dan tidak ada kabel. ETH.begin() adalah NET_CMD_ETH (operasi 1) milik mailbox: mesin status station bergabung tanpa SSID dan tanpa kata sandi, WIRED_PS (1,5 dtk) kemudian, dengan lease yang sama, dan semua yang berjalan di atas station (HTTP, server milik sketch, Blynk, gerbang internet Real beserta batasnya) berjalan di atas ini tanpa berubah. Ada satu link, jadi WiFi.status() membacanya dari mana pun ia aktif, dan WiFi.begin() memindahkannya kembali ke WiFi. Selama link adalah yang berkabel, handler WiFi.onEvent() dan Network.onEvent() menerima event ETH dari core, bukan dari station. ETH.config() tetap ada agar localIP() bisa melaporkannya; board tetap menjawab panel Web di 192.168.4.2. Kabelnya selalu terpasang.
Apa yang setia pada kenyataan
- API-nya. Panggilan dan tanda tangannya adalah yang disalin siswa dari tutorial 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, dan rute dengan pola di dalamnya:UriBraces("/toggle/{}")denganpathArg(0)danUriGlob("/files/*")(uri/UriBraces.h,uri/UriGlob.h; tidak adaUriRegex). - Kode statusnya.
wl_status_tadalah enum milik Arduino, nilai demi nilai. Kode negatifHTTPClientadalah milik Arduino untuk kegagalan yang sama di Mokxi (-1ditolak,-4tidak terhubung,-11habis waktu). - Kisaran waktunya. Asosiasi memakan waktu antara satu sampai tiga detik, dan kata sandi yang salah gagal setelah lima detik. Keduanya berada dalam kisaran yang dilakukan ESP32-C3 asli di jaringan yang sepi, dan keduanya ditahan di sana oleh sebuah tes.
- Urutan statusnya, yang menjadi dasar penulisan loop koneksi.
- Biayanya.
http.GET()yang terblokir benar-benar membebani sketch 60 ms waktu simulasi, karena sisa rangkaian berjalan melewatinya. Sketch yang lupahandleClient()benar-benar tidak pernah menjawab.http.setTimeout()yang lebih pendek dari itu akan habis waktu (-11), dan permintaan yang ditinggalkannya dibuang dan dicatat saat permintaan berikutnya dimulai, seperti klien asli menutup koneksi yang tidak lagi ditunggunya; permintaan berikutnya tidak ditolak. - Setiap
HTTPClientmenyimpan responsnya sendiri. Dua klien yang masing-masingGET()sebelum salah satu pembacaan mendapatkan kembali body miliknya sendiri, dangetString()dua kali memberikan body dua kali, seperti milik core ESP32.
Yang tidak
- Tidak ada radio, dan karenanya tidak ada 802.11 sama sekali. Tidak ada channel, tidak ada scan sungguhan, tidak ada beacon, tidak ada frame asosiasi, tidak ada WPA2, tidak ada PMK, tidak ada enkripsi di mana pun. Kata sandinya hanyalah perbandingan string.
WiFi.scanNetworks()bisa dikompilasi dan "menemukan" satu titik akses yang bisa dilihat board,wifiSsid-nya, dan mengatakan di serial monitor bahwa scan itu disimulasikan (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. - Tidak ada TLS.
WiFiClientSecurebisa dikompilasi lalu gagal:connect()mengembalikan 0 danwhyNot()mengatakan TLS tidak disimulasikan di Mokxi: tidak ada https di sini, hanya http:// di bawah .mokxi.HTTPClientyang diberi satu itu, atau diberi URLhttps://apa pun, mengembalikanHTTPC_ERROR_NO_TLSdengan kalimat yang sama. TLS yang mempercayai segalanya akan mengajari siswa bahwa https itu gratis. - 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. - Satu HP di soft AP, dan itu adalah panel Web. Tidak ada perangkat lain atau HP kedua yang bisa bergabung ke access point board;
maxConnections,hidden, dan channel diterima tapi tidak mengubah apa pun yang bisa dilihat sketch. HP mengambil lease-nya tanpa bertanya ke server DHCP board, tidak mengirim trafik apa pun selain request panel, dan tidak ada yang bisa mencapai internet melalui board (WiFi.AP.enableNAPT()bilang ya tapi tidak merutekan apa pun).WiFi.mode(WIFI_AP)tanpasoftAP()tidak mengaktifkan apa pun.wifi.radio.start_ap()milik CircuitPython tidak disimulasikan. - 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 adalah simulasi terpisah dengan kejujuran yang sama (
docs/bluetooth.md): Bluetooth Classic dan LE milik board ESP32 berbicara ke sebuah HP di panel Bluetooth editor, melalui register milik mereka sendiri di block yang sama. Bluetooth milik Pico W tidak dimodelkan. - Tidak ada interupsi di empat dari enam board. Di ESP32 klasik, ESP32-S3, ESP8266 dan Pico W mailbox tidak memunculkan interupsi CPU sama sekali: nomor sumber matriks interupsi dan nomor IRQ NVIC adalah milik chip, dan block ini bukan milik chip, jadi tidak ada nomor jujur yang bisa diberikan. Runtime melakukan polling, dan core yang diparkir tetap dibangunkan saat jaringan punya sesuatu untuk disampaikan.
- Angka-angka itu adalah pengaturan, bukan hasil pengukuran.
RSSI()adalah apa pun yang tertulis di propertiwifiRssi; tidak ada perhitungan kehilangan sinyal di jalur, dan memindahkan board di kanvas tidak mengubah apa pun. - Jam di
time.mokxiadalah milik kernel, dihitung sejak2026-01-01T00:00:00Z, bukan waktu dalam sehari. Simulasi tidak tahu hari ini hari apa dan mengarang satu hari akan jadi kebohongan yang tidak bisa dicek oleh siswa. Body-nya menyebutsimulatedjuga, danconfigTime(),NTP.begin()dan NTPClient menyetel jam yang sama ("Minta waktu", di atas). Stringadalah milik Arduino, dari core bersama (firmware/lib/WString.h), dengan teksnya di heap. Body masih dibatasi oleh ukuran di bawah.- Ukurannya dibatasi. Setiap ring mailbox berukuran 4096 byte, body permintaan paling banyak 2048 dan jawaban 4096; panel Cloud menyimpan 512 byte dari setiap body dan 100 permintaan terakhir. Halaman yang dikirim oleh server milik sketch berbagi ring dengan content type-nya, jadi terpotong beberapa byte sebelum 4096, dan saat terpotong, panel Web dan Cloud sama-sama memberi tahu.
Akhir halaman
Panel-panel mencapai jaringan melalui Component::ask, channel generik ketiga kernel di samping poke dan debug: string JSON buram turun, string JSON buram kembali, dan kernel yang tidak membaca keduanya. Operasinya adalah state, log, setAp, setWeather, setApi, blynkWrite, clearLog, fetch, result, serta apJoin dan apLeave (HP panel Web di soft AP); state dan log keduanya menjawab dengan "simulated": true di dalamnya, jadi panel tidak bisa merender tanpanya. crates/net/src/lib.rs adalah daftarnya.
Mode internet sungguhan
Mode opsional (worker/pro-pack.ts): sakelar Real internet di panel Cloud, yang hanya menyala setelah GET /api/gateway mengatakan akunnya boleh, dan menjawab batas mana yang berlaku. Gratis, dengan masuk dan email yang sudah dikonfirmasi, mendapat FREE_GATEWAY; paket Pro (Pro, Student, Teacher, Classroom, kelas berbayar, uji coba Pro) mendapat GATEWAY; siswa kelas atau anak di bawah 13 tahun hanya jika guru dengan alat kelasnya aktif menyalakannya untuk kelasnya (classes.real_internet, default mati), dengan GATEWAY; akun yang keluar dan akun yang ditangguhkan, tidak pernah. Board yang wifiSsid-nya Wokwi-GUEST, access point yang diberikan Wokwi pada board dan dinamai oleh impor Wokwi, menyalakan sakelarnya sendiri saat run dimulai (autoFor), karena di Wokwi access point itu menjangkau internet; jika dimatikan dengan tangan, tetap mati untuk sesi itu.
Di engine (crates/net): setReal {on} menyetel modenya. Saat aktif, CMD_REQUEST yang URL-nya diarahkan keluar (http::routes_out: host mana pun di luar .mokxi, termasuk https://, dan mqtt.mokxi) tidak dilayani setelah HTTP_LATENCY_PS. Ia menunggu, tanpa jamnya sendiri, pada halaman: outbound menjawab satu permintaan yang menunggu (id, method, url, contentType, body), dan outboundResult {id, status, contentType, body, note} menyelesaikannya lewat jalur yang sama dengan jawaban simulasi (ring, log, CMD_POLL). Status 0 adalah penolakan dan sampai ke sketch sebagai HTTPC_ERROR_CONNECTION_REFUSED. Sketch yang menyerah (timeout HTTPClient-nya sendiri, lima detik secara default) dan meminta lagi akan membuang permintaan lama daripada mendapat BUSY, dan jawaban terlambat untuknya tidak menemukan siapa pun yang menunggu. Asal simulasi dan alamat milik board sendiri tidak pernah diarahkan keluar.
Di halaman (web/src/ui/real-internet.ts): pump bertanya ke outbound setiap 80 ms, mengirimkan apa yang ditemukannya ke POST /api/gateway, lalu menyerahkan jawabannya kembali.
Di Worker (worker/gateway.ts): satu permintaan masuk, satu jawaban keluar. Hanya GET dan POST, http dan https di port 80, 443, 8080 dan 8443, tanpa kredensial di URL; host ditolak berdasarkan rentang IP (privat, loopback, link-local, CGNAT, dokumentasi, benchmarking, multicast, reserved; IPv6 di luar global unicast, dan alamat mapped atau NAT64 dinilai dari bagian IPv4-nya), berdasarkan nama (satu label, localhost, .local, .internal dan akhiran lokal lainnya, nama platform Cloudflare, mokxi.com), dan lagi berdasarkan hasil resolusi nama lewat DNS over HTTPS, serta denylist pemiliknya (GATEWAY_DENY_HOSTS, var publik: setiap nama menolak dirinya sendiri dan semua nama di bawahnya, broker termasuk). Redirect tidak pernah diikuti. Hanya content type milik sketch yang dikirim sebagai header. Body dibatasi: di Pro sesuai ukuran mailbox itu sendiri, 2048 byte keluar dan 4096 kembali, di paket Gratis separuhnya; body non-teks ditinggalkan. Host mendapat empat detik. Per akun dan per proyek: burst satu menit di memori (Pro 30 dan 20, paket Gratis 10 dan 10) dan total satu hari UTC di gateway_counts (Pro 1000 dan 500, paket Gratis 100 dan 50). Paket Gratis juga ditahan per alamat (FREE_GATEWAY_PER_IP: 20 per menit di memori, 300 per hari), jadi tumpukan akun sekali pakai di satu koneksi tidak menumpuk; Pro tidak, jadi kelas di belakang satu alamat tetap berfungsi. Tabel itu adalah satu-satunya yang ditulis: hitungan per hari per scope, scope alamat berupa hash bergaram yang berubah setiap hari, tidak pernah URL, host, body atau alamat.
MQTT: POST http://mqtt.mokxi/publish?broker=<name>&topic=<topic> dengan pesan sebagai body. Gateway menerbitkannya di QoS 0 lewat MQTT over WebSockets (worker/mqtt.ts) ke salah satu dari test.mosquitto.org, broker.hivemq.com atau broker.emqx.io; Worker tidak bisa membuka socket TCP ke port 1883, jadi PubSubClient dan TCP mentah tetap tidak berfungsi, dan tidak ada yang di-subscribe atau dibawa kembali. Topik wildcard ditolak; pesan paling banyak 1024 byte di Pro dan 512 di paket Gratis.
WiFiClientSecure tetap ditolak oleh runtime; http.begin("https://...") dan WiFiClient biasa mencapai gateway, yang mengerjakan TLS-nya.
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.
Contoh-contoh
wificonnect: loop connect, alamat, sinyal, dan sandi yang sengaja salah.wifiweather:HTTPClientterhadapweather.mokxi, nilai yang diambil dari JSON, dan permintaan yang sengaja dibuat keexample.comsupaya siswa membaca penolakan itu di serial monitor miliknya sendiri.wifiapi: GET biasa keapi.mokxi, dengan status dan JSON-nya dicetak ke Serial. Ubah responsnya di Cloud dan jalankan permintaan itu lagi.wifilamp:WebServerdengan dua link dan sebuah form, menyalakan LED di GPIO 8 dari panel Web.softapserver(ESP32 klasik, proyek galeri Web server access point ESP32):WiFi.softAP("MyESP", "12345678"), halaman yang menghitung stasiun, dan tombol ON dan OFF untuk LED di GPIO 26, dijelajahi oleh HP dari panel Web di 192.168.4.1.
wificonnect, wifiweather dan wifilamp tersedia untuk keenam board dan wifiapi untuk ESP32-C3, ESP32-C6, ESP32-S3 dan Pico W, dua puluh dua sketch, masing-masing menggerakkan pin yang digerakkan contoh blink board-nya sendiri, jadi rangkaian yang mengamati satu juga mengamati yang lain. Di Pico W itu adalah LED_BUILTIN dan GP15, karena LED on-board berada di CYW43439 dan tidak ada di header. Di ESP32-S3 itu adalah LED RGB on-board, menyala putih, dan GPIO 2.
Setiap board WiFi mengompilasinya di browser: header-nya ada di bundle runtime, dibangun ulang dengan node web/scripts/bundle-runtime.mjs. ESP32 klasik, ESP32-S3 dan ESP8266 dibangun di atas clang-v3, build wasm dari fork LLVM milik Espressif, sejak 2026-09-28. Contoh-contoh mereka yang belum disentuh masih menjalankan ELF prabangun dari GCC milik Espressif (deploy/fetch-xtensa.sh); docs/compile.md menjelaskan alasannya.