Başvuru

Simüle edilmiş WiFi

Bir kodun katıldığı ağ: ne sadık, ne Mokxi'ye özel, ne de hiç var olmayan.

Mokxi'nin ağ sözleşmesi: bir kod neler yapabilir, neler sadıktır ve neler hiç yoktur. Her kartın kendi sözleşmesinde yazmaç tablosu bulunur (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 modelin kendisidir; bu dosya hepsinden üstün tutulur.

Tek cümle

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.

Tek istisna isteğe bağlıdır ve her sayfa yüklemesinde kapalıdır: gerçek internet modu (aşağıda); bu modda sayfa, motor değil, bir kodun .mokxi dışındaki adlara yaptığı istekleri ağ geçidimiz üzerinden gönderir; giriş yapmış herkes için (Free'de küçük bir pay, Pro ile daha fazlası). Kapalıyken, ki varsayılan budur ve giriş yapılmamışken kullanılabilen tek mod budur, yukarıdaki her cümle aynen geçerlidir. Wokwi-GUEST ağına katılan bir kart, bir çalıştırma başladığında bunu açar.

Neden bir posta kutusu ve bu neden dürüst

Gerçek bir ESP32'de WiFi donanımı belgelenmiş yazmaçlar kümesi değildir. Komut arayüzlü kapalı bir ikili blobdur ve Arduino'nun WiFi.h dosyasındaki her satır onun öbür ucunda biter. Dolayısıyla model bir posta kutusudur: bir komut yazmacı, bir durum yazmacı, her yön için bir halka tampon ve bir kesme biti, ESP32-C3'te 0x6FFF_E000 adresinde: çipin değil, Mokxi'nin kendi bloğu, her gerçek çevre biriminin üzerinde, gerçek bir C3'ün eşlememediği bir adreste; böylece onu kullanan bir kalıp silisyumda hata verir, başkasının yazmacını okumak yerine.

Yalanın tamamı budur ve gerçeğin aynı biçimindedir. Olduğu şey şu değildir: sahte bir 802.11 MAC; bu kodda hiçbir yerde çerçeve, kanal, hız veya işaret aralığı yoktur, çünkü bunların bir modeli, kendisini doğrulayacak bir şeyi olmayan bir uydurma olurdu.

Altı kart ve farklı olan tek sayı

Blok karttan bağımsızdır. crates/net hiçbir kartı bilmez; SoC tek bir sayı seçer (temel adres) ve sözcük erişimlerini yönlendirir. Altı kart bunu yapar ve bunlar, gerçek donanımda radyosu olan tam o altı karttır:

kart posta kutusu şuradadır gerçek parçada orada ne var
ESP32-C3 DevKitM-1 0x6FFF_E000 hiçbir şey: çevre birimleri çok daha altta biter
ESP32-C6-DevKitC-1 0x6FFF_E000 hiçbir şey: aynı yer bu parçada da boştur
ESP32 DevKit (WROOM-32) 0x3FEF_E000 harici bellek pencereleri ile çevre birimi penceresi arasında ayrılmış bir boşluk
ESP32-S3-DevKitC-1 0x6FFF_E000 hiçbir şey: çevre birimleri 0x600D_0FFF adresinde, RTC FAST belleği 0x600F_FFFF adresinde biter
ESP8266 NodeMCU 0x6FFF_E000 hiçbir şey: gerçek bloklarının tamamı o pencerenin ilk birkaç kilobaytındadır
Raspberry Pi Pico W 0x4FFF_E000 hiçbir şey: her APB çevre biriminin üzerinde, AHB-Lite'ın altında

Bir Pico W'de dikiş farklı bir nedenden aynı biçimdedir: kablosuz parça, kapalı bir ikili blobun sürdüğü üç pinli SPI'ye benzer bir bağlantının öbür ucundaki bir CYW43439'dur; bu, bir ESP32'nin radyosu kendi çipinde ne kadar belgelenmiş yazmaç kümesi değilse, RP2040 üzerinde de o kadar değildir. Gerçekte orada olan bir komut arayüzüdür. (Pico W için resmi MicroPython ve CircuitPython firmware'leri çipi kendileri sürer ve onlar için model pinlerden oluşturulur, posta kutusu eşlemesiz kalır: docs/cyw43.md.)

firmware/include/mokxi_net.h her yazmacın, bitin ve komut kodunun tek tanımıdır; her kartın başlık dosyası temel adresi tanımlar ve onu içerir, firmware/tools/check_registers.py ise altı başlık dosyasını sözleşmelerindeki tablolara, temel adres dahil, bağlar. Uydurma bir çevre birimi, iki yarısının birbirine sabitlenmesini en çok gerektirendir.

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.

Bir öğrenci neler yapabilir

Join the network

Altı kartın hepsinde aynı kod; başlık dosyası hepsinde WiFi.h, çünkü Arduino API'si ESP32 ailesinde ve Pico W'de böyle adlandırılır.

#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 ve parola kartın özellikleridir: düzenleyicide karta tıkla ve wifiSsid, wifiPassword ve wifiRssi değerlerini ayarla. Altı kartın hepsi, crates/parts/src/wifi.rs dosyasındaki aynı üçünü taşır, aynı varsayılanlar ve aynı doğrulama ile. Radyo olmadığında taranacak bir şey ve ayrı bir parçanın ayarlarını taşıyacak bir şey yoktur; bu yüzden bir kartın görebildiği tek erişim noktası, kart üzerindeki bir ayardır. Cloud paneli, kod çalışırken aynı üç değeri düzenler.

WiFi.status() önce WL_IDLE_STATUS, bağlanırken WL_DISCONNECTED, ardından WL_CONNECTED döndürür; bu Arduino'nun kendi sırasıdır, çünkü Arduino'da WL_CONNECTING yoktur ve bağlanma aşamasındaki bir parça WL_DISCONNECTED bildirir. WiFi.localIP() değeri 192.168.4.2, gatewayIP() değeri 192.168.4.1'dir; RSSI(), wifiRssi özelliğidir; SSID() erişim noktasının adıdır ve macAddress() kartın kendi MAC adresidir: wifiMac ayarı ya da boş bırakıldıysa motorun parçanın kimliğinden ürettiği bir adres (02:4D:4F: ve üç bayt). Bu adres her çalıştırmada aynı, tuvaldeki her kart için farklıdır; böylece ESP-NOW onları birbirinden ayırt edebilir (docs/help/editor/esp-now.md).

Parolayı yanlış gir ve WiFi.status() WL_CONNECT_FAILED olur. Adı yanlış gir ve WL_NO_SSID_AVAIL olur. WiFi.disconnect() onu boşta duruma geri getirir ve sonraki begin() aynı adresi yeniden kiralar.

Bir şey çek

#include <HTTPClient.h>
WiFiClient client;
HTTPClient http;
http.begin(client, "http://weather.mokxi/");
int code = http.GET();
String body = http.getString();
http.end();

Dört kaynak vardır ve başkası yok:

ad yanıtlar
http://time.mokxi/ çekirdeğin saati ISO dizisi olarak, text/plain
http://weather.mokxi/ Cloud panelinin ayarladığı sıcaklık ve nem içeren JSON
http://echo.mokxi/ gönderdiğin gövde, geriye; ayrıca WebSocketsClient için simüle edilmiş WebSocket yankı sunucusu
http://api.mokxi/ Cloud panelinde yapılandırılmış durum, içerik türü ve yanıt gövdesi

http://192.168.4.2/ (ve http://board.mokxi/) kodun kendi sunucusudur; bir kodun anlamlı biçimde çağramayacağı tek adrestir, çünkü kendine yanıt vermek zorunda kalırdı; bunu söyleyen bir 404 alır.

Diğer herhangi bir .mokxi ad 404'tür. .mokxi altında olmayan hiçbir şey hiç çözümlenmez: http.GET() şunu döndürür HTTPC_ERROR_CONNECTION_REFUSED ve HTTPClient::errorToString() tüm bu özelliğin etrafında kurulduğu tek cümleyi döndürür: gerçek internet yok: yalnızca .mokxi altındaki adlar. https:// şunu döndürür HTTPC_ERROR_NO_TLS.

Bir şey sun

#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() ve handleClient(). Bekleyen istek yokken handleClient() 1 ms bekler, tıpkı ESP32 çekirdeğinin ve arduino-pico'nunki gibi (ESP8266'ınki beklemez), bu yüzden yalnızca hizmet veren bir loop() delay() içinde boşta bekler ve gerçek zamandan hızlı çalışır; enableDelay(false) oradaki gibi dönmesini sağlar. WiFiServer::available() yoklayan bir döngü hem gerçek çipte hem de burada döner. İşleyiciler, kartın çekirdeğindeki kodundur, kartın saatiyle. Alt sayfadaki Web paneli onlar için tarayıcıdır: http://192.168.4.2/ adresinde bir adres çubuğu, bir Yenile düğmesi ve komut dosyaları kapalı şekilde korumalı bir çerçevede görüntülenen sayfa. İçindeki bağlantılar ve form gönderimleri yakalanır ve simüle edilmiş ağa geri yönlendirilir, böylece "LED'i bir web sayfasından aç kapat" uçtan uca çalışır.

Tarayıcı sekmesinin dışındaki hiçbir şey o sunucuya ulaşamaz. Dinleyen bir soket yoktur. Web paneli var olan tek istemcidir.

Kartın kendi erişim noktasını çalıştır (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, kodun sunucusuna erişim noktasının adresinden ulaşır (http://192.168.4.1/ ya da softAPConfig() ile ayarlanan) ve adres çubuğu kendiliğinden oraya taşınır: Git'e bas. WebServer, elle yazılmış bir WiFiServer, AsyncWebServer ve ESP8266 ile Pico W sunucularının hepsi yanıt verir ve server.hostHeader() panelin istediği adrestir (veya addır);
  • WiFi.softAPgetStationNum() (and WiFi.AP.stationCount()) counts the phone, one less once it leaves (boards that joined count too);
  • WiFi.onEvent() işleyicileri çekirdeğin olaylarını onun sırasıyla alır: softAP() çağrısından sonra ARDUINO_EVENT_WIFI_AP_START, ardından her katılımda ARDUINO_EVENT_WIFI_AP_STACONNECTED (telefonun MAC'i, 02:50:48:4F:4E:45, aid 1) ve ARDUINO_EVENT_WIFI_AP_STAIPASSIGNED (192.168.4.2, erişim noktasının sonrasındaki adres, tıpkı ESP-IDF'nin DHCP sunucusunun ilk verdiği gibi), her ayrılışta ARDUINO_EVENT_WIFI_AP_STADISCONNECTED (neden 8) ve softAPdisconnect() sonrasında ya da AP kısmı olmayan bir kipte ARDUINO_EVENT_WIFI_AP_STOP. İstasyonunkiler gibi bunlar da delay() içinden çalışır, değişiklikten yaklaşık 100 ms sonra, böylece softAPgetStationNum() yoklayan bir döngü sayıyı önce görebilir.

Çekirdeklerin ardından gidenler: softAP() boş bir adı ve bir ile yedi karakter arası (ya da 63 üzeri) bir parolayı reddeder, false döndürür ve nedenini seri monitörde bir kez söyler; softAPIP() erişim noktası kapalıyken 0.0.0.0'dır; softAPConfig() önce ya da sonra softAP() onu taşır (ve telefonun kiralamasını sonrasındaki adrese), ve softAPSubnetMask(), softAPBroadcastIP(), softAPNetworkID() ve softAPSubnetCIDR() izler; WiFi.getMode() şudur WIFI_AP sonra softAP() tek başına, WIFI_AP_STA ile yanıt verir: begin() da. Tuvaldeki diğer kartlar da ona katılır. Bir projenin ESP kartları tek bir simüle edilmiş havayı paylaşır (ESP-NOW'un kullandığıyla aynı), böylece bir karttaki istasyon başka bir kartın soft AP'sine katılır: WiFi.begin("MyESP", "12345678") diğer kartın verdiği ad ve parolayla softAP() şu ile biter WL_CONNECTED, erişim noktasının alt ağından bir adresle (192.168.4.2, sonra .3, istedikleri sırayla) ve softAPgetStationNum() her birini sayar. Yanlış bir parola WL_CONNECT_FAILED; erişim noktası açılmadan önce istekte bulunan bir istasyon aramaya devam eder ve hazır olduğunda katılır. 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 ve 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'da arduino-pico'nun WiFi.beginAP() şudur softAP() (açıkken WL_CONNECTED) ve erişim noktası 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() bir tane belirlemediyse; WiFi.localIP() orada yanıt verir. Uno R4 WiFi, WiFiS3's WiFi.beginAP() şunu döndürür WL_AP_LISTENING, WiFi.config(ip) adresi belirtmeden önce ve WiFi.status() şudur WL_AP_CONNECTED while the phone is joined, as its AP_SimpleWebServer example waits for. The ESP8266's ESP8266WiFi soft AP çağrıları aynıdır.

Bir captive portal telefondaki gibi çalışır. DNSServer (dns.start(53, "*", WiFi.softAPIP())) ağa sunucusunun hangi adlara yanıt vereceğini söyler; başlatıldığı sürece telefon kapsadığı her adı o adrese çözer ve telefon katıldığında Web paneli portalı kendiliğinden açar, tıpkı bir telefonun oturum açma sayfasını göstermesi gibi: http://connectivitycheck.gstatic.com/generate_204 isteğinde bulunur ve kodun onNotFound() işlevi (veya kendi adresine yaptığı yönlendirme) yanıt verir. Adres çubuğuna yazılan her ad da karta gider. DNS paketi olmadığı için adlar loop() içinde processNextRequest() çağrılıp çağrılmadığına bakılmaksızın çözülür. .mokxi adları, hiçbir DNS sunucusu kapsamadığında bile benzetilen sitelere ulaşır; bu, kartın ağında gerçek bir telefonun yapamayacağı bir şeydir.

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.

Ne olduğunu izle

Bulut paneli ağ sekmesidir: kartın yaptığı her isteği ve sayfanın karta yaptığı her isteği, yöntemi, URL'yi, durumu, gövdeleri ve bir istek başarısız olduğunda nedenini söyleyen bir satırıyla birlikte taşır. Ayrıca erişim noktasının üç ayarını ve iki weather.mokxi değerini de içerir. Bir API laboratuvarı da vardır: api.mokxi için HTTP durumunu, içerik türünü ve yanıt gövdesini seç, sonra sonraki isteğin tam olarak o yanıtı geri getirişini izle. Bir öğretmen, başarıyı, hatalı girdiyi, eksik veriyi ve sunucu hatalarını API anahtarı veya dersin dışında bir bağımlılık olmadan modelleyebilir.

Blynk kullan

#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.

Kütüphanenin izlediği: Blynk.begin() kart ağa bağlanana ve oturum açana kadar bekler; BLYNK_WRITE Blynk.run() içinde çalışır, loop()'un iki satırı arasında asla; BLYNK_CONNECTED her oturum açışta çalışır; Blynk.syncVirtual() ve syncAll() sunucunun sakladığı değerleri BLYNK_WRITE'a geri gönderir; kart ağ dışındayken yapılan bir yazış atılır, kart ağ dışındayken panelden gönderilen bir değer saklanır ama teslim edilmez; bir float üç ondalıkla, bir double yedi ondalıkla çıkar; ağdan ayrılan bir kart sunucusunu kaybeder ve Blynk.run() geri geldikten beş saniye sonra yeniden oturum açar. Veri akışları bir kart sıfırlamasından kurtulur, gerçek bir sunucudaki gibi. BlynkTimer kütüphaneninkidir: timer.run()'dan on altı zamanlayıcı. WidgetLED, WidgetTerminal ve WidgetLCD pinlerini kütüphane gibi yazar (WidgetLCD.h ve eski kodların adıyla eklediği diğer widget başlık dosyaları da oradadır); LCD çizilmez, pin'i son clr veya p, x, y, text değerini gösterir.

İzlemeyen: token, şablon kimliği ve sunucu adı gösterilir, asla denetlenmez veya aranmaz (burada bir Blynk hesabı yoktur); BLYNK_APP_CONNECTED derlenir ama asla çalışmaz, çünkü hiçbir şey uygulama açmaz (BLYNK_READ, Blynk 1.4.0'dan beri yoktur, dolayısıyla onu kullanan bir kod derleme hatası alır ve BlynkTimer'dan Blynk.virtualWrite() adını önerir); Blynk.Edgent, OTA ve _SSL başlık dosyaları burada yoktur. Değerler 1024 baytla sınırlıdır, yoklamayan bir kart için 64 yazış bekler ve panel son 20 olayı tutar. Blynk trafiği istek günlüğünde değildir, yoksa doldururdu.

WebSocket kullan (yankı sunucusu)

#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.

Başka herhangi bir sunucu ve herhangi bir sunucuya beginSSL() çağrısı hiç bağlanmaz ve istek göndermez: loop() WStype_DISCONNECTED verir, her setReconnectInterval() aralığında tekrar dener ve seri monitör, o sunucuya WebSockets için gerçek bir kart gerektiğini bir kez söyler. Gerçek internet modu bunu değiştirmez: ağ geçidi tek bir HTTP isteği ve tek bir yanıt taşır. WebSocketsServer derlenir ve çalışır, ancak hiçbir istemci ona bağlanamaz, çünkü Web paneli sayfaları betikler kapalıyken gösterilir; bunu da bir kez söyler.

Saati sor

#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"

Bu, gerçek şu anki saat değildir. NTP, internet üzerindeki bir sunucuyla yapılan bir UDP alışverişidir ve bu ağ UDP taşımaz ve hiçbir sunucuya ulaşmaz; simülasyon bugünün tarihini de bilmez ve bir tarih uydurmak, bir öğrencinin denetleyemeyeceği bir yalan olur. Bu yüzden NTP simüle edilir, her WiFi kartında aynı şekilde: ESP32 ve ESP8266 kartlarında configTime(), Pico W'de NTP.begin() ve NTPClient (firmware/lib/NTPClient.h, arduino-libraries sürümü 3.2.1) saati simülasyonun kendi saatine ayarlar: güç verildiğinde 2026-01-01 00:00:00 UTC (epoch 1767225600), artı kartın çalıştığı saniyeler, ki http://time.mokxi/ de aynıını bildirir. Her biri bunu seri monitörde bir kez söyler. NTPClient'ın getEpochTime() işlevi bu değerdir, artı kendi ofseti; update() aralık geçtiğinde sorar ve forceUpdate() hemen şimdi sorar, ikisi de kart ağdayken cevaplanır ve ağda değilken yaklaşık bir saniye sonra zaman aşımına uğrar. Hiçbir paket gönderilmez: kendisine verilen WiFiUDP kullanılmaz.

Kablolu Ethernet kullanın (ETH.h, ESP32 kartları)

#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

PHY yok, RMII yok, W5500 yok ve kablo yok. ETH.begin() posta kutusunun NET_CMD_ETH komutudur (işlem 1): istasyon durum makinesi SSID'siz ve parolasız katılır, WIRED_PS (1,5 s) sonra, aynı kiralama ile ve istasyonun üzerinde ne taşıyorsa (HTTP, kodun sunucusu, Blynk, Gerçek internet geçidi ve sınırları) değişmeden bunun üzerinden gider. Tek bir bağlantı vardır, bu yüzden WiFi.status() nasıl açılmışsa açılmış o bağlantıyı okur ve WiFi.begin() onu WiFi'ye geri taşır. Bağlantı kablolu olduğu sürece WiFi.onEvent() ve Network.onEvent() işleyicileri istasyonun yerine çekirdeğin ETH olaylarını alır. ETH.config(), localIP()'in bildirmesi için korunur; kart Web paneline 192.168.4.2 adresinden hâlâ cevap verir. Kablo her zaman takılıdır.

Neye sadık

  • API. Çağrılar ve imzaları, bir öğrencinin bir ESP32 eğitiminden kopyaladıklarıdır: 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 ve içinde desen geçen yollar: pathArg(0) ile UriBraces("/toggle/{}") ve UriGlob("/files/*") (uri/UriBraces.h, uri/UriGlob.h; UriRegex yoktur).
  • Durum kodları. wl_status_t, Arduino'nun numaralandırmasıdır, değer değer. HTTPClient'ın negatif kodları, Mokxi'nin aynı hatayı yaşadığı yerlerde Arduino'nunkilerdir (-1 reddedildi, -4 bağlı değil, -11 zaman aşımı).
  • Zamanlama aralığı. Bir ilişkilendirme bir ile üç saniye arasında sürer, yanlış parola beş saniye sonra başarısız olur. İkisi de sakin bir ağdaki gerçek bir ESP32-C3'ün yaptığı aralıktadır ve ikisi de bir testle orada tutulur.
  • Durumların sırası, bir bağlanma döngüsünün yazıldığı şeydir.
  • Maliyet. Bloke eden bir http.GET(), koda simüle edilmiş 60 ms'sini gerçekten mal olur, çünkü devrenin geri kalanı onun içinden akar. handleClient()'i unutan bir kod gerçekten hiç cevap vermez. Ondan kısa bir http.setTimeout() zaman aşımına uğrar (-11), ve vazgeçtiği istek, gerçek bir istemcinin beklemeyi bıraktığı bağlantıyı kapatması gibi, bir sonraki başladığında bırakılır ve günlüğe yazılır; sonraki istek reddedilmez.
  • Her HTTPClient kendi cevabını tutar. Her biri ayrı olan iki istemci GET() herhangi biri okumadan önce kendi gövdelerini geri alır ve getString() iki kez çağırmak gövdeyi iki kez verir, tıpkı ESP32 çekirdeğindeki gibi.

Neler dahil değil

  • Radyo yok, dolayısıyla hiç 802.11 yok. Kanal yok, gerçek tarama yok, işaret çerçevesi yok, ilişkilendirme çerçeveleri yok, WPA2 yok, PMK yok, hiçbir yerde şifreleme yok. Parola bir dizgi karşılaştırmasıdır. WiFi.scanNetworks() derlenir ve kartın görebildiği tek erişim noktasını, onun wifiSsid'sini "bulur" ve seri monitörde taramanın simüle edildiğini söyler (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.
  • TLS yok. WiFiClientSecure derlenir ve sonra başarısız olur: connect() 0 döner ve whyNot() şunu söyler: Mokxi'de TLS simüle edilmez: burada https yoktur, yalnızca .mokxi altında http:// vardır. Kendisine böyle bir istemci ya da herhangi bir https:// URL verilen bir HTTPClient, aynı cümleyle HTTPC_ERROR_NO_TLS döner. Her şeye güvenen bir TLS, bir öğrenciye https'nin bedava olduğunu öğretirdi.
  • 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.
  • Yumuşak AP üzerinde tek telefon, o da Web paneli. Başka hiçbir cihaz ve ikinci bir telefon kartın erişim noktasına katılamaz; maxConnections, hidden ve kanal kabul edilir ama kodun görebileceği hiçbir şeyi değiştirmez. Telefon, kartın DHCP sunucusuna sormadan kirasını alır, panelin istekleri dışında kendi adına trafik göndermez ve kart üzerinden internete hiçbir şey ulaşmaz (WiFi.AP.enableNAPT() evet der ama hiçbir şeyi yönlendirmez). WiFi.mode(WIFI_AP) çağrısının ardından softAP() yapılmazsa hiçbir şey açılmaz. CircuitPython'ın wifi.radio.start_ap() simüle edilmez.
  • 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 ayrı bir simülasyondur ve aynı dürüstlüğe sahiptir (docs/bluetooth.md): ESP32 kartlarının Bluetooth Classic ve LE'si, düzenleyicinin Bluetooth bölmesindeki bir telefonla, bu bloktaki kendi yazmaçları üzerinden konuşur. Pico W'nin Bluetooth'u modellenmemiştir.
  • Altı karttan dördünde kesme yok. Klasik ESP32, ESP32-S3, ESP8266 ve Pico W'de posta kutusu hiçbir CPU kesmesi tetiklemez: bir kesme matrisi kaynak numarası ve bir NVIC IRQ numarası çipe aittir, bu blok ise çipe ait değildir, dolayısıyla ona verilecek dürüst bir numara yoktur. Çalışma zamanı yoklar ve beklemede olan bir çekirdek, ağın söyleyecek bir şeyi olduğunda yine de uyandırılır.
  • Sayılar ayardır, ölçüm değil. RSSI() değeri wifiRssi özelliğinin söylediğidir; hiçbir şey bir yol kaybı hesaplamaz ve kartı tuvalde taşımak hiçbir şeyi değiştirmez.
  • time.mokxi adresindeki saat çekirdeğin saatidir, şuradan sayılır: 2026-01-01T00:00:00Z, günün saati değildir. Simülasyon bugün hangi gün olduğunu bilmez ve bir gün uydurmak, bir öğrencinin doğrulayamayacağı bir yalan olur. Gövde de şunu söyler: simulated ayrıca şu da: configTime(), NTP.begin() ve NTPClient aynı saati kurar (yukarıda "Saati sor").
  • String, Arduino'nunkidir, paylaşılan çekirdekten (firmware/lib/WString.h), metni yığında durur. Gövdeler yine aşağıdaki boyutlarla sınırlıdır.
  • Boyutlar sınırlıdır. Her posta kutusu halkası 4096 bayttır, bir istek gövdesi en fazla 2048, bir yanıt 4096 bayttır; Cloud paneli her gövdenin 512 baytını ve son 100 isteği tutar. Kodun sunucusunun gönderdiği bir sayfa, halkasını içerik türüyle paylaşır, bu yüzden 4096 bayttan birkaç bayt eksik kesilir ve kesildiğinde Web ve Cloud panelleri bunu söyler.

Sayfanın sonu

Paneller ağa Component::ask üzerinden ulaşır; bu, çekirdeğin poke ve debug kanallarının yanındaki üçüncü genel kanalıdır: içeriği okunmayan bir JSON dizisi gider, içeriği okunmayan bir JSON dizisi döner ve çekirdek ikisini de okumaz. İşlemler şunlardır: state, log, setAp, setWeather, setApi, blynkWrite, clearLog, fetch, result ve soft AP üzerindeki Web panelinin telefonu için apJoin ve apLeave; state ve log yanıtlarının içinde "simulated": true bulunur, yani bir panel bunlar olmadan görüntülenemez. Listenin tamamı crates/net/src/lib.rs dosyasındadır.

Gerçek internet modu

İsteğe bağlı bir mod (worker/pro-pack.ts): Bulut panelindeki Real internet anahtarı; yalnızca GET /api/gateway hesabın izin verdiğini söyledikten sonra açılır ve hangi sınırların geçerli olduğunu yanıtlar. Ücretsiz planda, onaylı bir e-posta adresiyle giriş yapılmışsa FREE_GATEWAY gelir; Pro paketinde (Pro, Student, Teacher, Classroom, ücretli bir sınıf, Pro denemesi) GATEWAY gelir; bir sınıf öğrencisi veya 13 yaşından küçük bir çocuk yalnızca sınıf araçları açık olan bir öğretmen kendi sınıfı için açtıysa (classes.real_internet, varsayılan kapalı) GATEWAY ile açılabilir; çıkış yapılmış ve askıya alınmış hesaplara asla açılmaz. wifiSsid değeri Wokwi-GUEST olan bir kart (Wokwi'nin bir karta verdiği ve bir Wokwi içe aktarımının adlandırdığı erişim noktası), çalıştırma başladığında anahtarı kendi kendine açar (autoFor), çünkü Wokwi'de o erişim noktası internete ulaşır; elle kapatılırsa oturum boyunca kapalı kalır.

Motor tarafında (crates/net): setReal {on} modu ayarlar. Bu açıkken, URL'si dışarı yönlendirilen (http::routes_out: .mokxi dışındaki herhangi bir host, https:// dahil, ve mqtt.mokxi) bir CMD_REQUEST, HTTP_LATENCY_PS sonrasında karşılanmaz. Kendi saati olmadığı için sayfayı bekler: outbound bekleyen tek isteğe yanıt verir (id, method, url, contentType, body) ve outboundResult {id, status, contentType, body, note} isteği, simüle edilmiş bir yanıtın izlediği aynı yoldan tamamlar (ring, log, CMD_POLL). 0 durumu bir reddedilmedir ve koda HTTPC_ERROR_CONNECTION_REFUSED olarak ulaşır. Vazgeçen (kendi HTTPClient zaman aşımı, varsayılan olarak beş saniye) ve yeniden istek gönderen bir kod, BUSY almak yerine eski isteği düşürür ve o istek için gelen gecikmiş yanıt bekleyenini bulamaz. Simüle edilmiş kaynaklar ve kartın kendi adresi asla dışarı yönlendirilmez.

Sayfa tarafında (web/src/ui/real-internet.ts): bir pompa her 80 ms'de bir outbound'a bakar, bulduğunu POST /api/gatewayye gönderir ve yanıtı geri verir.

Worker tarafında (worker/gateway.ts): içeri bir istek, dışarı bir yanıt. Yalnızca GET ve POST; 80, 443, 8080 ve 8443 portlarında http ve https; URL'de kimlik bilgisi yok. Hostlar şunlara göre reddedilir: IP aralığına göre (özel, loopback, link-local, CGNAT, dokümantasyon, kıyaslama, multicast, ayrılmış; global unicast dışı IPv6 ve IPv4 bölümüne göre değerlendirilen mapped ya da NAT64 adresleri), ada göre (tek etiket, localhost, .local, .internal ve diğer yerel son ekler, Cloudflare platform adları, mokxi.com), DNS over HTTPS üzerinden adın çözümlendiği şeye göre ve sahibinin reddetme listesine göre (GATEWAY_DENY_HOSTS, herkese açık bir değişken: her ad kendisini ve altındaki tüm adları reddeder, aracılar dahil). Yönlendirmeler asla izlenmez. Dışarıya üstbilgi olarak yalnızca kodun içerik türü gider. Gövdeler sınırlıdır: Pro'da posta kutusunun kendi boyutlarıyla 2048 bayt dışarı, 4096 bayt geri; Free'de bunun yarısı. Metin olmayan gövde gönderilmez. Host için dört saniye süre vardır. Hesap başına ve proje başına: bellekte bir dakikalık yoğunluk (Pro 30 ve 20, Free 10 ve 10) ve gateway_counts içinde UTC günü toplamı (Pro 1000 ve 500, Free 100 ve 50). Free ayrıca adres başına da sınırlanır (FREE_GATEWAY_PER_IP: bellekte dakikada 20, günde 300), böylece tek bir bağlantı üzerinden açılan bir yığın tek kullanımlık hesap bir şey kazandırmaz; Pro sınırlanmaz, yani tek bir adresin arkasındaki bir sınıf çalışmaya devam eder. Yazılan tek şey o tablodur: kapsam başına günlük sayaçlar; adresin kapsamı her gün değişen tuzlanmış bir özettir, asla URL, host, gövde veya adres yazılmaz.

MQTT: mesaj gövde olarak gönderilerek POST http://mqtt.mokxi/publish?broker=<name>&topic=<topic> yapılır. Ağ geçidi bunu QoS 0 ile WebSockets üzerinden MQTT olarak (worker/mqtt.ts) şu adreslerden birine yayınlar: test.mosquitto.org, broker.hivemq.com veya broker.emqx.io; bir Worker 1883 numaralı porta TCP soketi açamaz, bu yüzden PubSubClient ve düz TCP hâlâ çalışmaz ve hiçbir şeye abone olunmaz ya da geri getirilmez. Joker karakterli konular reddedilir; bir mesaj Pro planında en fazla 1024 bayt, Free planında 512 bayttır.

WiFiClientSecure çalışma zamanı tarafından hâlâ reddedilir; http.begin("https://...") ve düz bir WiFiClient ağ geçidine ulaşır ve TLS işini ağ geçidi yapar.

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.

Örnekler

  • wificonnect: bağlantı döngüsü, adres, sinyal ve bilerek girilen yanlış parola.
  • wifiweather: HTTPClient karşı weather.mokxi, JSON'dan çekilen değer ve bilerek yapılan şu istek: example.com böylece öğrenci reddi kendi seri monitöründe okur.
  • wifiapi: şuraya normal bir GET: api.mokxi, durumu ve JSON'u Serial'e yazdırılarak. Yanıtı Cloud panelinde değiştir ve isteği yeniden çalıştır.
  • wifilamp: WebServer iki bağlantı ve bir form ile Web panelinden GPIO 8'deki LED'i açıp kapatma.
  • softapserver (klasik ESP32, galerideki ESP32 erişim noktası web sunucusu): WiFi.softAP("MyESP", "12345678"), istasyonları sayan bir sayfa ve GPIO 26'daki LED için AÇIK ve KAPALI butonları; Web panelinin telefonuyla 192.168.4.1 adresinden gezilir.

wificonnect, wifiweather ve wifilamp altı kartın tümü için, wifiapi ise ESP32-C3, ESP32-C6, ESP32-S3 ve Pico W için gelir; yirmi iki kod örneği, her biri kendi kartının blink örneğinin sürdüğü pini sürer, böylece birini izleyen devre diğerini de izler. Pico W'de bu LED_BUILTIN ve GP15'dir, çünkü kart üzerindeki LED CYW43439 üzerindedir ve header'da bulunmaz. ESP32-S3'te beyaz yanan kart üzerindeki RGB LED ve GPIO 2'dir.

Her WiFi kartı bunları tarayıcıda derler: başlık dosyaları çalışma zamanı paketlerindedir ve node web/scripts/bundle-runtime.mjs ile yeniden oluşturulur. Klasik ESP32, ESP32-S3 ve ESP8266, 2026-09-28'den beri Espressif'in LLVM çatalının wasm derlemesi olan clang-v3 ile derlenir. Dokunulmamış örnekleri hâlâ Espressif'in GCC derlemelerinin önceden derlenmiş ELF'lerini çalıştırır (deploy/fetch-xtensa.sh); nedeni docs/compile.md dosyasında yazıyor.