Referensi

WiFi tersimulasi

Jaringan yang disambungi sebuah sketch: apa yang setia pada aslinya, apa yang buatan Mokxi, dan apa yang tidak ada sama sekali.

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 diatur softAPConfig()), dan address bar pindah ke sana dengan sendirinya: tekan Go. WebServer, WiFiServer buatan sendiri, AsyncWebServer serta server ESP8266 dan Pico W semuanya menjawabnya, dan server.hostHeader() adalah alamat (atau nama) yang diminta panel;
  • WiFi.softAPgetStationNum() (and WiFi.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_START setelah softAP(), lalu ARDUINO_EVENT_WIFI_AP_STACONNECTED (MAC HP, 02:50:48:4F:4E:45, aid 1) dan ARDUINO_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, dan ARDUINO_EVENT_WIFI_AP_STOP setelah softAPdisconnect() atau mode tanpa bagian AP. Seperti milik station, handler ini berjalan dari delay(), sekitar 100 ms setelah perubahan, jadi loop yang memanggil softAPgetStationNum() 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 no WiFiServer on 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() and stop() 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 WiFiClient has no destructor here, so one that goes out of scope without stop() keeps its connection until its other end closes and a new connection needs the slot. Call stop().
  • 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 HTTP WebServer serves is refused, as is a station's HTTPClient request to another station's WebServer.

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/{}") dengan pathArg(0) dan UriGlob("/files/*") (uri/UriBraces.h, uri/UriGlob.h; tidak ada UriRegex).
  • Kode statusnya. wl_status_t adalah enum milik Arduino, nilai demi nilai. Kode negatif HTTPClient adalah milik Arduino untuk kegagalan yang sama di Mokxi (-1 ditolak, -4 tidak terhubung, -11 habis 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 lupa handleClient() 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 HTTPClient menyimpan responsnya sendiri. Dua klien yang masing-masing GET() sebelum salah satu pembacaan mendapatkan kembali body miliknya sendiri, dan getString() 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. WiFiClientSecure bisa dikompilasi lalu gagal: connect() mengembalikan 0 dan whyNot() mengatakan TLS tidak disimulasikan di Mokxi: tidak ada https di sini, hanya http:// di bawah .mokxi. HTTPClient yang diberi satu itu, atau diberi URL https:// apa pun, mengembalikan HTTPC_ERROR_NO_TLS dengan 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 what http.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 at echo.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-written WiFiServer (the Random Nerd Tutorials web server, on the ESP32 and the ESP8266 alike) gets each Web panel request from server.available() as the bytes a browser sends, and what it prints until stop() 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) tanpa softAP() 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), with HTTPClient to the access point's WebServer and 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 properti wifiRssi; tidak ada perhitungan kehilangan sinyal di jalur, dan memindahkan board di kanvas tidak mengubah apa pun.
  • Jam di time.mokxi adalah milik kernel, dihitung sejak 2026-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 menyebut simulated juga, dan configTime(), NTP.begin() dan NTPClient menyetel jam yang sama ("Minta waktu", di atas).
  • String adalah 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: HTTPClient terhadap weather.mokxi, nilai yang diambil dari JSON, dan permintaan yang sengaja dibuat ke example.com supaya siswa membaca penolakan itu di serial monitor miliknya sendiri.
  • wifiapi: GET biasa ke api.mokxi, dengan status dan JSON-nya dicetak ke Serial. Ubah responsnya di Cloud dan jalankan permintaan itu lagi.
  • wifilamp: WebServer dengan 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.