ESP32 notveršanas portāls statisko un DHCP IP iestatījumu konfigurēšanai: 8 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:55

ESP 32 ir ierīce ar integrētu WiFi un BLE. Tas ir sava veida svētība IoT projektiem. Vienkārši norādiet savu SSID, paroli un IP konfigurāciju un integrējiet lietas mākonī. Bet IP iestatījumu un lietotāja akreditācijas datu pārvaldība var sagādāt galvassāpes lietotājam.

Ko darīt, ja lietotājs vēlas mainīt WiFi akreditācijas datus?

Ko darīt, ja lietotājs vēlas mainīt DHCP/statiskā IP iestatījumus?

ESP32 mirgošana katru reizi nav uzticama un pat nav risinājums šīm problēmām. Šeit, šajā pamācībā, mēs demonstrēsim.

• Kā izveidot saistošu portālu.
• Tīmekļa veidlapas mitināšana no ESP32.
• Lasīšana un rakstīšana no SPIFFS ESP32.
• Mīksta piekļuves punkta izveidošana un savienojums ar staciju

1. darbība. Aparatūras un programmatūras specifikācija

Aparatūras specifikācija

• ESP32 WiFi/BLE
• Bezvadu temperatūras un mitruma sensors

Programmatūras specifikācija

Arduino IDE

2. darbība. Izvērstā portāla izveide

Fiksēts portāls ir tīmekļa lapa, kas tiek parādīta tikko savienotajiem lietotājiem t, pirms viņiem tiek piešķirta plašāka piekļuve tīkla resursiem. Šeit mēs apkalpojam trīs tīmekļa lapas, lai izvēlētos starp DHCP un statiskajiem IP iestatījumiem. mēs varam definēt IP adresi uz ESP divos veidos.

• DHCP IP adrese- tas ir veids, kā dinamiski piešķirt ierīcei IP adresi. ESP noklusējuma IP adrese ir 192.168.4.1
• Statiska IP adrese- pastāvīgas IP adreses piešķiršana mūsu tīkla ierīcei. lai ierīcei nodrošinātu statisku IP, mums ir jānosaka IP adrese, vārtejas adrese un apakštīkla maska.

Pirmajā tīmekļa vietnē Lietotājam tiek piedāvātas radio pogas, lai izvēlētos starp DHCP un Static IP iestatījumiem. Nākamajā tīmekļa vietnē mums ir jāsniedz ar IP saistīta informācija, lai turpinātu.

HTML kods

Tīmekļa lapu HTML kodu var atrast šajā Github krātuvē.

Lai izveidotu HTML tīmekļa lapas, varat izmantot jebkuru IDE vai teksta redaktoru, piemēram, Sublime vai piezīmju grāmatiņu ++.

• Vispirms izveidojiet HTML tīmekļa lapu, kurā ir divas radio pogas, lai izvēlētos starp DHCP un Static IP Settings.
• Tagad izveidojiet pogu, lai iesniegtu savu atbildi
• Piešķiriet radio pogām kādu nosaukumu. ESP Web servera klase ņems šos nosaukumus par argumentiem un saņems radio pogu atbildi, izmantojot šos argumentus
• Tagad ievietojiet pogu “IESŪTĪT”, lai nosūtītu atbildi uz ierīci.
• Pārējās tīmekļa lapās mums ir tekstlodziņi. Tekstlodziņam piešķiriet nosaukuma vērtību un ievades veidu un pievienojiet pogu Iesniegt, lai iesniegtu atbildi.
• Lai atiestatītu teksta lauka saturu, izveidojiet pogu “RESET”.

// Radio pogas DHCP iestatīšana

Statisks IP iestatījums

// Ievades teksta lodziņi

// Iesniegšanas poga

input [type = "iesniegt"] {background-color: #3498DB; / * Zaļa */ robeža: nav; krāsa: balta; polsterējums: 15 pikseļi 48 pikseļi; text-align: center; teksta dekorēšana: nav; displejs: inline-block; fonta lielums: 16 pikseļi; }

// Atiestatīšanas poga

input [type = "iesniegt"] {background-color: #3498DB; / * Zaļa */ robeža: nav; krāsa: balta; polsterējums: 15 pikseļi 48 pikseļi; text-align: center; teksta dekorēšana: nav; displejs: inline-block; fonta lielums: 16 pikseļi; }

3. darbība. Tīmekļa atbildes saņemšana no tīmekļa lapām uz ESP32

Tīmekļa lapu apkalpošana no ESP 32 ierīces ir ļoti jautra. Tas var būt jebkas, sākot no temperatūras datu rādīšanas tīmekļa vietnē, LED pagrieziena no pielāgotas tīmekļa lapas vai lietotāja WiFi akreditācijas datu saglabāšanas, izmantojot tīmekļa lapu. Šim nolūkam ESP 32 tīmekļa lapu serverēšanai izmanto WebServer klasi.

• Vispirms izveidojiet WebServer klases instanci portā 80 (HTTP ports).
• Tagad iestatiet ESP ierīci kā softAP. Piešķiriet SSID un piekļuves atslēgu un piešķiriet ierīcei statisku IP.
• Sāciet serveri.

// ********* SSID un caurlaide AP **************/

const char *ssidAP = "dot SSID"; const char *passAP = "caurlaides atslēga";

// ********* Statiskā IP konfigurācija **************/IPAddress ap_local_IP (192, 168, 1, 77); IPAddress ap_gateway (192, 168, 1, 254); IPAddress ap_subnet (255, 255, 255, 0);

// ********* SoftAP Config **************/

WiFi.mode (WIFI_AP);

Serial.println (WiFi.softAP (ssidAP, passAP)? "Soft-AP setup": "Neizdevās izveidot savienojumu");

kavēšanās (100); Serial.println (WiFi.softAPConfig (ap_local_IP, ap_gateway, ap_subnet)? "Soft Soft konfigurēšana": "Kļūda konfigurācijā"); Serial.println (WiFi.softAPIP ());

// sākt serveri

server.begin ();

• Izveidojiet un rādiet URL, izmantojot dažādus atzvanus.
• un apstrādāt klientu asinhroni, izmantojot handleClient.

server.on ("/", handleRoot);

server.on ("/dhcp", handleDHCP); server.on ("/static", handleStatic); // apstrādā atbildes atbildes server.handleClient ();

• Lai piekļūtu tīmekļa lapām. Izveidojiet savienojumu ar tikko izveidoto piekļuves punktu, kas norādīts jūsu WiFi tīklos. Tagad dodieties uz pārlūkprogrammu, ievadiet IP, kuru konfigurējāt pēdējā solī, un piekļūstiet tīmekļa lapai.
• Tīmekļa servera klase kā argumentus izmanto ievadēm doto nosaukumu ('teksts', 'poga', 'radiobutton'etc.). Tas saglabā šo ievades atbildes kā argumentus, un mēs varam iegūt vērtības vai pārbaudīt tās, izmantojot args, arg, hasArg metodes.

ja (server.args ()> 0) {par (int i = 0; i <= server.args (); i ++) {

Serial.println (String (server.argName (i)) + '\ t' + String (server.arg (i)));

}

if (server.hasArg ("ipv4static") && server.hasArg ("vārteja") && server.hasArg ("apakštīkls")) {staticSet (); } cits if (server.arg ("ipv4")! = "") {dhcpSetManual (); } cits {dhcpSetDefault (); }

4. darbība: statiskā IP konfigurācija

Līdz šim mēs esam sapratuši, kā izveidot savienojumu ar AP un kā iegūt vērtības no tīmekļa lapas ievades laukiem

Šajā solī mēs konfigurēsim statisko IP

• Atlasiet statisko IP iestatījumu un noklikšķiniet uz pogas Iesniegt. Jūs tiksit novirzīts uz nākamo lapu.
• Nākamajā lapā ievadiet statisko IP adresi, vārtejas adresi un apakštīkla masku, šī lapa tiks pasniegta "/static", kas tiek apstrādāta, izmantojot rokturi statiskā atzvanīšanas metode.
• Iegūstiet teksta lauku vērtību, izmantojot metodi server.arg ().

String ipv4static = Virkne (server.arg ("ipv4static"));

Stīgu vārteja = String (server.arg ("vārteja")); Stīgu apakštīkls = String (server.arg ("apakštīkls"));

• Tagad šīs vērtības ir sakārtotas JSON formātā.
• Tad mēs uzrakstīsim JSON uz SPIFFS.

root ["statickey"] = "staticSet";

sakne ["staticIP"] = ipv4static;

root ["gateway"] = vārteja;

sakne ["apakštīkls"] = apakštīkls;

Fails fileToWrite = SPIFFS.open ("/ip_set.txt", FILE_WRITE);

ja (root.printTo (fileToWrite)) {

Serial.println ("-Fails rakstīts"); }

• Šī konfigurācija tiek saglabāta SPIFFS. Vēlāk šīs vērtības tiek nolasītas no SPIFFS.
• Pēc tam statiskās IP vērtības tiek parsētas no JSON.

Faila fails = SPIFFS.open ("/ip_set.txt", "r");

kamēr (file.available ()) {

debugLogData += char (file.read ()); }

ja (debugLogData.length ()> 5) {

JsonObject & readRoot = jsonBuffer.parseObject (debugLogData);

if (readRoot.containsKey ("statickey")) {

String ipStaticValue = readRoot ["staticIP"];

String gatewayValue = readRoot ["vārteja"];

String subnetValue = readRoot ["apakštīkls"];

5. darbība: DHCP iestatījumi

Šajā solī mēs konfigurēsim DHCP iestatījumus

Indeksa lapā atlasiet DHCP iestatījumus un noklikšķiniet uz "Iesniegt"

• Jūs tiksit novirzīts uz nākamo lapu. Nākamajā lapā ievadiet IP adresi vai izvēlieties noklusējuma izvēli un noklikšķiniet uz pogas Iesniegt, lai iesniegtu atbildi. Šī lapa tiks apkalpota ar "/dhcp", kas tiek apstrādāta ar handleDHCP atzvanīšanas metodi. Iegūstiet teksta lauku vērtību, izmantojot metodi server.arg (). Noklikšķinot, izvēlieties izvēles rūtiņu pēc noklusējuma. ierīcei tiks piešķirts 192.168.4.1 IP.
• Tagad šīs vērtības ir sakārtotas JSON formātā.
• Tad mēs uzrakstīsim JSON uz SPIFFS.

JsonObject & root = jsonBuffer.createObject ();

root ["dhcpManual"] = "dhcpManual";

sakne ["dhcpIP"] = "192.168.4.1";

Fails fileToWrite = SPIFFS.open ("/ip_set.txt", FILE_WRITE);

ja (root.printTo (fileToWrite)) {

Serial.println ("-Fails rakstīts"); }

• Šī konfigurācija tiek saglabāta SPIFFS. Vēlāk šīs vērtības tiek nolasītas no SPIFFS.
• Pēc tam dhcp IP vērtības tiek parsētas no JSON.

Faila fails = SPIFFS.open ("/ip_set.txt", "r"); while (file.available ()) {debugLogData += char (file.read ()); } ja (debugLogData.length ()> 5) {JsonObject & readRoot = jsonBuffer.parseObject (debugLogData);

if (readRoot.containsKey ("dhcpDefault")) {

String ipdhcpValue = readRoot ["dhcpIP"];

Serial.println (ipdhcpValue);

dhcpAPConfig ();}

6. darbība. WiFi akreditācijas datu saglabāšana

Pagaidām mēs esam izvēlējušies IP konfigurāciju. Tagad mums ir jāsaglabā lietotāja wifi akreditācijas dati. Lai atrisinātu šo situāciju. Mēs esam ievērojuši šo procedūru.

• Tātad tagad mūsu ierīces AP iestatīšana ir veikta DHCP vai statiskās IP konfigurācijā, kuru mēs bijām izvēlējušies no pēdējos soļos minētā saistošā portāla.
• Pieņemsim, ka esam izvēlējušies statisko IP konfigurāciju.
• Šajā IP mēs konfigurēsim softAP.
• Pēc vērtību lasīšanas no SPIFFS un šo vērtību parsēšanas no JSON. Mēs konfigurēsim softAP šajā IP.
• Pārvērst IP virkni baitos.

baits ip [4];

parseBytes (ipv4Arr, '.', ip, 4, 10);

ip0 = (uint8_t) ip [0];

ip1 = (uint8_t) ip [1];

ip2 = (uint8_t) ip [2];

ip3 = (uint8_t) ip [3];

IPAddress ap_local (ip0, ip1, ip2, ip3);

// *************** Parsēt baitus no virknes ******************

void parseBytes (const char* str, char sep, byte* baiti, int maxBytes, int bāze) {

par (int i = 0; i <maxBytes; i ++) {

baiti = strtoul (str, NULL, bāze);

str = strchr (str, sep);

ja (str == NULL || *str == '\ 0') {

pārtraukums;

}

str ++;

}}

Tagad mēs konfigurēsim softAP šajā IP

Serial.println (WiFi.softAPConfig (ap_localWeb_IP, ap_gate, ap_net)? "SoftAP konfigurēšana": "nav savienots"); Serial.println (WiFi.softAPIP ());

• Tagad sāciet tīmekļa serveri un apkalpojiet tīmekļa lapu šajā IP. Lai ievadītu lietotāja WiFi akreditācijas datus.
• Tīmekļa lapa sastāv no diviem teksta laukiem, lai ievadītu SSID un paroli.
• handleStaticForm ir atzvanīšanas metode, kas apkalpo tīmekļa lapu.
• server.handleClient () rūpējas par pieprasījumu un atbildēm uz tīmekļa lapu un no tās.

server.begin ();

server.on ("/", handleStaticForm);

server.onNotFound (handleNotFound);

STIMERIS = milis ();

kamēr (milis ()-STIMER <= SI intervāls) {

server.handleClient (); }

HTML veidlapa tiek saglabāta SPIFFS formātā. mēs meklējam piemērotus argumentus, izmantojot server.arg (). lai iegūtu SSID un paroles vērtību

Faila fails = SPIFFS.open ("/WiFi.html", "r");

server.streamFile (fails, "teksts/html");

file.close ();

7. darbība: lasiet un rakstiet no SPIFFS

SPIFFS

Sērijas perifērijas interfeisa zibatmiņu sistēma vai saīsināti SPIFFS. Tā ir viegla failu sistēma mikrokontrolleriem ar SPI zibatmiņas mikroshēmu. ESP32 iebūvētajā zibatmiņas mikroshēmā ir daudz vietas jūsu tīmekļa lapām. Mēs arī esam saglabājuši savu tīmekļa vietni Flash sistēmā. Lai augšupielādētu datus spiffos, mums jāveic dažas darbības

Lejupielādējiet ESP 32 SPIFFS datu augšupielādes rīku:

• Arduino skiču grāmatu direktorijā izveidojiet rīku direktoriju, ja tā vēl nav
• Izpakojiet rīku rīku direktorijā (ceļš izskatīsies kā /Arduino/tools/ESP32FS/tool/esp32fs.jar)
• Restartējiet Arduino IDE
• Atveriet skici (vai izveidojiet jaunu un saglabājiet to)
• Dodieties uz skiču direktoriju (izvēlieties Skice> Show Sketch Folder)
• Izveidojiet direktoriju ar nosaukumu dati un visus failus, kurus vēlaties tur esošajā failu sistēmā. Esam augšupielādējuši savu HTML lapu ar nosaukumu webform.html
• Pārliecinieties, vai esat izvēlējies plati, portu un slēgtu sērijas monitoru
• Atlasiet Rīki> ESP8266 Skices datu augšupielāde. Tam vajadzētu sākt failu augšupielādi ESP8266 flash failu sistēmā. Kad tas ir izdarīts, IDE statusa joslā tiks parādīts ziņojums SPIFFS attēla augšupielāde.

void handleDHCP () {Faila fails = SPIFFS.open ("/page_dhcp.html", "r"); server.streamFile (fails, "teksts/html"); file.close ();}

void handleStatic () {

Faila fails = SPIFFS.open ("/page_static.html", "r"); server.streamFile (fails, "teksts/html"); file.close ();}

Rakstīšana SPIFFS

Šeit mēs rakstām saglabāto iestatījumu SPIFFS, lai lietotājiem nebūtu jāveic šīs darbības ikreiz, kad ierīce tiek atiestatīta.

• Pārveidojiet no tīmekļa lapas saņemtos argumentus par JSON objektiem
• Ierakstiet šo JSON.txt failā, kas saglabāts SPIFFS.

String ipv4static = Virkne (server.arg ("ipv4static"));

Stīgu vārteja = String (server.arg ("vārteja")); Stīgu apakštīkls = String (server.arg ("apakštīkls")); root ["statickey"] = "staticSet"; sakne ["staticIP"] = ipv4static; root ["gateway"] = vārteja; sakne ["apakštīkls"] = apakštīkls; Stīgu JSONStatic; char JSON [120]; root.printTo (sērijas); root.prettyPrintTo (JSONStatic); JSONStatic.toCharArray (JSON, sizeof (JSONStatic) +2); Fails fileToWrite = SPIFFS.open ("/ip_set.txt", FILE_WRITE); if (! fileToWrite) {Serial.println ("Kļūda, atverot SPIFFS"); } ja (fileToWrite.print (JSON)) {Serial.println ("-Fails rakstīts"); } else {Serial.println ("-kļūda, rakstot failu"); } fileToWrite.close ();

8. solis: vispārējais kods

HTML un ESP32 kods Over ir atrodams šajā Github krātuvē