... Over het algemeen beperkt dit materiaal zich niet tot slechts één Arduino-onderwerp.

Het onderwerp ESP8266 is een behoorlijk moeilijk onderwerp. Maar als je hiermee werkt Wi-Fi-modules in de Arduino IDE-ontwikkelomgeving daalt de instapdrempel naar een niveau dat acceptabel is voor de gemiddelde Arduino-gebruiker. En niet alleen de Arduino-man, maar iedereen die iets over dit onderwerp wil vertellen, en zonder veel tijd te besteden aan het lezen van de documentatie voor de chip en het bestuderen van de API voor deze modules.

Deze video dupliceert volledig het materiaal dat in het onderstaande artikel wordt gepresenteerd.

Welnu, we weten al hoe we de ESP8266 moeten aansluiten en in de programmeermodus moeten zetten, laten we nu verder gaan met iets nuttigs.

Ik zeg meteen dat zodra we de module in de Arduino-ontwikkelomgeving programmeren, we de oorspronkelijke firmware vernietigen en dat we niet langer met de module kunnen werken met behulp van AT-opdrachten. Persoonlijk word ik er niet koud/heet van, maar als iemand het nodig heeft, laat ik je tegen het einde van het artikel zien hoe je de native firmware terug in de module kunt flashen, of in een soort bootloader zoals NodeMcu.

Download om te beginnen de nieuwste versie van Arduino IDE op de officiële website, momenteel is dit 1.6.7. Oudere versies zoals 1.0.5. passen niet omdat ze simpelweg niet de nodige functionaliteit hebben, en dansen met een tamboerijn interesseert ons niet, toch?

We starten de ontwikkelomgeving en gaan onmiddellijk naar Bestand/Instellingen:

Http://arduino.esp8266.com/stable/package_esp8266com_index.json

Ga vervolgens naar Extra/Bord:/Board Manager...:

Er verschijnt een bordmanagervenster voor ons, blader er helemaal doorheen, en als alles correct is gedaan, zullen we zoiets als dit zien:

Klik met de cursor op het opschrift " esp8266 door ESP8266 Gemeenschap"daarna hebben we een knop "Installeren", selecteer de gewenste versie, ik neem de nieuwste, vandaag is het 2.1.0 en installeer deze. De ontwikkelomgeving downloadt de bestanden die hij nodig heeft (ongeveer 150 megabytes) en tegenover de opschrift " esp8266 door ESP8266 Gemeenschap""GEÏNSTALLEERD" zal verschijnen, dat wil zeggen geïnstalleerd:

We scrollen door de lijst met borden en zien dat we veel verschillende ESP's in de lijst hebben, neem "Generieke ESP8266-module":

Ga naar “Tools” en selecteer de gewenste COM-poort (voor mij is het COM32), stel vervolgens de uploadsnelheid in: “115200”:

We stellen de snelheid in op 74880 en "NL & CR" en schakelen opnieuw uit en schakelen de stroom in en deze zal reageren met wat foutopsporingsinformatie:

Merk op dat 74880 niet de hoofdsnelheid is van de ESP8266, hij verzendt gewoon daarop foutopsporingsinformatie. Als de module niets naar de console stuurt, is er mogelijk iets verkeerd aangesloten.

Standaard zou de snelheid 115200 moeten zijn, maar in in sommige gevallen misschien 9600 en anderen... Probeer het dus op te pakken.

Na selectie vereiste snelheid we sturen de “AT” -module en deze zou moeten antwoorden dat alles “OK” is. Het commando "AT+GMR" geeft informatie over de firmware weer.

Voordat je de ESP8266 gaat flashen Arduino-IDE Ik raad u aan het artikel tot het einde te lezen.

Laten we nu proberen de ESP8266 te flashen via Arduino IDE. We hebben de module in de programmeermodus gezet (hoe je dit moet doen, heb ik geschreven).

Laten we een standaard LED aan de flitser toevoegen:

// Door Mr. PodelkinTs youtube.com/RazniePodelki // speciaal voor site/post/271754/ #define TXD 1 // GPIO1/TXD01 void setup() ( pinMode(TXD, OUTPUT); ) void loop() ( digitalWrite( TXD, HOOG); vertraging (1000); digitalWrite (TXD, LAAG);

Geflitst? Dit betekent dat alles correct is gedaan. Waar heb ik begrepen dat de LED op de eerste pin is aangesloten? In het vorige artikel staat een afbeelding met pinouts van verschillende modules, en er is een markering van de poorten bij gebruik van de Arduino-bootloader (pinnen zijn roze gemarkeerd).

Het laten knipperen van een LED is natuurlijk goed, maar we moeten een soort webserver installeren of de LED op zijn minst gaan besturen met behulp van knoppen in de browser, toch? Maar ik zal je hier een andere keer over vertellen.

En nu hoe je native firmware kunt flashen, en hoe je zelfs een module kunt flashen met bootloaders van derden. Voor ESP8266 is er een programma als NodeMCU Flasher, dat oorspronkelijk bedoeld is voor het flashen van de NodeMCU-bootloader. Maar het bleek dat het perfect andere firmware flitst.

Ik zal voor het gemak een archief met dit programma en firmware bij het artikel voegen, maar je kunt altijd een nieuwe versie van NodeMCU Flasher downloaden.

In de map "nodemcu-flasher-master" bevinden zich 2 mappen, Win64 en Win32, en afhankelijk van de bitdiepte van uw besturingssysteem selecteert u degene die u nodig heeft. Voer vervolgens in de map Release “ESP8266Flasher.exe” uit en bekijk de programma-interface:

Selecteer de gewenste COM-poort en ga naar het tabblad “Config”, verwijder het kruisje naast “INTERNAL://NODEMCU” en zet het een punt lager, zoals in de screenshot:

(Als je de NodeMCU-bootloader wilt flashen, verwijder dan het kruisje waar het niet was en plaats het waar het was, dat wil zeggen in de buurt van "INTERNAL://NODEMCU").

Vervolgens klikken we op het tandwiel en selecteren waar onze firmware zich bevindt, de firmware heeft meestal het *.bin-formaat (in het bijgevoegde archief is dit “v0.9.5.2 AT Firmware.bin” dat zich in de hoofdmap bevindt), en selecteer ook “0x00000” als en hoger.

We keren weer terug naar het tabblad “Bediening”, zetten de module in de programmeermodus en klikken op “Flash”:

Dat is alles, de module is begonnen met flitsen. Vergeet na het flitsen niet de module opnieuw op te starten en voila, hij is geflitst met de firmware die we nodig hebben.

We controleren met het AT-commando “AT+GMR” of we alles correct hebben gedaan:

Zoals je ziet is alles vlot verlopen.

Zo fijn dat er naast firmware voor het gebruik van de ESP8266 als WiFi-module aangestuurd door een externe microcontroller, veel firmware bestaat om hem als microcontroller voor verschillende doeleinden te gebruiken, onder meer op het gebied van Internet of Things. In deze serie artikelen verkennen we de mogelijkheden ESP8266 met firmware KnooppuntMCU en leer een scripttaal LUA.

Wat is ESP8266?

ESP8266 is een microcontroller met een WiFi-interface. Het kan worden gebruikt als WiFi-module en als microcontroller.

Voordelen van ESP8266: WiFi-interface, 32-bit kern met voldoende prestaties, lage prijs.
Nadelen: Vergeleken met andere 32-bits microcontrollers zijn de randapparatuur teleurstellend.

ESP8266 is ideaal voor thuisprojecten, Internet of Things. De ESP8266 is programmeerbaar via de seriële UART-poort, dus er is geen speciale programmeur nodig om de firmware te flashen. Het bijzondere van deze microcontroller is dat hij een programma kan uitvoeren dat zich op een extern Flash-geheugen bevindt. Hierdoor kan de fabrikant het volume van Flash “vergroten”, wat ook een pluspunt is.

Er zijn verschillende modules beschikbaar op basis van ESP8266:

ESP-01
ESP-02
ESP-03
ESP-04
ESP-05
ESP-06
ESP-07
ESP-08
ESP-09
ESP-10
ESP-11
ESP-12S
ESP-12E
ESP-12F

Bestaat verschillende versies borden met reeds afgedichte ESP8266-modules, spanningsstabilisatoren, een microschakeling om de werking te garanderen seriële poort UART via USB en gekamde pinnen, knoppen en dergelijke. Om met dergelijke kaarten te werken, sluit u ze gewoon aan op de USB-poort van uw computer. Er is geen extra uitrusting vereist. Het is erg handig. Eén zo'n bord is NodeMCU. In de voorbeelden zal ik een NodeMCU-bord gebruiken met een ESP-12F-module. Maar u kunt eenvoudig een module nemen, bijvoorbeeld ESP-01, er een UART-USB-adapter op aansluiten en er op dezelfde manier mee werken. De ESP-01 heeft minder geheugen en minder pinnen om te gebruiken, maar werkt verder op dezelfde manier.

Wat is NodeMCU?

NodeMCU - open source gratis project gebaseerd op de Lua-scripttaal. De firmware is behoorlijk krachtig en stelt je in staat zeer snel verschillende standaardprojecten te implementeren. Vandaag gaan we bijvoorbeeld als introductie een WiFi-stopcontact maken dat wordt bestuurd door mobiele telefoon en met een webinterface. De firmware kan Lua-scripts uitvoeren zowel vanaf de seriële UART-poort (vergelijkbaar met AT-opdrachten) als vanaf de interne flash-geheugen(scripts uitvoeren). Lua-scripts worden in Flash opgeslagen op het interne bestandssysteem. Het bestandssysteem is plat en vereenvoudigd. Die. geen submappen. Toch is het cool. Vergeet niet dat de ESP8266 slechts een microcontroller is. Vanuit scripts kunt u ook toegang krijgen tot bestanden, verschillende informatie lezen en opslaan. NodeMCU is modulair. Waarmee u enerzijds de functionaliteit kunt vergroten en anderzijds de firmware alleen uit de vereiste modules kunt samenstellen, zonder geheugen te verspillen.

NodeMCU werkt met protocollen voor gegevensuitwisseling - HTTP, MQTT, JSON, CoAP.
Ondersteund diverse sensoren –
ADXL345 versnellingsmeters,
magnetometers HMC5883L,
L3G4200D gyroscopen,
temperatuur- en vochtigheidssensoren AM2320, DHT11, DHT21, DHT22, DHT33, DHT44
temperatuur-, vochtigheids- en atmosferische druksensoren BME280,
temperatuursensoren, atmosferische druk BMP085,
veel displays werken op I2C- en SPI-bussen. Met de mogelijkheid om met verschillende lettertypen te werken.
TFT-schermen ILI9163, ILI9341, PCF8833, SEPS225, SSD1331, SSD1351, ST7735,
slimme LED's en LED-controllers – WS2812, tm1829, WS2801, WS2812,
ondersteunde interfaces – 1-Wire, I2C, SPI, UART,

U kunt ook een encryptiemodule, een taakplanner, een real-time klok, een kloksynchronisatieprotocol via internet SNTP, timers, een ADC-kanaal (één) gebruiken, audiobestanden afspelen, een PWM-signaal genereren aan de uitgangen (tot 6), gebruik sockets, er is ondersteuning voor FatFS, d.w.z. je kunt SD-kaarten aansluiten enzovoort.

Wat is Lua-taal?

Lua is een geïnterpreteerde taal die, zoals de meeste moderne geïnterpreteerde talen, gecompileerde versies van scripts kan opslaan. Hiermee kunt u de werksnelheid verhogen. Lua is gepositioneerd als multi-paradigma. Het is niet ingewikkeld, en als je al in welke taal dan ook hebt geprogrammeerd, zul je Lua heel snel leren. Als je net begint met programmeren, zal Lua je verrassen met de toegankelijkheid voor beginners.

Er zijn enkele bijzonderheden bij het werken met Lua op NodeMCU. Dit komt vooral door de beperkte geheugencapaciteit van de ESP8266-microcontroller. Moet blijven plakken eenvoudige regels en de stijl van werken met Lua behouden. Ik zal je later over deze regels vertellen. Als je dezelfde stijl aanhoudt als bij het schrijven van programma's in C, dan zul je niet de volledige kracht van Lua en de NodeMCU-firmware kunnen voelen. Wanneer je in Lua begint te schrijven, wordt het boeiend en begin je steeds grotere taken uit te voeren. Je verliest het gevoel dat je met een microcontroller werkt en laadt jezelf onbewust op met taken die de mogelijkheden van een microcontroller te boven gaan. Er moet aan worden herinnerd dat de ESP8266 beperkte middelen en het mag niet vol zitten met taken die microcomputers of volwaardige computers kunnen uitvoeren.

LUA-documentatie in het Russisch: http://www.lua.ru/doc/
Leer LUA in 15 minuten: http://tylerneylon.com/a/learn-lua/

Waar kan ik NodeMCU downloaden?

Natuurlijk kun je downloaden broncodes NodeMCU (https://github.com/nodemcu/nodemcu-firmware/releases/) en compileren met de noodzakelijke parameters. Maar dat zullen wij niet doen. Er is een website https://nodemcu-build.com, waarop u NodeMCU kunt samenstellen met de modules die u nodig heeft. U markeert eenvoudig de modules die u nodig heeft, geeft uw e-mailadres aan en klikt op de onderstaande knop “ Begin met bouwen“. Eerst aan opgegeven e-mailadres Ik ontvang een brief waarin staat dat de montage is begonnen. En dan een melding van voltooiing en downloadlinks geheel getal En vlot versies. Als u geen drijvende-kommaberekeningen in uw project wilt gebruiken, download dan “ geheel getal“. Wees niet hebzuchtig en neem modules op die u niet van plan bent te gebruiken. U kunt het op elk gewenst moment ophalen nieuwe firmware door de ontbrekende module toe te voegen. Ik heb bijvoorbeeld NodeMCU gebouwd met de volgende modules:

Hoe NodeMCU uploaden naar ESP8266?

Nu we het NodeMCU-firmwarebestand hebben, moeten we het uploaden naar de ESP8266. Allereerst, wanneer u het NodeMCU-bord op uw computer aansluit, wordt een virtueel Com haven. Meestal de nieuwste versies Windows-installatie geen stuurprogramma's vereist. Ubuntu herkent het aangesloten apparaat onmiddellijk.

NodeMCU-firmware voor Windows

Flash met het commando:

Sudo python esptool.py --port /dev/ttyUSB0 write_flash 0x00000 The_Path_To_The_NodeMCU_Firmware.bin

/Dev/ttyUSB0– de poort waarop de ESP8266 hangt.
Het_pad_naar_het_knooppuntMCU_Firmware.bin– pad naar het firmwarebestand.

Trouwens, esptool kan ook onder Windows worden gebruikt. esptool geschreven in Python, om op Windows te werken moet je Python installeren.

esptool nuttig voor ons om te vullen binaire bestanden naar het NodeMCU-bestandssysteem. U kunt alle bestanden uploaden, inclusief scripts. Je kunt zelfs in Kladblok scripts schrijven, maar ik geef er de voorkeur aan ESPlorer.

ESPlorer, init.lua – het schrijven van het eerste script

We zullen het ESPlorer-programma gebruiken om scripts te schrijven en te uploaden. Dit is een platformonafhankelijk programma geschreven in Java en vereist ook geen installatie. Werkt hetzelfde op zowel Windows als Ubuntu.

Pak het archief uit.

Onder Windows voeren we het bestand uit ESPlorer.bat

Sudo java-jar ESPlorer.jar

Geef de poort en snelheid op 9600 :

En druk op “ Open“. We zullen het volgende zien

ESPlorer heeft een slechte functie. Het maakt niet altijd duidelijk verbinding met de NodeMCU. Als u een opdracht probeert te verzenden (met behulp van de Versturen) vuilnis vliegt in de console in plaats van een normaal antwoord. Soms wordt na een paar herhalingen alles beter. Als u hier last van heeft, probeer dan de verbindingssnelheid te wijzigen naar 115200.

Laten we beginnen met het maken van het eerste script in Lua. Script met naam init.lua start automatisch nadat NodeMCU is gestart. Laten we een bestand maken init.lua.

Laten we slechts één regel afdrukken:

Afdrukken("Ja, het werkt!")

Sla het bestand op als init.lua. Na het opslaan wordt het bestand uitgevoerd en zouden we het eerste script moeten zien draaien.

Standaard wordt het bestand op de computerschijf opgeslagen en naar de ESP8266 geüpload.

Nu over het grootste probleem dat NodeMCU heeft. In het geval van enkele kritieke fouten (dit gebeurt niet vaak, maar als het gebeurt, wordt het lange tijd onthouden) kan NodeMCU opnieuw opstarten. En het ergste dat kan gebeuren is een cyclische herstart. Dit gebeurt als u een kritieke fout maakt in een script dat automatisch wordt gestart. NodeMCU start, voert een “buggy”-script uit, komt een kritieke fout tegen en wordt opnieuw opgestart. En zo voort tot in het oneindige.

Om mezelf te beschermen tijdens het leren van NodeMCU, gebruik ik de hieronder beschreven techniek. In het startscript init.lua we starten een timer die slechts één keer en daarna werkt opgegeven tijd(V in dit geval na 5 seconden) zal de procedure worden uitgevoerd voor het starten van een ander script (in dit geval hoofd.lua). Verder niets in het script init.lua wij niet. Alle bewerkingen worden in het script uitgevoerd hoofd.lua. Dus als we een fout maken in het script hoofd.lua, en NodeMCU gaat naar cyclisch opnieuw opstarten, na het opnieuw opstarten hebben we 5 seconden om het "buggy" -script te verwijderen of te repareren.

init.lua-tekst:

Print ("Wachten ...") tmr.register (0, 5000, tmr.ALARM_SINGLE, functie (t) tmr.unregister (0); print ("Begint ..."); dofile ("main.lua") einde) tmr.start (0)

Bovendien maakt deze aanpak het gemakkelijk om er een op te nemen vereist script, genoeg in het bestand init.lua in plaats van hoofd.lua geef de naam van een ander script op. Dit is erg handig als u meerdere projecten of meerdere versies van een script op één bord test.

Maak verbinding met Wifi of creëer je eigen Wifi-punt

Om verbinding te maken met WiFi, maakt u main.lua aan en schrijft u:

WiFi-instelling wifi.setmode(wifi.STATION) lokaal cfg=() cfg.ssid="MijnWiFi" cfg.pwd="MijnWiFiPassword" wifi.sta.config(cfg) cfg = nul collectgarbage()

Na een succesvolle verbinding ontvangt de module een IP-adres. Je kunt het achterhalen met behulp van het commando:

Wifi.sta.getip()

Als we willen dat de ESP8266 zijn eigen land creëert eigen wifi punt:

WiFi AP-instelling wifi.setmode(wifi.STATIONAP) cfg=() cfg.ssid="ESPWIFI" cfg.pwd="1234567890" wifi.ap.config(cfg) cfg = nul collectgarbage()

Opmerking: WiFi-hotspot werkt niet als het wachtwoord korter is dan 8 tekens. Standaard is het IP-adres van het punt altijd 192.168.4.1

Je kunt het achterhalen met het commando:

Wifi.ap.getip()

Wat is er gebeurd afval verzamelen()? Functie afval verzamelen is een vuilnisophaler. Het moet aan het einde van elk script worden aangeroepen. Let op de variabele cfg verklaard als lokaal. Het zal alleen beschikbaar zijn in het huidige script. Als lokaal verwijder en vervolgens de variabele cfg zou globaal zijn en beschikbaar in andere scripts.

GPIO. Knipperende LED

Om het relais te besturen (we gaan tenslotte een wifi-aansluiting maken), moet je leren werken met de pinnen GPIO. Laten we voorlopig proberen te gebruiken GPIO pin als uitgang en stel het signaalniveau hoog en laag in. Laten we voor de duidelijkheid de LED aansluiten zoals weergegeven in het diagram.

My_pin_number = 1 -- Stel de bedrijfsmodus in als uitvoer gpio.mode (my_pin_number, gpio.OUTPUT) -- Stel in hoog niveau gpio.write (my_pin_number, gpio.HIGH) -- Stel het lage niveau in gpio.write (my_pin_number, gpio.LOW) -- Knipper de LED 10 keer gpio.serout (1, gpio.HIGH, (+990000,990000), 10, 1)

Pinnummering:

D0(GPIO16) kan alleen worden gebruikt als gpio lezen/schrijven. Geen ondersteuning voor open-drain/interrupt/pwm/i2c/ow

NodeMCU-bord

Let op: Er zijn verschillende versies van Nodemcu-borden. De pinout van je bord kan variëren.

Webaansluiting

Nu gaan we een server maken die op de opgegeven poort werkt (laat het 333 zijn). Vervolgens maken we verbinding met onze server via een terminalprogramma, waarbij we het IP-adres en de poort specificeren. En dan gaan we gegevens uitwisselen.

Main.lua-script:

WiFi AP-instelling wifi.setmode(wifi.STATIONAP) cfg=() cfg.ssid="ESPTEST" cfg.pwd="1234567890" wifi.ap.config(cfg) --Create Server sv=net.createServer(net.TCP ) function receiver(sck, data) -- Ontvangen gegevens afdrukken print(data) -- Antwoord verzenden sck:send("Ontvangen: "..data) end if sv then sv:listen(333, function(conn) conn:on ("ontvangen", ontvanger) conn:send("Hallo!") end) end print("Gestart.")

Nu verhoogt ons script het Wi-Fi-punt en creëert een server die wacht op een verbinding op poort 333. Op het moment dat er verbinding wordt gemaakt, stuurt de server de client de tekenreeks “ Hallo!“, en nadat het gegevens van de klant heeft ontvangen, zal het de string “ Ontvangen:' en toen accepteerde hij alles.

Nu kunnen we onze mobiele telefoon verbinden Wifi-punt ESP8266. In principe is het niet nodig om een ​​punt aan te maken. U kunt het script herschrijven en de ESP8266 verbinding laten maken met uw WiFi-netwerken. Vervolgens moet u het IP-adres achterhalen en dit vervolgens gebruiken in plaats van 192.168.4.1, dat verder in de voorbeelden wordt gebruikt.

Maar we hebben nog steeds een terminalprogramma nodig om verbinding te maken met het ESP8266 IP-adres (192.168.4.1) en de opgegeven poort (333). U kunt PuTTY op een gewone computer installeren. Voor Android mobiele telefoons die ik gebruik JuiceSSH.

Gegevens overbrengen van mobiele telefoon met JuiceSSH

Installeren en starten RoboRemoGratis

Maak een verbinding met de server. Het is raadzaam dat de mobiele telefoon/tablet verbonden is met hetzelfde WiFi-netwerk waar de server zich bevindt. In dit geval onze ESP8266. Ga naar “Menu”, selecteer “verbinden”

Selecteer het verbindingstype “Internet (TCP)”

Geef IP en poort op

De interface selecteren. Met het programma kunt u verschillende interfaces met verschillende bedieningselementen maken.

Ga vervolgens naar de interfacebewerkingsmodus

Klik op vrije ruimte en kies wat we willen installeren. We zullen knoppen gebruiken. Selecteer “knop”

Hierna wordt een knop op de interface geïnstalleerd. Het kan worden verplaatst en vergroot of verkleind.

Om de naam van een knop te wijzigen, moet u erop klikken en 'Tekst instellen' selecteren

Vervolgens specificeren we nog een parameter: “persactie instellen”. Laten we het op "1" zetten. Wanneer u op de knop klikt, wordt de opgegeven string verzonden via de verbinding die we hebben gemaakt. Die. Onze ESP8266 ontvangt het teken “1” en zet de LED aan.

Laten we op dezelfde manier de knop "Uit" maken en de drukactie "0" instellen.

Onze interface is klaar. Verlaat de bewerkingsmodus door het menu-item “ui niet bewerken” uit te voeren.

Als de verbinding met de server (ESP8266) succesvol was, kunt u deze gebruiken. Door op de “Aan”-knop te drukken moet de LED gaan branden, door op de “Uit”-knop te drukken moet de LED uitgaan.

Webinterface

Er is een andere manier: je kunt het doen Webinterface en bedien de LED ook via een browser.

Hetzelfde script + webinterface:

WiFi AP instellen wifi.setmode(wifi.STATIONAP) cfg=() cfg.ssid="ESPTEST" cfg.pwd="1234567890" wifi.ap.config(cfg) --Pin-modus instellen my_pin_number = 1 gpio.mode(my_pin_number , gpio.OUTPUT) --Create Server sv=net.createServer(net.TCP) functieontvanger(sck, data) if string.sub (data, 0, 1) == "1" dan gpio.write(my_pin_number, gpio .HIGH) else if string.sub (data, 0, 1) == "0" then gpio.write(my_pin_number, gpio.LOW) end end print(data) end if sv then sv:listen(333, function(conn ) conn:on("receive",) conn:send("Hallo!") end) end --Maak HTTP-server http=net.createServer(net.TCP) functie receiver_http(sck, data) lokaal verzoek = string match (data,"([^\r,\n]*)[\r,\n]",1) if request == "GET /on HTTP/1.1" then gpio.write(my_pin_number, gpio.HIGH) end if request == "GET /off HTTP/1.1" then gpio.write(my_pin_number, gpio.LOW) end sck:on("sent", function(sck) sck:close() end) local response = "HTTP/ 1.0 200 OK\r\nServer: NodeMCU op ESP8266\r\nContenttype: text/html\r\n\r\n".. " ".. "

NodeMCU op ESP8266

Een korte uitleg over hoe een webserver in het algemeen werkt, en ons script in het bijzonder. De standaardpoort voor een webserver is 80. d.w.z. wanneer u in de browser typt http://192.168.4.1/, dan maakt de browser verbinding met de server (192.168.4.1) op poort 80 en verzendt een verzoek. Het verzoek ziet er ongeveer zo uit:

GET / HTTP / 1.1 Host: 192.168.4.1 User-Agent: Mozilla / 5.0 (Windows NT 5.1; rv: 2.0.1) Gecko / 20100101 Firefox Accepteren: tekst / html, applicatie / xhtml + xml, applicatie / xml; q = 0,9, * / *; q = 0,8 Accepteer-taal: ru-RU, ru; q = 0,8, en-VS; q = 0,5, en; q = 0,3 Accepteren-codering: gzip, leeglopen Verbinding: keep-alive Upgrade-onveilige verzoeken: 1

De eerste regel van de vraag is voor ons interessant: “ GET / HTTP/1.1“. Het bevat de URL. Als u in de browser typt http://192.168.4.1/ op , dan is de eerste regel van de zoekopdracht “ KRIJGEN /op HTTP/1.1“. En als u in de browser typt http://192.168.4.1/ uit dan zal het zijn “ KRIJGEN / uit HTTP/1.1“. Het is deze regel die het script analyseert en, afhankelijk van de ontvangen URL, de LED aan of uit zet.

Vervolgens stuurt het script een html-pagina. Maar na het verzenden moet u de verbinding verbreken. Omdat het verzenden enige tijd kost en het wachten op het einde van het verzenden technisch gezien stom is, is de gebeurtenis “ verstuurd” (verzonden) verbind de functie met de string sck:sluiten(). Dit gebeurt in de regel: sck:on(“verzonden”, functie(sck) sck:close() einde). P Hierna wordt de html-pagina verzonden sck:verzenden(antwoord). MET de crypte blijft werken. Wanneer het antwoord volledig is verzonden, werkt het sck:sluiten().

Pagina's groot formaat Op deze manier kun je het niet verzenden. Zware inhoud moet in stukken worden verzonden. Dit zal in een ander artikel in meer detail worden besproken.

We verbinden het relais met de belasting

Aandacht! Een spanning van meer dan 40 Volt is gevaarlijk voor mensenlevens! Wees voorzichtig en voorzichtig bij het monteren en aansluiten van het circuit huishoudelijke apparaten. Raak spanningvoerende delen niet aan.

Laten we nu in plaats van een LED een relaismodule aansluiten, en als belasting bijvoorbeeld een lamp, een verwarming, een compressor voor een aquarium, een ventilator, enz.

Er kunnen enkele nuances zijn bij het aansluiten van een relais. Als het relaisblok optisch geïsoleerd is (met een optocoupler), hoeft u hoogstwaarschijnlijk niets opnieuw te doen. Als het relaisblok geen optische isolatie heeft, zoals het mijne, dan zul je het werk opnieuw moeten doen met GPIO, aangezien eerst het relais wordt ingeschakeld laag niveau, en niet hoog, en ten tweede is het hoge niveau van de ESP8266 3,3V, voor een relaisblok van 5 volt is dit niet genoeg, dus moest ik de uitgang configureren als OPENDRAIN, waarna alles werkte zoals het zou moeten.

De definitieve versie van het script ziet er als volgt uit:

WiFi AP instellen wifi.setmode(wifi.STATIONAP) cfg=() cfg.ssid="ESPTEST" cfg.pwd="1234567890" wifi.ap.config(cfg) --Pin-modus instellen my_pin_number = 1 --gpio.mode (my_pin_number, gpio.OUTPUT) gpio.mode(my_pin_number, gpio.OPENDRAIN) --Create Server sv=net.createServer(net.TCP) function receiver(sck, data) if string.sub (data, 0, 1) = = "1" then --gpio.write(my_pin_number, gpio.HIGH) gpio.write(my_pin_number, gpio.LOW) else if string.sub (data, 0, 1) == "0" then --gpio.write (mijn_pinnummer, gpio.LOW) gpio.write(mijn_pin_nummer, gpio.HIGH) end end print(data) end if sv then sv:listen(333, function(conn) conn:on("receive", receiver) conn:send ("Hallo!") end) end --Maak HTTP-server http=net.createServer(net.TCP) functie ontvangst_http(sck, data) print(data) lokaal verzoek = string.match(data,"([^\r ,\n]*)[\r,\n]",1) if request == "KRIJG /op HTTP/1.1" then --gpio.write(mijn_pin_nummer, gpio.HIGH) gpio.write(mijn_pin_nummer, gpio. LOW) end if request == "GET /off HTTP/1.1" then --gpio.write(my_pin_number, gpio.LOW) gpio.write(my_pin_number, gpio.HIGH) end sck:on("sent", function(sck ) sck:close() collectgarbage() end) local response = "HTTP/1.0 200 OK\r\nServer: NodeMCU op ESP8266\r\nContenttype: tekst/html\r\n\r\n".. " ".. "

NodeMCU op ESP8266

Nu kunnen we de “socket” aan en uit zetten vanaf een mobiele telefoon met behulp van het RoboRemoFree-programma of met behulp van een browser. Natuurlijk, met gewone computer Je kunt het ook via de browser beheren.

Dit is allemaal goed, maar hoe nu verder? Als we 5, 10, 20 hebben soortgelijke apparaten? Hoe u ze kunt combineren, zodat u niet elk apparaat afzonderlijk hoeft te verbinden. Hiervoor bestaat een MQTT-protocol, maar dat zal een apart onderwerp zijn. In de tussentijd zullen we de mogelijkheden van de ESP8266 en NodeMCU verkennen.

Enkele regels voor het werken met de Lua-taal op NodeMCU

1. Schrijf geen lange scripts. De ESP8266-geheugengrootte is niet oneindig. Verdeel het programma in functionele modules en maak er afzonderlijke scripts van, waarbij u ze uitvoert met behulp van dofile(). Wifi-verbindingscode bijvoorbeeld:

WiFi-instelling wifi.setmode (wifi.STATION) lokaal cfg = () cfg.ssid = "MyWiFi" cfg.pwd = "MyWiFiPassword" wifi.sta.config (cfg) cfg = nul collectgarbage ()

kan in een apart script worden geplaatst “ wifi.lua' en voer het uit vanuit het hoofdscript met de opdracht dofile(“wifi.lua”).

2. Declareer variabelen die alleen in het huidige script worden gebruikt als lokaal. Aan het einde van het script, wanneer de variabele niet langer nodig is, wijst u er een waarde aan toe nul en bel expliciet de vuilnisman afval verzamelen()