ESP32 alap indító
Készlet

Csomagolási lista

ESP32 Bevezetés

Új ESP32? Kezdje itt! Az ESP32 az Espressif által kifejlesztett, alacsony költségű és alacsony fogyasztású System on a Chip (SoC) mikrokontrollerek sorozata, amelyek Wi-Fi és Bluetooth vezeték nélküli képességeket és kétmagos processzort tartalmaznak. Ha ismeri az ESP8266-ot, az ESP32 az utódja, rengeteg új funkcióval.ESP32 specifikációk
Ha egy kicsit technikaibbra és konkrétabbra vágyik, tekintse meg az ESP32 alábbi részletes specifikációit (forrás: http://esp32.net/) – további részletekért ellenőrizze az adatlapot):

• Vezeték nélküli kapcsolat WiFi: 150.0 Mbps adatsebesség HT40-nel
• Bluetooth: BLE (Bluetooth Low Energy) és Bluetooth Classic
• Processzor: Tensilica Xtensa kétmagos 32 bites LX6 mikroprocesszor, 160 vagy 240 MHz-en
• Memória:
• ROM: 448 KB (a rendszerindításhoz és az alapvető funkciókhoz)
• SRAM: 520 KB (adatokhoz és utasításokhoz)
• RTC fas SRAM: 8 KB (adattároláshoz és a fő CPU-hoz az RTC rendszerindítás során mélyalvó módból)
• RTC lassú SRAM: 8 KB (a társprocesszoros hozzáféréshez mélyalvás üzemmódban) eFuse: 1 Kbit (ebből 256 bit a rendszerhez (MAC-cím és chipkonfiguráció), a maradék 768 bit pedig az ügyfélalkalmazások számára van fenntartva, beleértve Flash-titkosítás és chip-azonosító)

Beágyazott vaku: belsőleg csatlakoztatott vaku az IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 és SD_DATA_1 csatlakozókon keresztül ESP32-D2WD és ESP32-PICO-D4-en.

• 0 MiB (ESP32-D0WDQ6, ESP32-D0WD és ESP32-S0WD chipek)
• 2 MiB (ESP32-D2WD chip)
• 4 MiB (ESP32-PICO-D4 SiP modul)

Alacsony fogyasztás: biztosítja, hogy továbbra is használhatja az ADC konverziókat, plample, mély alvás közben.
Periféria bemenet/kimenet:

• periféria interfész DMA-val, amely kapacitív érintést is tartalmaz
• ADC-k (analóg-digitális konverter)
• DAC-ok (digitális-analóg konverter)
• I²C (Inter-Integrated Circuit)
• UART (univerzális aszinkron vevő/adó)
• SPI (soros periféria interfész)
• I²S (Integrated Interchip Sound)
• RMII (Reduced Media-Independent Interface)
• PWM (impulzusszélesség-moduláció)

Biztonság: hardveres gyorsítók AES-hez és SSL/TLS-hez

ESP32 fejlesztési táblák

Az ESP32 a csupasz ESP32 chipre utal. Az „ESP32” kifejezést azonban az ESP32 fejlesztőkártyákra is használják. Az ESP32 csupasz chipek használata nem egyszerű vagy praktikus, különösen tanulás, tesztelés és prototípuskészítés során. Legtöbbször ESP32 fejlesztőkártyát szeretne használni.
Referenciaként az ESP32 DEVKIT V1 kártyát fogjuk használni. Az alábbi képen az ESP32 DEVKIT V1 kártya látható, 30 GPIO tűvel.Műszaki adatok – ESP32 DEVKIT V1
Az alábbi táblázat összefoglalja az ESP32 DEVKIT V1 DOIT kártya jellemzőit és specifikációit:

Magok száma	2 (kétmagos)
Wi-Fi	2.4 GHz 150 Mbit/s-ig
Bluetooth	BLE (Bluetooth Low Energy) és a régi Bluetooth
Építészet	32 bites
Órajel frekvencia	240 MHz-ig
RAM	512 KB
Pins	30 (modelltől függően)

Perifériák	Kapacitív érintés, ADC (analóg-digitális átalakító), DAC (digitális-analóg átalakító), 12C (Inter-Integrated Circuit), UART (univerzális aszinkron vevő/adó), CAN 2.0 (Controller Area Network), SPI (soros periféria interfész) , 12S (Integrált Inter-IC Hang), RMII (Reduced Media-Independent Interface), PWM (impulzusszélesség-moduláció) és még sok más.
Beépített gombok	RESET és BOOT gombok
Beépített LED-ek	beépített kék LED GPIO2-re csatlakoztatva; beépített piros LED, amely jelzi, hogy a tábla áram alatt van
USB - UART híd	CP2102

Egy microUSB interfésszel rendelkezik, amellyel a kártyát a számítógéphez csatlakoztathatja kód feltöltéséhez vagy áramellátáshoz.
A CP2102 chipet (USB-tól UART-ig) használja a számítógéppel való kommunikációhoz egy COM-porton keresztül, soros interfészen keresztül. Egy másik népszerű chip a CH340. Ellenőrizze, hogy mi az USB-UART chip átalakító a kártyán, mert telepítenie kell a szükséges illesztőprogramokat, hogy számítógépe kommunikálni tudjon az alaplappal (erről az útmutató későbbi részében olvashat bővebben).
Ezen az alaplapon található még egy RESET gomb (lehet, hogy EN felirattal is) az alaplap újraindításához, valamint egy BOOT gomb, amely villogó üzemmódba helyezi a kártyát (kód fogadására használható). Vegye figyelembe, hogy egyes kártyákon előfordulhat, hogy nincs BOOT gomb.
Ezenkívül egy beépített kék LED-del is rendelkezik, amely belsőleg csatlakozik a GPIO 2-höz. Ez a LED hasznos hibakereséshez, hogy valamilyen vizuális fizikai kimenetet adjon. Van egy piros LED is, amely akkor világít, amikor árammal látja el a táblát.ESP32 Pinout
Az ESP32 perifériák a következőket tartalmazzák:

• 18 Analog-to-Digital Converter (ADC) csatorna
• 3 SPI interfész
• 3 UART interfész
• 2 I2C interfész
• 16 PWM kimeneti csatorna
• 2 digitális-analóg konverter (DAC)
• 2 I2S interfész
• 10 kapacitív érzékelő GPIO

Az ADC (analóg-digitális konverter) és DAC (digitális-analóg konverter) funkciók meghatározott statikus érintkezőkhöz vannak hozzárendelve. Eldöntheti azonban, hogy mely érintkezők UART, I2C, SPI, PWM stb. – csak hozzá kell rendelni őket a kódban. Ez az ESP32 chip multiplexelési funkciója miatt lehetséges.
Bár a tűk tulajdonságait meghatározhatja a szoftverben, a következő ábrán látható módon alapértelmezés szerint hozzá vannak rendelve a tűkEzenkívül vannak olyan csapok, amelyek speciális jellemzőkkel rendelkeznek, amelyek alkalmassá teszik őket egy adott projekthez. A következő táblázat bemutatja, hogy mely érintkezőket a legjobb bemenetként, kimenetként használni, és melyek azok, amelyekre óvatosnak kell lenni.
A zölddel kiemelt tűk használhatók. A sárgával kiemeltek használhatók, de oda kell figyelni, mert főként indításkor előfordulhatnak váratlan viselkedésük. A pirossal kiemelt tűket nem ajánljuk bemenetként vagy kimenetként használni.

IO háziorvos	Bemenet	Kimenet	Megjegyzések
0	felhúzott	OK	PWM jelet ad ki rendszerindításkor, LOW-nak kell lennie a villogó módba lépéshez
1	TX tű	OK	hibakeresési kimenet indításkor
2	OK	OK	fedélzeti LED-hez van csatlakoztatva, villogó üzemmódba lépéshez úszóban vagy LOW-ban kell hagyni
3	OK	RX tű	MAGAS indításkor
4	OK	OK
5	OK	OK	PWM jelet ad ki a rendszerindításkor, pántoló tű
12	OK	OK	a csomagtartó meghibásodik, ha magasra húzzák, hevedercsap
13	OK	OK
14	OK	OK	PWM jelet ad ki rendszerindításkor
15	OK	OK	PWM jelet ad ki a rendszerindításkor, pántoló tű

16	OK	OK
17	OK	OK
18	OK	OK
19	OK	OK
21	OK	OK
22	OK	OK
23	OK	OK
25	OK	OK
26	OK	OK
27	OK	OK
32	OK	OK
33	OK	OK
34	OK		csak bemenet
35	OK		csak bemenet
36	OK		csak bemenet
39	OK		csak bemenet

Folytassa az olvasást az ESP32 GPIO-k és funkcióinak részletesebb és mélyebb elemzéséhez.
Csak a tűket vigye be
A 34-39 közötti GPIO-k GPI-k – csak bemeneti lábak. Ezeknek a tűknek nincs belső felhúzó vagy lehúzó ellenállása. Nem használhatók kimenetként, ezért ezeket a lábakat csak bemenetként használja:

• GPIO 34
• GPIO 35
• GPIO 36
• GPIO 39

Az ESP-WROOM-32-be integrált SPI vaku
A GPIO 6–GPIO 11 elérhető néhány ESP32 fejlesztői kártyán. Ezek a tűk azonban az ESP-WROOM-32 chip integrált SPI vakujához csatlakoznak, és nem ajánlottak más célra. Tehát ne használja ezeket a tűket a projektjeiben:

• GPIO 6 (SCK/CLK)
• GPIO 7 (SDO/SD0)
• GPIO 8 (SDI/SD1)
• GPIO 9 (SHD/SD2)
• GPIO 10 (SWP/SD3)
• GPIO 11 (CSC/CMD)

Kapacitív érintőképernyős GPIO-k
Az ESP32 10 belső kapacitív érintésérzékelővel rendelkezik. Ezek érzékelik a változásokat bármiben, ami elektromos töltést tartalmaz, például az emberi bőrben. Így észlelni tudják a GPIO-k ujjal történő megérintésekor előidézett eltéréseket. Ezek a tűk könnyen integrálhatók kapacitív párnákba, és helyettesíthetik a mechanikus gombokat. A kapacitív érintőtűkkel az ESP32 felébreszthető a mély alvásból. Ezek a belső érintésérzékelők ezekhez a GPIO-khoz csatlakoznak:

• T0 (GPIO 4)
• T1 (GPIO 0)
• T2 (GPIO 2)
• T3 (GPIO 15)
• T4 (GPIO 13)
• T5 (GPIO 12)
• T6 (GPIO 14)
• T7 (GPIO 27)
• T8 (GPIO 33)
• T9 (GPIO 32)

Analóg-digitális átalakító (ADC)
Az ESP32 18 x 12 bites ADC bemeneti csatornákkal rendelkezik (míg az ESP8266 csak 1 x 10 bites ADC-vel rendelkezik). Ezek a GPIO-k, amelyek ADC-ként és megfelelő csatornáként használhatók:

• ADC1_CH0 (GPIO 36)
• ADC1_CH1 (GPIO 37)
• ADC1_CH2 (GPIO 38)
• ADC1_CH3 (GPIO 39)
• ADC1_CH4 (GPIO 32)
• ADC1_CH5 (GPIO 33)
• ADC1_CH6 (GPIO 34)
• ADC1_CH7 (GPIO 35)
• ADC2_CH0 (GPIO 4)
• ADC2_CH1 (GPIO 0)
• ADC2_CH2 (GPIO 2)
• ADC2_CH3 (GPIO 15)
• ADC2_CH4 (GPIO 13)
• ADC2_CH5 (GPIO 12)
• ADC2_CH6 (GPIO 14)
• ADC2_CH7 (GPIO 27)
• ADC2_CH8 (GPIO 25)
• ADC2_CH9 (GPIO 26)

Jegyzet: Az ADC2 érintkezők nem használhatók Wi-Fi használata esetén. Tehát, ha Wi-Fi-t használ, és problémái vannak az ADC2 GPIO értékének lekérésével, fontolja meg egy ADC1 GPIO használatát. Ennek meg kell oldania a problémáját.
Az ADC bemeneti csatornák felbontása 12 bites. Ez azt jelenti, hogy 0 és 4095 közötti analóg értékeket kaphat, amelyekben a 0 0 V-nak, 4095 és 3.3 V-nak felel meg. A kódon és az ADC tartományon is beállíthatja csatornáinak felbontását.
Az ESP32 ADC tűi nem lineárisak. Valószínűleg nem fog tudni különbséget tenni 0 és 0.1 V, illetve 3.2 és 3.3 V között. Ezt szem előtt kell tartania az ADC érintkezők használatakor. A következő ábrán láthatóhoz hasonló viselkedést fog kapni.Digitális-analóg konverter (DAC)
Az ESP2-n 8 x 32 bites DAC csatorna található a digitális jelek analóg formátummá alakításáhoztage jelkimenetek. Ezek a DAC csatornák:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

RTC GPIO-k
Az ESP32 rendelkezik RTC GPIO támogatással. Az RTC alacsony fogyasztású alrendszeréhez irányított GPIO-k akkor használhatók, ha az ESP32 mélyalvásban van. Ezekkel az RTC GPIO-kkal fel lehet ébreszteni az ESP32-t a mély alvásból, amikor az Ultra Low
A Power (ULP) társprocesszor fut. A következő GPIO-k külső ébresztési forrásként használhatók.

• RTC_GPIO0 (GPIO36)
• RTC_GPIO3 (GPIO39)
• RTC_GPIO4 (GPIO34)
• RTC_GPIO5 (GPIO35)
• RTC_GPIO6 (GPIO25)
• RTC_GPIO7 (GPIO26)
• RTC_GPIO8 (GPIO33)
• RTC_GPIO9 (GPIO32)
• RTC_GPIO10 (GPIO4)
• RTC_GPIO11 (GPIO0)
• RTC_GPIO12 (GPIO2)
• RTC_GPIO13 (GPIO15)
• RTC_GPIO14 (GPIO13)
• RTC_GPIO15 (GPIO12)
• RTC_GPIO16 (GPIO14)
• RTC_GPIO17 (GPIO27)

PWM
Az ESP32 LED PWM vezérlő 16 független csatornával rendelkezik, amelyek konfigurálhatók különböző tulajdonságú PWM jelek generálására. Minden kimenet, amely kimenetként működhet, használható PWM lábként (a 34-39 GPIO-k nem tudnak PWM-et generálni).
A PWM jel beállításához a következő paramétereket kell megadnia a kódban:

• a jel frekvenciája;
• Üzemi ciklus;
• PWM csatorna;
• GPIO, ahol a jelet ki akarja adni.

I2C
Az ESP32 két I2C csatornával rendelkezik, és bármelyik érintkező beállítható SDA vagy SCL-ként. Ha az ESP32-t Arduino IDE-vel használja, az alapértelmezett I2C érintkezők a következők:

• GPIO 21 (SDA)
• GPIO 22 (SCL)

Ha más tűket szeretne használni a vezetékkönyvtár használatakor, csak hívnia kell:
Wire.begin(SDA, SCL);
SPI
Alapértelmezés szerint az SPI pin-leképezése a következő:

SPI	MOSI	MISO	CLK	CS
VSPI	GPIO 23	GPIO 19	GPIO 18	GPIO 5
HSPI	GPIO 13	GPIO 12	GPIO 14	GPIO 15

megszakítások
Minden GPIO megszakításként konfigurálható.
Pántolócsapok
Az ESP32 chip a következő rögzítőcsapokkal rendelkezik:

• GPIO 0 (ALACSONY értékűnek kell lennie a rendszerindítási módba lépéshez)
• GPIO 2 (lebegőnek vagy LOW-nak kell lennie a rendszerindítás során)
• GPIO 4
• GPIO 5 (magasnak kell lennie rendszerindításkor)
• GPIO 12 (LOW-nak kell lennie rendszerindításkor)
• GPIO 15 (magasnak kell lennie rendszerindításkor)

Ezekkel az ESP32 bootloader vagy villogó módba kerül. A legtöbb beépített USB/soros fejlesztői kártyán nem kell aggódnia ezen érintkezők állapota miatt. A tábla megfelelő állapotba hozza a tűket villogó vagy rendszerindítási módhoz. További információ az ESP32 rendszerindítási mód kiválasztásáról itt található.
Ha azonban perifériák vannak csatlakoztatva ezekhez a érintkezőkhöz, gondot okozhat az új kód feltöltése, az ESP32 új firmware-lel való felvillantása vagy az alaplap visszaállítása. Ha néhány periféria van csatlakoztatva a rögzítőtüskéihez, és problémába ütközik a kód feltöltése vagy az ESP32 villogása, ennek oka lehet, hogy ezek a perifériák megakadályozzák, hogy az ESP32 a megfelelő módba lépjen. Olvassa el a Boot Mode Selection dokumentációját, amely elvezeti Önt a helyes irányba. Az alaphelyzetbe állítás, villogás vagy rendszerindítás után ezek a tűk a várt módon működnek.
HIGH csapok a rendszerindításkor
Egyes GPIO-k állapotukat HIGH-ra változtatják, vagy PWM-jeleket adnak ki rendszerindításkor vagy alaphelyzetbe állításkor.
Ez azt jelenti, hogy ha kimenetei vannak csatlakoztatva ezekhez a GPIO-khoz, akkor váratlan eredményeket kaphat az ESP32 alaphelyzetbe állításakor vagy elindulásakor.

• GPIO 1
• GPIO 3
• GPIO 5
• GPIO 6 – GPIO 11 (csatlakozik az ESP32 integrált SPI flash memóriához – nem ajánlott a használata).
• GPIO 14
• GPIO 15

Engedélyezés (EN)
Az engedélyezés (EN) a 3.3 V-os szabályozó engedélyező érintkezője. Fel van húzva, ezért csatlakoztassa a földhöz a 3.3 V-os szabályozó letiltásához. Ez azt jelenti, hogy ezt a nyomógombhoz csatlakoztatott tűt használhatja az ESP32 újraindításához, plample.
GPIO áramfelvétel
A GPIO-nként felvett abszolút maximális áram 40 mA az ESP32 adatlap „Ajánlott működési feltételek” szakasza szerint.
ESP32 beépített Hall effektus érzékelő
Az ESP32 beépített Hall effektus érzékelővel is rendelkezik, amely érzékeli a környezetében lévő mágneses tér változásait
ESP32 Arduino IDE
Van egy kiegészítő az Arduino IDE-hez, amely lehetővé teszi az ESP32 programozását az Arduino IDE és annak programozási nyelve segítségével. Ebben az oktatóanyagban megmutatjuk, hogyan telepítheti az ESP32 kártyát az Arduino IDE-ben, függetlenül attól, hogy Windows, Mac OS X vagy Linux rendszert használ.
Előfeltételek: Arduino IDE telepítve
A telepítési eljárás megkezdése előtt telepítenie kell az Arduino IDE-t a számítógépére. Az Arduino IDE két verziója telepíthető: az 1-es és a 2-es verzió.
Az Arduino IDE letöltéséhez és telepítéséhez kattintson a következő linkre: arduino.cc/en/Main/Software
Melyik Arduino IDE verziót ajánljuk? Jelenleg van néhány plugins az ESP32-hez (mint az SPIFFS Filerendszerfeltöltő beépülő modul), amelyek még nem támogatottak az Arduino 2-n. Ha tehát a jövőben használni kívánja az SPIFFS beépülő modult, javasoljuk a régebbi 1.8.X verzió telepítését. Csak le kell görgetnie az Arduino szoftver oldalán, hogy megtalálja.
Az ESP32 bővítmény telepítése az Arduino IDE-ben
Az ESP32 kártya Arduino IDE-be való telepítéséhez kövesse az alábbi utasításokat:

1. Az Arduino IDE-ben lépjen a következőre: File> Beállítások elemre
2. Írja be a következőket a „További testületi menedzser URLs” mező:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Ezután kattintson az „OK” gombra:Jegyzet: ha már megvannak az ESP8266 táblák URL, elválaszthatja a URLs vesszővel a következőképpen:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Nyissa meg a Boards Managert. Lépjen az Eszközök > Tábla > Táblakezelő...Keresse meg az ESP32-t, és nyomja meg az „ESP32 by Espressif Systems” telepítési gombot:Ennyi. Néhány másodperc múlva telepíteni kell.

Töltse fel a tesztkódot

Csatlakoztassa az ESP32 kártyát a számítógéphez. Az Arduino IDE megnyitásakor kövesse az alábbi lépéseket:

1. Válassza ki a táblát az Eszközök > Tábla menüben (esetemben ez az ESP32 DEV modul)
2. Válassza ki a portot (ha nem látja a COM-portot az Arduino IDE-ben, telepítenie kell a CP210x USB-t az UART Bridge VCP-illesztőprogramjaihoz):
3. Nyissa meg a következő plample alatt File > Plamples > WiFi
   (ESP32) > WiFiScan
4. Egy új vázlat nyílik meg az Arduino IDE-ben:
5. Nyomja meg a Feltöltés gombot az Arduino IDE-ben. Várjon néhány másodpercet, amíg a kód összeáll és feltöltődik a táblára.
6. Ha minden a várt módon ment, a „Feltöltés kész” üzenetnek kell megjelennie. üzenet.
7. Nyissa meg az Arduino IDE soros monitort 115200 adatátviteli sebességgel:
8. Nyomja meg az ESP32 beépített engedélyezése gombot, és látnia kell az ESP32 közelében elérhető hálózatokat:

Hibaelhárítás

Ha új vázlatot próbál feltölteni az ESP32-re, és ezt a hibaüzenetet kapja: „Végzetes hiba történt: Nem sikerült csatlakozni az ESP32-hez: Időtúllépés… Csatlakozás…”. Ez azt jelenti, hogy az ESP32 nincs villogó/feltöltés módban.
A megfelelő kártyanév és COM por kiválasztása után kövesse az alábbi lépéseket:
Tartsa lenyomva a „BOOT” gombot az ESP32 kártyán

• Nyomja meg a „Feltöltés” ​​gombot az Arduino IDE-ben a vázlat feltöltéséhez:
• Miután megjelenik a „Csatlakozás…” felirat. üzenetet az Arduino IDE-ben, engedje el az ujját a „BOOT” gombról:
• Ezt követően látnia kell a „Feltöltés kész” üzenetet
  Ennyi. Az ESP32-n futnia kell az új vázlatnak. Nyomja meg az „ENABLE” gombot az ESP32 újraindításához és az új feltöltött vázlat futtatásához.
  Ezt a gombsort is meg kell ismételnie minden alkalommal, amikor új vázlatot szeretne feltölteni.

1. projekt ESP32 bemenetek kimenetek

Ebből az első lépések útmutatóból megtudhatja, hogyan olvassa el a digitális bemeneteket, például egy gombos kapcsolót, és hogyan vezérelje a digitális kimeneteket, például egy LED-et az ESP32 és Arduino IDE segítségével.
Előfeltételek
Az ESP32-t Arduino IDE segítségével programozzuk. Tehát a folytatás előtt győződjön meg arról, hogy telepítette az ESP32 kártyák bővítményét:

• Az ESP32 bővítmény telepítése az Arduino IDE-ben

ESP32 vezérlő digitális kimenetek
Először is be kell állítania a vezérelni kívánt GPIO-t OUTPUT-ként. Használja a pinMode() függvényt az alábbiak szerint:
pinMode(GPIO, OUTPUT);
A digitális kimenet vezérléséhez csak a digitalWrite() függvényt kell használnia, amely elfogadja argumentumként, a hivatkozott GPIO-t (int szám), valamint a HIGH vagy LOW állapotot.
digitalWrite(GPIO, ÁLLAPOT);
Minden GPIO használható kimenetként, kivéve a 6–11. GPIO-t (csatlakoztatva az integrált SPI flash-hez) és a 34., 35., 36. és 39. GPIO-t (csak bemeneti GPIO-k);
Tudjon meg többet az ESP32 GPIO-król: ESP32 GPIO Reference Guide
ESP32 Digitális bemenetek olvasása
Először állítsa be az olvasni kívánt GPIO-t INPUT-ként a pinMode() függvény segítségével az alábbiak szerint:
pinMode(GPIO, INPUT);
A digitális bemenet, például egy gomb olvasásához a digitalRead() függvényt kell használni, amely argumentumként elfogadja az Ön által hivatkozott GPIO-t (int szám).
digitális olvasás (GPIO);
Minden ESP32 GPIO használható bemenetként, kivéve a 6-tól 11-ig terjedő GPIO-kat (az integrált SPI vakuhoz csatlakoztatva).
Tudjon meg többet az ESP32 GPIO-król: ESP32 GPIO Reference Guide
Projekt plample
A digitális bemenetek és digitális kimenetek használatának bemutatásához egy egyszerű projektet készítünk, plample nyomógombbal és LED-del. Leolvassuk a nyomógomb állapotát, és ennek megfelelően világítjuk a LED-et az alábbi ábrán látható módon.

Szükséges alkatrészek
Íme az áramkör felépítéséhez szükséges alkatrészek listája:

• ESP32 DEVKIT V1
• 5 mm-es LED
• 220 ohmos ellenállás
• Nyomógomb
• 10k Ohm ellenállás
• Kenyértábla
• Jumper vezetékek

Sematikus diagram
A folytatás előtt össze kell állítania egy áramkört LED-del és nyomógombbal.
A LED-et a GPIO 5-höz, a nyomógombot pedig a GPIO-hoz csatlakoztatjuk 4.Kód
Nyissa meg a Project_1_ESP32_Inputs_Outputs.ino kódot az arduino IDE-benHogyan működik a kód
A következő két sorban változókat hoz létre a tűk hozzárendeléséhez:

A gomb a GPIO 4-hez, a LED pedig a GPIO 5-höz csatlakozik. Ha az Arduino IDE-t ESP32-vel használja, a 4 a GPIO 4-nek, az 5 pedig a GPIO 5-nek felel meg.
Ezután hozzon létre egy változót a gomb állapotának megtartásához. Alapértelmezés szerint 0 (nincs lenyomva).
int gombÁllapot = 0;
A setup()-ban inicializálja a gombot INPUT-ként, a LED-et pedig OUTPUT-ként.
Ehhez használja a pinMode() függvényt, amely elfogadja az Ön által hivatkozott PIN-kódot, és a módot: INPUT vagy OUTPUT.
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
Az In the loop() itt olvasható le a gomb állapotáról, és ennek megfelelően állíthatja be a LED-et.
A következő sorban olvassa el a gomb állapotát, és mentse el a buttonState változóba.
Ahogy korábban láttuk, a digitalRead() függvényt használjuk.
buttonState = digitalRead(buttonPin);
A következő if utasítás azt ellenőrzi, hogy a gomb állapota HIGH. Ha igen, akkor a digitalWrite() függvény segítségével bekapcsolja a LED-et, amely argumentumként elfogadja a ledPin-t és a HIGH állapotot.
if (buttonState == HIGH)Ha a gomb állapota nem HIGH, akkor kikapcsolja a LED-et. Csak állítsa be a LOW értéket második argumentumként a digitalWrite() függvényben.A kód feltöltése
Mielőtt a feltöltés gombra kattintana, lépjen az Eszközök > Tábla elemre, és válassza ki a DOIT ESP32 DEVKIT V1 kártyát.
Válassza az Eszközök > Port lehetőséget, és válassza ki azt a COM-portot, amelyhez az ESP32 csatlakozik. Ezután nyomja meg a feltöltés gombot, és várja meg a „Feltöltés kész” üzenetet.Megjegyzés: Ha sok pontot lát (csatlakozás…__…__) a hibakereső ablakban, és a „Nem sikerült csatlakozni az ESP32-hez: Időtúllépés a csomagfejlécre várakozva” üzenetet, az azt jelenti, hogy meg kell nyomnia az ESP32 fedélzeti BOOT gombját. gombot a pontok után
kezdenek megjelenni.Hibaelhárítás

Demonstráció

A kód feltöltése után tesztelje az áramkört. A LED-nek világítania kell, amikor megnyomja a nyomógombot:És kapcsolja ki, amikor elengedi:

Project 2 ESP32 analóg bemenetek

Ez a projekt bemutatja, hogyan kell az analóg bemeneteket olvasni az ESP32-vel az Arduino IDE használatával.
Az analóg leolvasás hasznos változó ellenállásokból, például potenciométerekből vagy analóg érzékelőkből származó értékek olvasásához.
Analóg bemenetek (ADC)
Az analóg érték ESP32-vel történő leolvasása azt jelenti, hogy megmérheti a változó térfogatottage 0 V és 3.3 V között van.
A kötettagA mért e értéket ezután 0 és 4095 közötti értékhez rendeljük, amelyben a 0 V 0-nak, a 3.3 V pedig 4095-nek felel meg.tage 0 V és 3.3 V között a megfelelő értéket kapjuk.Az ADC nemlineáris
Ideális esetben lineáris viselkedés várható az ESP32 ADC érintkezők használatakor.
Ez azonban nem történik meg. A következő diagramon látható viselkedést fog kapni:Ez a viselkedés azt jelenti, hogy az ESP32 nem képes megkülönböztetni a 3.3 V-ot a 3.2 V-tól.
Mindkét kötetre ugyanazt az értéket kapjatages: 4095.
Ugyanez történik nagyon alacsony hangerő esetén istage értékek: 0 V és 0.1 V esetén ugyanazt az értéket kapja: 0. Ezt szem előtt kell tartania az ESP32 ADC érintkezők használatakor.
analogRead() függvény
Az analóg bemenet olvasása az ESP32-vel az Arduino IDE használatával olyan egyszerű, mint az analógRead() függvény használata. Érvként elfogadja az olvasni kívánt GPIO-t:
analogRead(GPIO);
Csak 15 érhető el a DEVKIT V1boardon (30 GPIO-val rendelkező verzió).
Fogja meg az ESP32 kártya kivezetését, és keresse meg az ADC érintkezőit. Ezek az alábbi ábrán piros kerettel vannak kiemelve.Ezek az analóg bemeneti érintkezők 12 bites felbontással rendelkeznek. Ez azt jelenti, hogy amikor egy analóg bemenetet olvas, annak tartománya 0 és 4095 között változhat.
Megjegyzés: Az ADC2 érintkezők nem használhatók Wi-Fi használata esetén. Tehát, ha Wi-Fi-t használ, és problémái vannak az ADC2 GPIO értékének lekérésével, fontolja meg egy ADC1 GPIO használatát, amely megoldja a problémát.
Hogy lássuk, hogyan kapcsolódik minden egymáshoz, készítünk egy egyszerű exetample leolvasni egy analóg értéket egy potenciométerről.
Szükséges alkatrészek
Ennek az example, a következő alkatrészekre van szüksége:

• ESP32 DEVKIT V1 tábla
• Potenciométer
• Kenyértábla
• Jumper vezetékek

Vázlatos
Csatlakoztasson egy potenciométert az ESP32-hez. A potenciométer középső érintkezőjét a GPIO 4-hez kell csatlakoztatni. Referenciaként használhatja a következő sematikus ábrát.Kód
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy telepítve van az ESP32 kiegészítő: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-ben
Nyissa meg a Project_2_ESP32_Inputs_Outputs.ino kódot az arduino IDE-benEz a kód egyszerűen kiolvassa az értékeket a potenciométerről, és kiírja ezeket az értékeket a soros monitorba.
A kódban először meghatározza azt a GPIO-t, amelyhez a potenciométer csatlakozik. Ebben az example, GPIO 4.A setup()-ban inicializáljon egy soros kommunikációt 115200 adatátviteli sebességgel.A loop()-ban használja az analogRead() függvényt az analóg bemenet olvasásához a potPin-ből.Végül nyomtassa ki a potenciométerről leolvasott értékeket a soros monitoron.Töltse fel a kapott kódot az ESP32-re. Győződjön meg arról, hogy a megfelelő kártya és COM port van kiválasztva az Eszközök menüben.
Az Ex teszteléseample
A kód feltöltése és az ESP32 reset gomb megnyomása után nyissa meg a Serial Monitort 115200 adatátviteli sebességgel. Forgassa el a potenciométert, és nézze meg az értékek változását.A maximális érték 4095, a minimális érték pedig 0.

Becsomagolás

Ebből a cikkből megtanulta, hogyan olvassa el az analóg bemeneteket az ESP32 használatával az Arduino IDE-vel. Összefoglalva:

• Az ESP32 DEVKIT V1 DOIT kártya (30 tűs változat) 15 ADC tűvel rendelkezik, amelyek segítségével az analóg bemeneteket olvashatja.
• Ezek a tűk 12 bites felbontással rendelkeznek, ami azt jelenti, hogy 0 és 4095 közötti értékeket kaphat.
• Egy érték beolvasásához az Arduino IDE-ben egyszerűen használja az analogRead() függvényt.
• Az ESP32 ADC tűi nem lineárisak. Valószínűleg nem fog tudni különbséget tenni 0 és 0.1 V, illetve 3.2 és 3.3 V között. Ezt szem előtt kell tartania az ADC érintkezők használatakor.

Project 3 ESP32 PWM (analóg kimenet)

Ebben az oktatóanyagban bemutatjuk, hogyan generálhat PWM jeleket az ESP32 segítségével az Arduino IDE használatával. Mint exampAz ESP32 LED PWM vezérlőjének segítségével egy egyszerű áramkört építünk, amely tompítja a LED-et.ESP32 LED PWM vezérlő
Az ESP32 LED PWM vezérlővel rendelkezik 16 független csatornával, amely konfigurálható különböző tulajdonságú PWM jelek generálására.
Íme a lépések, amelyeket követnie kell a LED PWM-mel történő tompításához az Arduino IDE használatával:

1. Először is ki kell választania egy PWM csatornát. 16 csatorna van 0 és 15 között.
2. Ezután be kell állítania a PWM jel frekvenciáját. LED-eknél 5000 Hz-es frekvencia megfelelő.
3. Be kell állítani a jel terhelhetőségi felbontását is: 1 és 16 bit közötti felbontások vannak. 8 bites felbontást használunk, ami azt jelenti, hogy a LED fényerejét 0 és 255 közötti értékkel szabályozhatja.
4.  Ezután meg kell adnia, hogy melyik GPIO-n vagy GPIO-kon jelenjen meg a jel. Ehhez a következő függvényt kell használni:
   ledcAttachPin (GPIO, csatorna)
   Ez a függvény két argumentumot fogad el. Az első a GPIO, amely a jelet adja ki, a második pedig a csatorna, amely a jelet generálja.
5. Végül a LED fényerejének PWM segítségével történő szabályozásához használja a következő funkciót:

ledcWrite(csatorna, munkaciklus)
Ez a függvény argumentumként elfogadja a PWM jelet generáló csatornát és a munkaciklust.
Szükséges alkatrészek
Az oktatóanyag követéséhez a következő részekre lesz szüksége:

• ESP32 DEVKIT V1 tábla
• 5mm LED
• 220 ohmos ellenállás
•  Kenyértábla
• Jumper vezetékek

Vázlatos
Csatlakoztasson egy LED-et az ESP32-hez az alábbi kapcsolási rajz szerint. A LED-et a GPIO-hoz kell csatlakoztatni 4.Jegyzet: tetszőleges tűt használhat, amennyiben kimenetként működik. Minden kimenet, amelyik kimenetként működhet, használható PWM lábként. Az ESP32 GPIO-kkal kapcsolatos további információkért olvassa el a következőt: ESP32 Pinout Reference: Milyen GPIO érintkezőket érdemes használni?
Kód
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy telepítve van az ESP32 kiegészítő: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-ben
Nyissa meg a Project_3_ESP32_PWM.ino kódot az arduino IDE-benKezdje azzal, hogy meghatározza azt a tűt, amelyhez a LED csatlakozik. Ebben az esetben a LED a GPIO 4-hez van csatlakoztatva.Ezután beállíthatja a PWM jel tulajdonságait. Meghatározhatja az 5000 Hz-es frekvenciát, kiválasztja a 0-s csatornát a jel generálásához, és beállítja a 8 bites felbontást. Ezektől eltérő tulajdonságokat is választhat, hogy különböző PWM jeleket generáljon.A setup()-ban be kell állítania a LED PWM-et azokkal a tulajdonságokkal, amelyeket korábban definiált a ledcSetup() függvény segítségével, amely argumentumként elfogadja a ledChannel-t, a frekvenciát és a felbontást, az alábbiak szerint:Ezután ki kell választania azt a GPIO-t, amelyről a jelet kapja. Ehhez használja a ledcAttachPin() függvényt, amely elfogadja argumentumként azt a GPIO-t, ahol a jelet szeretné megkapni, és a jelet előállító csatornát. Ebben az example, akkor a ledPin GPIO-ban kapjuk meg a jelet, ami megfelel a GPIO 4-nek. A jelet generáló csatorna a ledChannel, ami a 0-s csatornának felel meg.A ciklus során a munkaciklust 0 és 255 között változtathatja a LED fényerejének növelése érdekében.Majd 255 és 0 között a fényerő csökkentéséhez.A LED fényerejének beállításához csak a ledcWrite() függvényt kell használni, amely argumentumként elfogadja a jelet generáló csatornát és a munkaciklust.Mivel 8 bites felbontást használunk, a munkaciklust 0 és 255 közötti értékkel szabályozzuk. Vegye figyelembe, hogy a ledcWrite() függvényben azt a csatornát használjuk, amely a jelet generálja, és nem a GPIO-t.

Az Ex teszteléseample

Töltse fel a kódot az ESP32-re. Győződjön meg arról, hogy a megfelelő kártya és COM port van kiválasztva. Nézd meg az áramkörödet. Legyen egy dimmer LED, amely növeli és csökkenti a fényerőt.

Project 4 ESP32 PIR mozgásérzékelő

Ez a projekt bemutatja, hogyan lehet mozgást észlelni az ESP32-vel PIR mozgásérzékelő segítségével. A hangjelző riaszt, ha mozgást észlel, és leállítja a riasztást, ha egy előre beállított ideig (például 4 másodpercig) nem érzékel mozgást.
Hogyan működik a HC-SR501 mozgásérzékelő
.A HC-SR501 érzékelő működési elve a mozgó tárgy infravörös sugárzásának változásán alapul. Ahhoz, hogy a HC-SR501 érzékelő észlelje, az objektumnak két követelménynek kell megfelelnie:

• Az objektum infravörös sugárzást bocsát ki.
• A tárgy mozog vagy remeg

Így:
Ha egy tárgy kibocsátja az infravörös sugarat, de NEM mozog (pl. egy személy mozdulatlanul áll), azt NEM érzékeli az érzékelő.
Ha egy tárgy mozog, de NEM bocsát ki infravörös sugarat (pl. robot vagy jármű), azt NEM érzékeli az érzékelő.
Bemutatjuk az időzítőket
Ebben az exampidőzítőket is bevezetünk. Azt akarjuk, hogy a LED egy előre meghatározott számú másodpercig égve maradjon a mozgás észlelése után. Ahelyett, hogy egy delay() függvényt használnánk, amely blokkolja a kódot, és nem engedi meg, hogy mást csináljon meghatározott számú másodpercig, időzítőt kell használnunk.A delay() függvény
Ismernie kell a delay() függvényt, mivel széles körben használják. Ez a funkció meglehetősen egyszerűen használható. Egyetlen int számot fogad el argumentumként.
Ez a szám azt az időt jelenti ezredmásodpercben, amelyet a programnak várnia kell, amíg a következő kódsorra lép.Ha késlelteted (1000), a programod 1 másodpercre megáll ezen a vonalon.
A delay() egy blokkoló függvény. A blokkoló funkciók megakadályozzák, hogy a program bármi mást tegyen, amíg az adott feladat be nem fejeződik. Ha egyszerre több feladatra van szüksége, akkor nem használhatja a delay(t) funkciót.
A legtöbb projektnél kerülni kell a késleltetést, helyette időzítőket kell használni.
A millis() függvény
A millis() függvény segítségével visszaadhatja a program első indítása óta eltelt ezredmásodpercek számát.Miért hasznos ez a funkció? Mert némi matematikai számítással könnyen ellenőrizheti, hogy mennyi idő telt el anélkül, hogy blokkolná a kódot.
Szükséges alkatrészek
Az oktatóanyag követéséhez a következő részekre van szüksége

• ESP32 DEVKIT V1 tábla
• PIR mozgásérzékelő (HC-SR501)
• Aktív hangjelző
• Jumper vezetékek
• Kenyértábla

VázlatosJegyzet: A munkaköttagA HC-SR501 e 5V. Használja a Vin tűt a tápellátáshoz.
Kód
Mielőtt folytatná ezt az oktatóanyagot, telepítenie kell az ESP32 kiegészítőt az Arduino IDE-be. Ha még nem tette meg, kövesse az alábbi oktatóanyagok egyikét az ESP32 telepítéséhez az Arduino IDE-re. (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-ben
Nyissa meg a Project_4_ESP32_PIR_Motion_Sensor.ino kódot az arduino IDE-ben.
Demonstráció
Töltse fel a kódot az ESP32 kártyára. Győződjön meg arról, hogy a megfelelő kártyát és COM-portot választotta ki.Töltse fel a kód hivatkozási lépéseit.
Nyissa meg a soros monitort 115200 XNUMX adatátviteli sebességgel.Mozgassa a kezét a PIR érzékelő elé. A hangjelzésnek be kell kapcsolnia, és a soros monitoron megjelenik a „Motion detected!Buzzer alarm” üzenet.
4 másodperc elteltével a hangjelzésnek ki kell kapcsolnia.

Project 5 ESP32 kapcsoló Web Szerver

Ebben a projektben önállót hoz létre web szerver ESP32-vel, amely az Arduino IDE programozási környezet segítségével vezérli a kimeneteket (két LED). A web A szerver mobilra érzékeny, és bármely eszközzel elérhető, amely böngészőként működik a helyi hálózaton. Megmutatjuk, hogyan kell létrehozni a web szervert és a kód működését lépésről lépésre.
Projekt végetview
Mielőtt közvetlenül rátérnénk a projektre, fontos felvázolni, hogy mi a miénk web szerver megteszi, így a későbbiekben könnyebben követheti a lépéseket.

• A web az elkészített szerver két LED-et vezérel, amelyek az ESP32 GPIO 26-hoz és GPIO 27-hez vannak csatlakoztatva;
• Hozzáférhet az ESP32-hez web szerverre az ESP32 IP-cím beírásával a helyi hálózat böngészőjében;
• A saját gombjaira kattintva web szerveren azonnal megváltoztathatja az egyes LED-ek állapotát.

Szükséges alkatrészek
Ehhez az oktatóanyaghoz a következő részekre lesz szüksége:

• ESP32 DEVKIT V1 tábla
• 2x 5mm LED
• 2x 200 ohmos ellenállás
• Kenyértábla
• Jumper vezetékek

Vázlatos
Kezdje az áramkör felépítésével. Csatlakoztasson két LED-et az ESP32-höz az alábbi kapcsolási rajz szerint – az egyik LED a GPIO 26-hoz, a másik pedig a GPIO 27-hez csatlakozik.
Jegyzet: 32 tűs ESP36 DEVKIT DOIT kártyát használunk. Az áramkör összeszerelése előtt győződjön meg arról, hogy ellenőrizze a használt kártya kivezetését.Kód
Itt megadjuk az ESP32-t létrehozó kódot web szerver. Nyissa meg a Project_5_ESP32_Switch _ kódotWeb_Server.ino az arduino IDE-ben, de még ne töltse fel. Néhány változtatást kell végrehajtania, hogy működjön az Ön számára.
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy telepítve van az ESP32 kiegészítő: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-ben
A hálózati hitelesítési adatok beállítása
A következő sorokat kell módosítania a hálózati hitelesítő adataival: SSID és jelszó. A kód jól meg van írva, hogy hol kell módosítani.A kód feltöltése
Most feltöltheti a kódot és a web a szerver azonnal működni fog.
Kövesse a következő lépéseket a kód ESP32-re való feltöltéséhez:

1. Csatlakoztassa az ESP32 kártyát a számítógéphez;
2. Az Arduino IDE-ben válassza ki a kártyát az Eszközök > Tábla menüpontban (esetünkben az ESP32 DEVKIT DOIT kártyát használjuk);
3. Válassza ki a COM-portot az Eszközök > Port menüpontban.
4. Nyomja meg a Feltöltés gombot az Arduino IDE-ben, és várjon néhány másodpercet, amíg a kód összeáll és feltöltődik a táblára.
5. Várja meg a „Feltöltés kész” üzenetet.

Az ESP IP-cím megkeresése
A kód feltöltése után nyissa meg a Serial Monitort 115200 adatátviteli sebességgel.Nyomja meg az ESP32 EN gombot (reset). Az ESP32 csatlakozik a Wi-Fi-hez, és kiadja az ESP IP-címét a soros monitoron. Másolja ki ezt az IP-címet, mert szüksége van rá az ESP32 eléréséhez web szerver.Hozzáférés a Web Szerver
Ahhoz, hogy hozzáférjen a web szervert, nyissa meg a böngészőt, illessze be az ESP32 IP-címét, és megjelenik a következő oldal.
Jegyzet: A böngészőnek és az ESP32-nek ugyanahhoz a LAN-hoz kell csatlakoznia.Ha megnézi a Serial Monitort, láthatja, mi történik a háttérben. Az ESP HTTP kérést kap egy új klienstől (jelen esetben a böngészőtől).További információkat is láthat a HTTP-kérésről.
Demonstráció
Most tesztelheti, hogy a saját web a szerver megfelelően működik. Kattintson a gombokra a LED-ek vezérléséhez.Ugyanakkor egy pillantást vethet a Serial Monitorra, hogy megnézze, mi történik a háttérben. Plampha rákattint a gombra a GPIO 26 ON bekapcsolásához, az ESP32 kérést kap a /26/on URL.Amikor az ESP32 megkapja ezt a kérést, bekapcsolja a GPIO 26-hoz csatlakoztatott LED-et, és frissíti az állapotát a web oldalon.A GPIO 27 gombja hasonló módon működik. Tesztelje, hogy megfelelően működik-e.

Hogyan működik a kód

Ebben a részben közelebbről megvizsgáljuk a kódot, hogy megtudjuk, hogyan működik.
Az első dolog, amit meg kell tennie, hogy tartalmazza a WiFi könyvtárat.Mint korábban említettük, az ssid-t és a jelszót a következő sorokba kell beírnia az idézőjelbe.Ezután beállítja a sajátját web szerver a 80-as portra.A következő sor létrehoz egy változót a HTTP-kérés fejlécének tárolására:Ezután létrehozhat segédváltozókat a kimenetek aktuális állapotának tárolására. Ha több kimenetet szeretne hozzáadni, és el szeretné menteni az állapotát, több változót kell létrehoznia.Ezenkívül minden kimenethez hozzá kell rendelnie egy GPIO-t. Itt a GPIO 26-ot és a GPIO 27-et használjuk. Bármilyen más megfelelő GPIO-t használhat.setup()
Most menjünk a setup()-ba. Először soros kommunikációt indítunk 115200 adatátviteli sebességgel hibakeresési célból.A GPIO-kat OUTPUT-ként is meghatározhatja, és LOW-ra állíthatja.A következő sorok a WiFi.begin(ssid, password) paranccsal kezdik a Wi-Fi kapcsolatot, várják meg a sikeres csatlakozást, és nyomtassák ki az ESP IP-címet a Serial Monitorban.hurok()
A loop()-ban programozzuk, hogy mi történik, ha egy új kliens kapcsolatot létesít a web szerver.
Az ESP32 mindig a következő vonallal figyeli a bejövő ügyfeleket:Amikor egy ügyféltől kérés érkezik, elmentjük a beérkező adatokat. Az ezt követő while ciklus mindaddig fut, amíg az ügyfél kapcsolatban marad. Nem javasoljuk a kód következő részének megváltoztatását, hacsak nem tudja pontosan, mit csinál.Az if és else utasítások következő szakasza azt ellenőrzi, hogy melyik gombot nyomta meg az Ön web oldalon, és ennek megfelelően vezérli a kimeneteket. Amint azt korábban láttuk, másra is kérünk URLs a megnyomott gombtól függően.Plampha megnyomta a GPIO 26 ON gombot, az ESP32 kérést kap a /26/ON URL (Ezt az információt láthatjuk a Serial Monitor HTTP-fejlécében). Így ellenőrizhetjük, hogy a fejléc tartalmazza-e a GET /26/on kifejezést. Ha tartalmazza, akkor az output26state változót ON-ra állítjuk, és az ESP32 bekapcsolja a LED-et.
Ez hasonlóan működik a többi gombnál is. Tehát, ha további kimeneteket szeretne hozzáadni, módosítania kell a kód ezen részét, hogy tartalmazza azokat.
A HTML megjelenítése web oldalon
A következő dolog, amit meg kell tennie, az a web oldalon. Az ESP32 választ küld a böngészőjének néhány HTML-kóddal a létrehozásához web oldalon.
A web oldal a client.println() kifejezés használatával kerül elküldésre az ügyfélnek. Érvként meg kell adnia, hogy mit szeretne küldeni az ügyfélnek.
Az első dolog, amit el kell küldenünk, mindig a következő sor, amely azt jelzi, hogy HTML-t küldünk.Ezután a következő sor a web oldal bármelyben reszponzív web böngésző.A következőket pedig arra használjuk, hogy megakadályozzuk a kéréseket a faviconban. – Nem kell aggódnia emiatt a vonal miatt.

Stilizálás a Web oldal

Ezután van néhány CSS-szövegünk a gombok stílusához és a web oldal megjelenése.
Kiválasztjuk a Helvetica betűtípust, meghatározzuk a megjelenítendő tartalmat blokkként és középre igazítva.Gombjainkat #4CAF50 színnel, szegély nélkül, fehér színű szöveggel és ezzel a párnázással: 16px 40px. A szövegdekorációt is none-ra állítjuk, a betűméretet, a margót és a kurzort egy pointerre állítjuk.Meghatározzuk egy második gomb stílusát is, a gomb összes tulajdonságával, amit korábban definiáltunk, de más színnel. Ez lesz a kikapcsoló gomb stílusa.

Beállítása a Web Oldal első címsora
A következő sorban beállíthatja az első címsort web oldalon. Itt van az „ESP32 Web Szerver”, de ezt a szöveget tetszés szerint módosíthatja.A gombok és a megfelelő állapot megjelenítése
Ezután írjon egy bekezdést a GPIO 26 aktuális állapotának megjelenítéséhez. Amint láthatja, az output26State változót használjuk, így az állapot azonnal frissül, amikor ez a változó megváltozik.Ezután a GPIO aktuális állapotától függően megjelenítjük a be vagy a ki gombot. Ha a GPIO aktuális állapota ki van kapcsolva, akkor az ON gombot, ha nem, az OFF gombot jelenítjük meg.Ugyanezt az eljárást alkalmazzuk a GPIO 27 esetében is.
A kapcsolat lezárása
Végül, amikor a válasz véget ér, töröljük a fejlécváltozót, és leállítjuk a kapcsolatot az ügyféllel a client.stop() segítségével.

Becsomagolás

Ebben az oktatóanyagban megmutattuk, hogyan kell felépíteni a web szerver ESP32-vel. Mutattunk egy egyszerű exetampEz két LED-et vezérel, de az ötlet az, hogy ezeket a LED-eket relével vagy bármilyen más vezérelni kívánt kimenettel helyettesítsék.

Project 6 RGB LED Web Szerver

Ebben a projektben megmutatjuk, hogyan lehet távolról vezérelni egy RGB LED-et ESP32 kártyával a web szerver színválasztóval.
Projekt végetview
Mielőtt elkezdené, nézzük meg, hogyan működik ez a projekt:

• Az ESP32 web a szerver színválasztót jelenít meg.
• Amikor kiválaszt egy színt, a böngészője kérést küld a URL amely tartalmazza a kiválasztott szín R, G és B paramétereit.
• Az ESP32 fogadja a kérést, és felosztja az értéket az egyes színparaméterekhez.
• Ezután a megfelelő értékű PWM-jelet küldi az RGB LED-et vezérlő GPIO-knak.

Hogyan működnek az RGB LED-ek?
Egy közös katódú RGB LED-ben mindhárom LED negatív csatlakozáson (katódon) osztozik. A készlet mindegyike közös katódú RGB.Hogyan készítsünk különböző színeket?
RGB LED-del természetesen piros, zöld és kék fényt is előállíthatunk, illetve az egyes LED-ek intenzitásának konfigurálásával más színeket is előállíthatunk.
PlampA tisztán kék fény előállításához a kék LED-et a legmagasabb, a zöld és a piros LED-eket pedig a legalacsonyabb intenzitásra kell állítani. Fehér fényhez mindhárom LED-et a legmagasabb intenzitásra kell állítani.
Színek keverése
Más színek előállításához a három színt különböző intenzitással kombinálhatja. Az egyes LED-ek intenzitásának beállításához PWM jelet használhat.
Mivel a LED-ek nagyon közel vannak egymáshoz, szemünk inkább a színkombináció eredményét látja, nem pedig a három színt külön-külön.
Ha ötletet szeretne a színek kombinálására, tekintse meg a következő táblázatot.
Ez a legegyszerűbb színkeverési táblázat, de ötletet ad a működéséről és a különböző színek előállításáról.Szükséges alkatrészek
Ehhez a projekthez a következő alkatrészekre van szüksége:

• ESP32 DEVKIT V1 tábla
• RGB LED
• 3x 220 ohmos ellenállás
• Jumper vezetékek
• Kenyértábla

VázlatosKód
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy telepítve van az ESP32 kiegészítő: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)

• Az ESP32 bővítmény telepítése az Arduino IDE-ben

Az áramkör összeszerelése után nyissa meg a kódot
Projekt_6_RGB_LED_Web_Server.ino az arduino IDE-ben.
A kód feltöltése előtt ne felejtse el beírni a hálózati hitelesítő adatait, hogy az ESP csatlakozhasson a helyi hálózathoz.Hogyan működik a kód
Az ESP32 vázlat a WiFi.h könyvtárat használja.A következő sorok karakterlánc-változókat határoznak meg a kérelem R, G és B paramétereinek tárolására.A következő négy változó a HTTP-kérés későbbi dekódolására szolgál.Hozzon létre három változót a GPIO-khoz, amelyek az R, G és B sáv paramétereit vezérlik. Ebben az esetben a GPIO 13-at, a GPIO 12-t és a GPIO 14-et használjuk.Ezeknek a GPIO-knak PWM jeleket kell kiadniuk, ezért először a PWM tulajdonságait kell konfigurálnunk. Állítsa a PWM jel frekvenciáját 5000 Hz-re. Ezután minden színhez társítson egy PWM-csatornátÉs végül állítsa a PWM csatornák felbontását 8 bitesreA setup()-ban rendelje hozzá a PWM-tulajdonságokat a PWM-csatornákhozCsatlakoztassa a PWM csatornákat a megfelelő GPIO-khozA következő kódrész a színválasztót jeleníti meg web oldalt, és kérést küld a kiválasztott szín alapján.Amikor kiválaszt egy színt, a következő formátumú kérést kapja.

Tehát fel kell osztanunk ezt a karakterláncot, hogy megkapjuk az R, G és B paramétereket. A paraméterek redString, greenString és blueString változókban vannak elmentve, és értéke 0 és 255 között lehet.A szalag ESP32-vel történő vezérléséhez használja a ledcWrite() függvényt PWM jelek generálásához a HTTP-ből dekódolt értékekkel kér.Jegyzet: Tudjon meg többet a PWM-ről ESP32-vel: Project 3 ESP32 PWM (analóg kimenet)
A szalag ESP8266-tal történő vezérléséhez csak használnunk kell
az analogWrite() függvény PWM-jelek generálására a HTPP-kérésből dekódolt értékekkel.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
Mivel az értékeket egy karakterlánc-változóban kapjuk meg, a toInt() metódus segítségével egész számokká kell konvertálnunk őket.
Demonstráció
A hálózati hitelesítő adatok beillesztése után válassza ki a megfelelő kártyát és COM-portot, és töltse fel a kódot az ESP32-be. A kód feltöltése hivatkozási lépések.
Feltöltés után nyissa meg a Serial Monitort 115200 adatátviteli sebességgel, és nyomja meg az ESP engedélyezése/visszaállítása gombot. Meg kell kapnia a tábla IP-címét.Nyissa meg a böngészőt, és írja be az ESP IP-címét. Most használja a színválasztót az RGB LED színének kiválasztásához.
Ezután meg kell nyomnia a „Szín módosítása” gombot, hogy a szín érvénybe lépjen.Az RGB LED kikapcsolásához válassza ki a fekete színt.
A legerősebb színek (a színválasztó tetején) azok, amelyek jobb eredményeket produkálnak.

Project 7 ESP32 relé Web Szerver

A relé használata az ESP32-vel nagyszerű módja az AC háztartási készülékek távoli vezérlésének. Ez az oktatóanyag elmagyarázza, hogyan lehet vezérelni egy relémodult az ESP32-vel.
Megnézzük, hogyan működik a relémodul, hogyan lehet a relét csatlakoztatni az ESP32-höz, és web szerver egy relé távoli vezérléséhez.
Bemutatkozik a relék
A relé egy elektromosan működtetett kapcsoló, és mint minden más kapcsoló, ez is be- és kikapcsolható, átengedi az áramot vagy sem. Alacsony hangerővel vezérelhetőtagmint az ESP3.3 GPIO-k által biztosított 32 V, és lehetővé teszi a nagy hangerő szabályozásáttagpéldául 12V, 24V vagy hálózati feszültségtage (230 V Európában és 120 V az USA-ban).A bal oldalon két három aljzat található a nagy hangerő csatlakoztatásáhoztages, és a csapok a jobb oldalon (low-voltage) csatlakozzon az ESP32 GPIO-khoz.
Mains Voltage KapcsolatokAz előző képen látható relémodul két csatlakozóval rendelkezik, mindegyik három aljzattal: közös (COM), normál zárt (NC) és normál nyitott (NO).

• COM: csatlakoztassa a vezérelni kívánt áramot (hálózati köttagés).
• NC (Normally Closed): az alaphelyzetben zárt konfigurációt használja, ha azt szeretné, hogy a relé alapértelmezés szerint zárva legyen. Az NC COM érintkezők csatlakoztatva vannak, ami azt jelenti, hogy az áram folyik, hacsak nem küld jelet az ESP32-től a relémodulhoz, hogy megnyissa az áramkört és leállítsa az áram áramlását.
• NO (Normally Open): a normál nyitott konfiguráció fordítva működik: nincs kapcsolat a NO és a COM érintkezők között, így az áramkör megszakad, hacsak nem küld jelet az ESP32-től az áramkör lezárására.

VezérlőcsapokA kis térfogatútagAz egyik oldalon egy négy és egy három tűből álló készlet található. Az első készlet a VCC-ből és a GND-ből áll a modul bekapcsolásához, valamint az 1-es bemenetből (IN1) és a 2-es bemenetből (IN2) az alsó és felső relék vezérléséhez.
Ha a relémodulnak csak egy csatornája van, akkor csak egy IN érintkezője lesz. Ha négy csatornája van, akkor négy bemeneti tűje lesz, és így tovább.
Az IN érintkezőkre küldött jel határozza meg, hogy a relé aktív-e vagy sem. A relé akkor aktiválódik, ha a bemenet kb. 2V alá esik. Ez azt jelenti, hogy a következő forgatókönyvek lesznek:

• Normálisan zárt konfiguráció (NC):
• HIGH jel – áram folyik
• LOW jel – az áram nem folyik
• Normálisan nyitott konfiguráció (NO):
• HIGH jel – az áram nem folyik
• LOW jel – áram folyik

Normálisan zárt konfigurációt kell használni, amikor az áramnak legtöbbször folynia kell, és csak időnként szeretné leállítani.
Használjon normál nyitott konfigurációt, ha azt szeretné, hogy az áram időnként folyjon (plample, kapcsolja be az alamp néha).
Tápegység kiválasztásaA második érintkezőkészlet GND, VCC és JD-VCC érintkezőkből áll.
A JD-VCC érintkező táplálja a relé elektromágnesét. Figyelje meg, hogy a modul egy áthidaló sapkával rendelkezik, amely összeköti a VCC és a JD-VCC érintkezőket; az itt látható sárga, de a tiéd más színű lehet.
Az áthidaló sapkával a VCC és a JD-VCC érintkezők csatlakoztatva vannak. Ez azt jelenti, hogy a relé elektromágnes közvetlenül az ESP32 tápérintkezőjéről táplálkozik, így a relémodul és az ESP32 áramkörök nincsenek fizikailag elszigetelve egymástól.
A jumpersapka nélkül független áramforrást kell biztosítania a relé elektromágnesének a JD-VCC érintkezőn keresztüli táplálásához. Ez a konfiguráció fizikailag leválasztja a reléket az ESP32-ről a modul beépített optocsatolójával, amely megakadályozza az ESP32 károsodását elektromos tüskék esetén.
VázlatosFigyelmeztetés: Nagy térfogatú használatatagA tápegységek súlyos sérüléseket okozhatnak.
Ezért 5 mm-es LED-eket használnak a nagy tápfeszültség helyetttage izzók a kísérletben. Ha nem ismeri a hálózati köttagKérj meg valakit, aki segít neked. Az ESP programozása vagy az áramkör bekötése közben győződjön meg arról, hogy minden le van választva a hálózatróltage.Az ESP32 könyvtárának telepítése
Ezt megépíteni web szerver, az ESPAsync-et használjukWebSzerverkönyvtár és AsyncTCP könyvtár.
Az ESPAsync telepítéseWebSzerver könyvtár
Kövesse a következő lépéseket a telepítéshez ESPAsyncWebSzerver könyvtár:

1. Kattintson ide az ESPAsync letöltéséhezWebSzerver könyvtár. kellett volna
   egy .zip mappát a Letöltések mappában
2. Csomagolja ki a .zip mappát, és meg kell szereznie az ESPAsync-etWebServer-master mappa
3. Nevezze át a mappát az ESPAsync alkalmazásbólWebServer-master az ESPAsynchezWebSzerver
4. Helyezze át az ESPAsync-etWebA szerver mappát az Arduino IDE telepítési könyvtárak mappájába

Alternatív megoldásként az Arduino IDE-ben lépjen a Sketch > Include menüpontra
Könyvtár > .ZIP-könyvtár hozzáadása…, és válassza ki az éppen letöltött könyvtárat.
Az ESP32 AsyncTCP könyvtárának telepítése
A ESPAsyncWebSzerver könyvtár igényli a AsyncTCP könyvtár dolgozni. Kövesd
a következő lépések a könyvtár telepítéséhez:

1. Kattintson ide az AsyncTCP könyvtár letöltéséhez. A Letöltések mappában kell lennie egy .zip mappának
2. Csomagolja ki a .zip mappát, és megkapja az AsyncTCP-master mappát
   1. Nevezze át mappáját AsyncTCP-masterről AsyncTCP-re
   3. Helyezze át az AsyncTCP mappát az Arduino IDE telepítési könyvtárak mappájába
   4. Végül nyissa meg újra az Arduino IDE-t

Alternatív megoldásként az Arduino IDE-ben lépjen a Sketch > Include menüpontra
Könyvtár > .ZIP-könyvtár hozzáadása…, és válassza ki az éppen letöltött könyvtárat.
Kód
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy telepítve van az ESP32 kiegészítő: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-ben
A szükséges könyvtárak telepítése után nyissa meg a Project_7_ESP32_Relay_ kódotWeb_Server.ino az arduino IDE-ben.
A kód feltöltése előtt ne felejtse el beírni a hálózati hitelesítő adatait, hogy az ESP csatlakozhasson a helyi hálózathoz.Demonstráció
A szükséges módosítások elvégzése után töltse fel a kódot az ESP32-be. A kód feltöltésének hivatkozási lépései.
Nyissa meg a Serial Monitort 115200 adatátviteli sebességgel, és nyomja meg az ESP32 EN gombot az IP-cím megszerzéséhez. Ezután nyissa meg a böngészőt a helyi hálózaton, és írja be az ESP32 IP-címét, hogy hozzáférjen a web szerver.
Nyissa meg a Serial Monitort 115200 adatátviteli sebességgel, és nyomja meg az ESP32 EN gombot az IP-cím megszerzéséhez. Ezután nyissa meg a böngészőt a helyi hálózaton, és írja be az ESP32 IP-címét, hogy hozzáférjen a web szerver.Jegyzet: A böngészőnek és az ESP32-nek ugyanahhoz a LAN-hoz kell csatlakoznia.
A kódban megadott relék számának megfelelően két gombbal a következőket kell kapnia.Mostantól a gombokkal vezérelheti a reléket okostelefonjával.

Project_8_Output_State_State_Synchronization_ Web_Szerver

Ez a projekt bemutatja, hogyan vezérelheti az ESP32 vagy ESP8266 kimeneteket a web szervert és egy fizikai gombot egyszerre. A kimenet állapota frissül a web oldalt, hogy a fizikai gombbal változtat-e vagy web szerver.
Projekt végetview
Vessünk egy pillantást a projekt működésére.Az ESP32 vagy ESP8266 a web szerver, amely lehetővé teszi a kimenet állapotának szabályozását;

• Az aktuális kimeneti állapot megjelenik a web szerver;
• Az ESP egy fizikai nyomógombhoz is kapcsolódik, amely ugyanazt a kimenetet vezérli;
• Ha megváltoztatja a kimeneti állapotot a fizikai puhsgombbal, az aktuális állapota is frissül a web szerver.

Összefoglalva, ez a projekt lehetővé teszi, hogy ugyanazt a kimenetet vezérelje a web szerver és egy nyomógomb egyszerre. Amikor a kimeneti állapot megváltozik, a web a szerver frissül.
Szükséges alkatrészek
Íme az áramkör felépítéséhez szükséges alkatrészek listája:

• ESP32 DEVKIT V1 tábla
• 5 mm-es LED
• 220 ohmos ellenállás
• Nyomógomb
• 10k Ohm ellenállás
• Kenyértábla
• Jumper vezetékek

VázlatosAz ESP32 könyvtárának telepítése
Ezt megépíteni web szerver, az ESPAsync-et használjukWebSzerverkönyvtár és AsyncTCP könyvtár. (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESPAsync telepítéseWebSzerver könyvtár
Kövesse a következő lépéseket az ESPAsync telepítéséhezWebSzerver könyvtár:

1. Kattintson ide az ESPAsync letöltéséhezWebSzerver könyvtár. kellett volna
   egy .zip mappát a Letöltések mappában
2. Csomagolja ki a .zip mappát, és meg kell szereznie az ESPAsync-etWebServer-master mappa
3. Nevezze át a mappát az ESPAsync alkalmazásbólWebServer-master az ESPAsynchezWebSzerver
4. Helyezze át az ESPAsync-etWebA szerver mappát az Arduino IDE telepítési könyvtárak mappájába
   Alternatív megoldásként az Arduino IDE-ben lépjen a Sketch > Include menüpontra
   Könyvtár > .ZIP-könyvtár hozzáadása…, és válassza ki az éppen letöltött könyvtárat.

Az ESP32 AsyncTCP könyvtárának telepítése
Az ESPAsyncWebA szerverkönyvtár működéséhez az AsyncTCP könyvtár szükséges. Kövesse a következő lépéseket a könyvtár telepítéséhez:

1. Kattintson ide az AsyncTCP könyvtár letöltéséhez. A Letöltések mappában kell lennie egy .zip mappának
2. Csomagolja ki a .zip mappát, és megkapja az AsyncTCP-master mappát
3. Nevezze át a mappát AsyncTCP-masterről AsyncTCP-re
4. Helyezze át az AsyncTCP mappát az Arduino IDE telepítési könyvtárak mappájába
5. Végül nyissa meg újra az Arduino IDE-t
   Alternatív megoldásként az Arduino IDE-ben lépjen a Sketch > Include menüpontra
   Könyvtár > .ZIP-könyvtár hozzáadása…, és válassza ki az éppen letöltött könyvtárat.

Kód
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy telepítve van az ESP32 kiegészítő: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-ben
A szükséges könyvtárak telepítése után nyissa meg a kódot
Project_8_Output_State_State_Synchronization_Web_Server.ino az arduino IDE-ben.
A kód feltöltése előtt ne felejtse el beírni a hálózati hitelesítő adatait, hogy az ESP csatlakozhasson a helyi hálózathoz.

Hogyan működik a kód

Gomb állapota és kimeneti állapota
A ledState változó tartja a LED kimeneti állapotát. Alapértelmezés szerint, amikor a web A szerver elindul, LOW.

A buttonState és lastButtonState segítségével megállapítható, hogy a nyomógombot megnyomták-e vagy sem.gomb (web szerver)
Nem adtuk meg a HTML-t a gomb létrehozásához az index_html változóban.
Ez azért van így, mert azt szeretnénk, hogy a LED aktuális állapotától függően változtathassuk, amit a nyomógombbal is lehet változtatni.
Létrehoztunk tehát egy helyőrzőt a %BUTTONPLACEHOLDER% gombhoz, amelyet HTML-szövegre cserélünk, hogy később létrehozzuk a gombot a kódban (ez a processor() függvényben történik).processzor()
A processor() függvény a HTML-szöveg helyőrzőit tényleges értékekkel helyettesíti. Először is ellenőrzi, hogy a HTML-szövegekben van-e ilyen
helyőrzők %BUTTONPLACEHOLDER%.Ezután hívja meg az outputState() függvényt, amely visszaadja az aktuális kimeneti állapotot. Mentjük az outputStateValue változóba.Ezt követően használja ezt az értéket a HTML-szöveg létrehozásához, hogy a megfelelő állapotú gomb jelenjen meg:HTTP GET kérés a kimeneti állapot megváltoztatására (JavaScript)
A gomb megnyomásakor a toggleCheckbox() függvény meghívódik. Ez a funkció kérést küld különböző URLs a LED be- vagy kikapcsolásához.A LED bekapcsolásához kérést küld az /update?state=1 oldalon URL:Ellenkező esetben kérést küld az /update?state=0 oldalon URL.
HTTP GET kérés frissítési állapothoz (JavaScript)
A kimeneti állapot frissítéséhez a web szerver, a következő függvényt hívjuk meg, amely új kérést küld a /state-on URL minden másodpercben.Kezelje a kéréseket
Ezután kezelnünk kell, mi történik, ha az ESP32 vagy ESP8266 kéréseket kap ezekről URLs.
Amikor egy kérés érkezik a gyökérbe /URL, küldjük a HTML oldalt, valamint a processzort.A következő sorok ellenőrzik, hogy az /update?state=1 vagy /update?state=0 címen kapott-e kérést URL és ennek megfelelően módosítja a ledState értéket.Amikor egy kérés érkezik a /state URL, elküldjük az aktuális kimeneti állapotot:hurok()
A loop()-ban visszaütjük a nyomógombot, és a LED-et be- vagy kikapcsoljuk a ledState értékétől függően változó.Demonstráció
Töltse fel a kódot az ESP32 kártyára. Töltse fel a kód hivatkozási lépéseit.
Ezután nyissa meg a Serial Monitort 115200 adatátviteli sebességgel. Nyomja meg a fedélzeti EN/RST gombot az IP-cím megszerzéséhez.Nyisson meg egy böngészőt a helyi hálózaton, és írja be az ESP IP-címét. Hozzá kell férnie a web szervert az alábbiak szerint.
Jegyzet: A böngészőnek és az ESP32-nek ugyanahhoz a LAN-hoz kell csatlakoznia.A gombot átkapcsolhatja a web szervert a LED bekapcsolásához.Ugyanezt a LED-et a fizikai nyomógombbal is vezérelheti. Állapota mindig automatikusan frissül a web szerver.

9. projekt ESP32 DHT11 Web Szerver

Ebben a projektben megtudhatja, hogyan kell aszinkron ESP32-t felépíteni web szerver a DHT11-gyel, amely az Arduino IDE segítségével megjeleníti a hőmérsékletet és a páratartalmat.
Előfeltételek
A web szerver automatikusan frissíti a leolvasásokat anélkül, hogy frissíteni kellene a web oldalon.
Ezzel a projekttel megtudhatja:

• Hogyan lehet leolvasni a hőmérsékletet és a páratartalmat a DHT-érzékelőkről;
• Építsen egy aszinkront web szerver segítségével ESPAsyncWebSzerver könyvtár;
• Frissítse az érzékelő leolvasásait automatikusan anélkül, hogy frissítenie kellene web oldalon.

Aszinkron Web Szerver
Építeni a web szervert fogjuk használni ESPAsyncWebSzerver könyvtár amely egyszerű módot biztosít egy aszinkron létrehozására web szerver. Aszinkron építése web szervernek több advantaga könyvtár GitHub oldalán említett módon, például:

• „Egynél több kapcsolat kezelése egyszerre”;
• „A válasz elküldésekor azonnal készen áll a többi kapcsolat kezelésére, miközben a szerver a háttérben gondoskodik a válasz elküldéséről”;
• „Egyszerű sablonfeldolgozó motor a sablonok kezelésére”;

Szükséges alkatrészek
Az oktatóanyag befejezéséhez a következő részekre lesz szüksége:

• ESP32 fejlesztő kártya
• DHT11 modul
• Kenyértábla
• Jumper vezetékek

VázlatosKönyvtárak telepítése
Ehhez a projekthez telepítenie kell néhány könyvtárat:

• A DHT és a Adafruit Unified Sensor Illesztőprogram-könyvtárak a DHT-érzékelőből való olvasáshoz.
• ESPAsyncWebSzerver és Aszinkron TCP könyvtárak az aszinkron felépítéséhez web szerver.
  Kövesse a következő utasításokat a könyvtárak telepítéséhez:

A DHT Sensor Library telepítése
Ha az Arduino IDE használatával szeretne olvasni a DHT-érzékelőből, telepítenie kell a DHT érzékelő könyvtár. Kövesse a következő lépéseket a könyvtár telepítéséhez.

1. Kattintson ide a DHT érzékelő könyvtár letöltéséhez. A Letöltések mappában kell lennie egy .zip mappának
2. Csomagolja ki a .zip mappát, és megkapja a DHT-sensor-library-master mappát
3. Nevezze át mappáját DHT-sensor-library-master-ről DHT_sensor-ra
4. Helyezze át a DHT_sensor mappát az Arduino IDE telepítési könyvtárak mappájába
5. Végül nyissa meg újra az Arduino IDE-t

Az Adafruit Unified Sensor Driver telepítése
Ezenkívül telepítenie kell a Adafruit Unified Sensor Driver könyvtár a DHT érzékelővel való együttműködéshez. Kövesse a következő lépéseket a könyvtár telepítéséhez.

1. Kattintson ide az Adafruit Unified Sensor könyvtárának letöltéséhez. A Letöltések mappában kell lennie egy .zip mappának
2. Csomagolja ki a .zip mappát, és megkapja az Adafruit_sensor-master mappát
3. Nevezze át mappáját Adafruit_sensor-master névről Adafruit_sensor névre
4. Helyezze át az Adafruit_sensor mappát az Arduino IDE telepítési könyvtárak mappájába
5. Végül nyissa meg újra az Arduino IDE-t

Az ESPAsync telepítéseWebSzerver könyvtár

Kövesse a következő lépéseket a telepítéshez ESPAsyncWebSzerver könyvtár:

1. Kattintson ide az ESPAsync letöltéséhezWebSzerver könyvtár. kellett volna
   egy .zip mappát a Letöltések mappában
2. Csomagolja ki a .zip mappát, és meg kell tennie
   szerezd be az ESPAsync-etWebServer-master mappa
3. Nevezze át a mappát az ESPAsync alkalmazásbólWebServer-master az ESPAsynchezWebSzerver
4. Helyezze át az ESPAsync-etWebA szerver mappát az Arduino IDE telepítési könyvtárak mappájába

Az ESP32 Async TCP Library telepítése
A ESPAsyncWebSzerver könyvtár igényli a AsyncTCP könyvtár dolgozni. Kövesse a következő lépéseket a könyvtár telepítéséhez:

1. Kattintson ide az AsyncTCP könyvtár letöltéséhez. A Letöltések mappában kell lennie egy .zip mappának
2. Csomagolja ki a .zip mappát, és megkapja az AsyncTCP-master mappát
3. Nevezze át a mappát AsyncTCP-masterről AsyncTCP-re
4. Helyezze át az AsyncTCP mappát az Arduino IDE telepítési könyvtárak mappájába
5. Végül nyissa meg újra az Arduino IDE-t

Kód
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy telepítve van az ESP32 kiegészítő: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-ben
A szükséges könyvtárak telepítése után nyissa meg a kódot
Project_9_ESP32_DHT11_Web_Server.ino az arduino IDE-ben.
A kód feltöltése előtt ne felejtse el beírni a hálózati hitelesítő adatait, hogy az ESP csatlakozhasson a helyi hálózathoz.Hogyan működik a kód
A következő bekezdésekben elmagyarázzuk, hogyan működik a kód. Folytassa az olvasást, ha többet szeretne megtudni, vagy ugorjon a Bemutató részre a végeredmény megtekintéséhez.
Könyvtárak importálása
Először importálja a szükséges könyvtárakat. A WiFi, ESPAsyncWebSzerverre és ESPAsyncTCP-re van szükség a létrehozásához web szerver. Az Adafruit_Sensor és a DHT könyvtárak szükségesek a DHT11 vagy DHT22 érzékelők olvasásához.A változók meghatározása
Határozza meg azt a GPIO-t, amelyhez a DHT adattű csatlakozik. Ebben az esetben a GPIO 4-hez csatlakozik.Ezután válassza ki a használt DHT-érzékelő típusát. Az exünkbenample, a DHT22-t használjuk. Ha más típust használ, csak törölnie kell az érzékelő megjegyzését, és megjegyzést kell fűznie az összes többihez.

Példányosítson egy DHT-objektumot a korábban definiált típussal és tűvel.Hozzon létre egy aszinkrontWebSzerverobjektum a 80-as porton.Olvassa el a hőmérséklet- és páratartalom-funkciókat
Két funkciót hoztunk létre: az egyik a hőmérséklet olvasására Két funkciót hoztunk létre: az egyik a hőmérséklet (readDHTTemperature()), a másik pedig a páratartalom (readDHTHumidity()).Az érzékelők leolvasása olyan egyszerű, mint a használata Az érzékelők leolvasása olyan egyszerű, mint a readTemperature() és readHumidity() metódusok használata a dht objektumon.Van egy olyan feltételünk is, amely két kötőjelet (–) ad vissza arra az esetre, ha az érzékelő nem kapja meg a leolvasást.A leolvasások karakterlánc-típusként kerülnek visszaadásra. A float karakterláncsá alakításához használja a String() függvénytAlapértelmezés szerint a hőmérsékletet Celsius-fokban mérjük. Ha a hőmérsékletet Fahrenheit-fokban szeretné megkapni, írja be megjegyzésbe a hőmérsékletet Celsius-ban, és törölje a Fahrenheit-fokban, így a következőket kapja:Töltse fel a kódot
Most töltse fel a kódot az ESP32-re. Győződjön meg arról, hogy a megfelelő kártyát és COM-portot választotta ki.Töltse fel a kód hivatkozási lépéseit.
Feltöltés után nyissa meg a Serial Monitort 115200 adatátviteli sebességgel. Nyomja meg az ESP32 reset gombot. Az ESP32 IP-címet a sorozatba kell nyomtatni monitor.Demonstráció
Nyisson meg egy böngészőt, és írja be az ESP32 IP-címét. A te web a szervernek a legfrissebb szenzorértékeket kell megjelenítenie.
Jegyzet: A böngészőnek és az ESP32-nek ugyanahhoz a LAN-hoz kell csatlakoznia.
Figyelje meg, hogy a hőmérséklet- és páratartalom-értékek automatikusan frissülnek anélkül, hogy frissíteni kellene web oldalon.

Project_10_ESP32_OLED_Kijelző

Ez a projekt bemutatja, hogyan kell használni a 0.96 hüvelykes SSD1306 OLED kijelzőt ESP32-vel Arduino IDE használatával.
Bemutatjuk a 0.96 hüvelykes OLED kijelzőt
A OLED kijelző Ebben az oktatóanyagban az SSD1306 modellt fogjuk használni: egyszínű, 0.96 hüvelykes kijelző 128 × 64 képponttal, ahogy az a következő ábrán látható.Az OLED kijelző nem igényel háttérvilágítást, ami nagyon szép kontrasztot eredményez sötét környezetben. Ráadásul a pixelei csak bekapcsolt állapotban fogyasztanak energiát, így az OLED-kijelző kevesebb energiát fogyaszt, mint más kijelzők.
Mivel az OLED kijelző I2C kommunikációs protokollt használ, a vezetékezés nagyon egyszerű. Az alábbi táblázatot referenciaként használhatja.

OLED tű	ESP32
Vin	3.3V
GND	GND
SCL	GPIO 22
SDA	GPIO 21

VázlatosSSD1306 OLED Library telepítése – ESP32
Számos könyvtár áll rendelkezésre az OLED-kijelző vezérléséhez az ESP32-vel.
Ebben az oktatóanyagban két Adafruit könyvtárat fogunk használni: Adafruit_SSD1306 könyvtár és Adafruit_GFX könyvtár.
Kövesse a következő lépéseket a könyvtárak telepítéséhez.

1. Nyissa meg az Arduino IDE-t, és lépjen a Sketch > Include Library > Manage Libraries menüpontra. A Könyvtárkezelőnek meg kell nyílnia.
2. Írja be az „SSD1306” kifejezést a keresőmezőbe, és telepítse az SSD1306 könyvtárat az Adafruitból.
3. Miután telepítette az SSD1306 könyvtárat az Adafruitból, írja be a „GFX” kifejezést a keresőmezőbe, és telepítse a könyvtárat.
4. A könyvtárak telepítése után indítsa újra az Arduino IDE-t.

Kód
A szükséges könyvtárak telepítése után nyissa meg a Project_10_ESP32_OLED_Display.ino fájlt az arduino IDE-ben. kód
Az ESP32-t Arduino IDE segítségével programozzuk, ezért a folytatás előtt győződjön meg arról, hogy az ESP32 kiegészítő telepítve van: (Ha már megtette ezt a lépést, ugorhat a következő lépésre.)
Az ESP32 bővítmény telepítése az Arduino IDE-benHogyan működik a kód
Könyvtárak importálása
Először is importálnia kell a szükséges könyvtárakat. A Wire könyvtár az I2C használatához és az Adafruit könyvtárak a kijelzőre való íráshoz: Adafruit_GFX és Adafruit_SSD1306.Inicializálja az OLED kijelzőt
Ezután határozza meg az OLED szélességét és magasságát. Ebben az examp128×64-es OLED kijelzőt használunk. Ha más méretet használ, ezt a SCREEN_WIDTH és SCREEN_HEIGHT változókban módosíthatja.Ezután inicializáljon egy megjelenítési objektumot az I2C kommunikációs protokollal (&Wire) korábban meghatározott szélességgel és magassággal.A (-1) paraméter azt jelenti, hogy az OLED-kijelzőn nincs RESET tű. Ha az OLED-kijelzőnek van RESET tűje, akkor azt egy GPIO-hoz kell csatlakoztatni. Ebben az esetben paraméterként adja meg a GPIO-számot.
A setup()-ban hibakeresés céljából inicializálja a soros monitort 115200 baud raute értékkel.Inicializálja az OLED-kijelzőt a begin() metódussal az alábbiak szerint:Ez a részlet a soros monitoron is kiír egy üzenetet arra az esetre, ha nem tudnánk csatlakozni a kijelzőhöz.

Ha másik OLED-kijelzőt használ, előfordulhat, hogy módosítania kell az OLED-címet. Esetünkben a cím 0x3C.A kijelző inicializálása után adjon hozzá két másodperces késleltetést, hogy az OLED-nek elegendő ideje legyen inicializálni, mielőtt szöveget írna:Tiszta kijelző, betűméret, szín és szöveg írása
A kijelző inicializálása után törölje a puffert a clearDisplay() metódussal:

Szöveg írása előtt be kell állítania a szöveg méretét, színét és azt, hogy a szöveg hol jelenjen meg az OLED-en.
Állítsa be a betűméretet a setTextSize() metódussal:Állítsa be a betűszínt a setTextColor() metódussal:
A WHITE fehér betűtípust és fekete hátteret állít be.
Határozza meg a szöveg kezdőpontját a setCursor(x,y) metódussal. Ebben az esetben a szöveget úgy állítjuk be, hogy a (0,0) koordinátákkal kezdődjön – a bal felső sarokban.Végül a szöveget a println() metódussal a kijelzőre küldhetjük, az alábbiak szerintEzután meg kell hívnia a display() metódust, hogy ténylegesen megjelenítse a szöveget a képernyőn.

Az Adafruit OLED könyvtár hasznos módszereket kínál a szöveg egyszerű görgetéséhez.

• startscrollright(0x00, 0x0F): a szöveg görgetése balról jobbra
• startscrollleft(0x00, 0x0F): a szöveg görgetése jobbról balra
• startscrolldiagright(0x00, 0x07): szöveg görgetése a bal alsó sarokból a jobb felső sarokba startscrolldiagleft(0x00, 0x07): a szöveg görgetése a jobb alsó sarokból a bal felső sarokba

Töltse fel a kódot
Most töltse fel a kódot az ESP32-be. A kód feltöltésének lépései.
A kód feltöltése után az OLED görgető szöveget jelenít meg.

Dokumentumok / Források

LAFVIN ESP32 alap kezdőkészlet [pdf] Használati utasítás ESP32 Basic Starter Kit, ESP32, Basic Starter Kit, Starter Kit

Hivatkozások

• Felhasználói kézikönyv