Starter de bază ESP32
Kit

Lista de ambalare

ESP32 Introducere

Nou la ESP32? Începeți de aici! ESP32 este o serie de microcontrolere System on a Chip (SoC) cu costuri reduse și cu consum redus, dezvoltate de Espressif, care includ capabilități wireless Wi-Fi și Bluetooth și procesor dual-core. Dacă sunteți familiarizat cu ESP8266, ESP32 este succesorul său, încărcat cu o mulțime de funcții noi.Specificații ESP32
Dacă doriți să obțineți ceva mai tehnic și mai specific, puteți arunca o privire la următoarele specificații detaliate ale ESP32 (sursa: http://esp32.net/)—pentru mai multe detalii, verifica fisa de date):

• Conectivitate wireless WiFi: Rată de date de 150.0 Mbps cu HT40
• Bluetooth: BLE (Bluetooth Low Energy) și Bluetooth Classic
• Procesor: microprocesor Tensilica Xtensa Dual-Core LX32 pe 6 de biți, care rulează la 160 sau 240 MHz
• Memorie:
• ROM: 448 KB (pentru pornire și funcții de bază)
• SRAM: 520 KB (pentru date și instrucțiuni)
• RTC fa SRAM: 8 KB (pentru stocarea datelor și CPU principal în timpul RTC Boot din modul deep-sleep)
• SRAM lentă RTC: 8KB (pentru accesarea coprocesorului în timpul modului de repaus profund) eFuse: 1 Kbit (din care 256 de biți sunt utilizați pentru sistem (adresa MAC și configurația chip) iar restul de 768 de biți sunt rezervați pentru aplicațiile clienților, inclusiv Criptare Flash și ID-ul cip)

Bliț încorporat: bliț conectat intern prin IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 și SD_DATA_1 pe ESP32-D2WD și ESP32-PICO-D4.

• 0 MiB (cipuri ESP32-D0WDQ6, ESP32-D0WD și ESP32-S0WD)
• 2 MiB (cip ESP32-D2WD)
• 4 MiB (modul ESP32-PICO-D4 SiP)

Putere scăzută: vă asigură că puteți utiliza în continuare conversii ADC, de example, în timpul somnului adânc.
Intrare/ieșire periferică:

• interfață periferică cu DMA care include atingere capacitivă
• ADC (convertor analog-digital)
• DAC (convertor digital-analogic)
• I²C (circuit inter-integrat)
• UART (receptor/transmițător universal asincron)
• SPI (Interfață periferică serială)
• I²S (sunet integrat între cipuri)
• RMII (Interfață independentă de media redusă)
• PWM (modulație pe lățime a impulsului)

Securitate: acceleratoare hardware pentru AES și SSL/TLS

Plăci de dezvoltare ESP32

ESP32 se referă la cipul ESP32 gol. Cu toate acestea, termenul „ESP32” este folosit și pentru a se referi la plăcile de dezvoltare ESP32. Utilizarea cipurilor goale ESP32 nu este ușoară sau practică, mai ales atunci când învățați, testați și prototipați. De cele mai multe ori, veți dori să utilizați o placă de dezvoltare ESP32.
Vom folosi ca referință placa ESP32 DEVKIT V1. Imaginea de mai jos arată placa ESP32 DEVKIT V1, versiunea cu 30 de pini GPIO.Specificații – ESP32 DEVKIT V1
Următorul tabel prezintă un rezumat al caracteristicilor și specificațiilor plăcii ESP32 DEVKIT V1 DOIT:

Numărul de nuclee	2 (dual core)
Wifi	2.4 GHz până la 150 Mbit/s
Bluetooth	BLE (Bluetooth Low Energy) și Bluetooth vechi
Arhitectură	32 biți
Frecvența ceasului	Până la 240 MHz
RAM	512 KB
Ace	30 (în funcție de model)

Periferice	Atingere capacitivă, ADC (convertor analog-digital), DAC (convertor digital-analogic), 12C (Circuit inter-integrat), UART (receptor/transmițător universal asincron), CAN 2.0 (Controller Area Network), SPI (Interfață periferică serială) , 12S (Inter-IC integrat Sunet), RMII (Interfață independentă de media redusă), PWM (modularea lățimii pulsului) și multe altele.
Butoane încorporate	Butoanele RESET și BOOT
LED-uri încorporate	LED albastru încorporat conectat la GPIO2; LED roșu încorporat care arată că placa este alimentată
USB la UART pod	CP2102

Vine cu o interfață microUSB pe care o puteți folosi pentru a conecta placa la computer pentru a încărca codul sau a aplica energie.
Utilizează cipul CP2102 (USB la UART) pentru a comunica cu computerul printr-un port COM folosind o interfață serială. Un alt cip popular este CH340. Verificați care este convertorul de cip USB la UART pe placa dvs., deoarece va trebui să instalați driverele necesare, astfel încât computerul să poată comunica cu placa (mai multe informații despre aceasta mai târziu în acest ghid).
Această placă vine, de asemenea, cu un buton RESET (poate fi etichetat EN) pentru a reporni placa și un buton BOOT pentru a pune placa în modul intermitent (disponibil pentru a primi cod). Rețineți că este posibil ca unele plăci să nu aibă un buton BOOT.
De asemenea, vine cu un LED albastru încorporat care este conectat intern la GPIO 2. Acest LED este util pentru depanare pentru a oferi un fel de ieșire fizică vizuală. Există, de asemenea, un LED roșu care se aprinde atunci când furnizați energie plăcii.Pinout ESP32
Perifericele ESP32 includ:

• 18 canale de convertizor analog-digital (ADC).
• 3 interfețe SPI
• 3 interfețe UART
• 2 interfețe I2C
• 16 canale de ieșire PWM
• 2 convertoare digital-analogice (DAC)
• 2 interfețe I2S
• 10 GPIO cu detecție capacitivă

Caracteristicile ADC (convertor analog-digital) și DAC (convertor digital-analogic) sunt alocate unor pini statici specifici. Cu toate acestea, puteți decide ce pini sunt UART, I2C, SPI, PWM etc. - trebuie doar să le atribuiți în cod. Acest lucru este posibil datorită caracteristicii de multiplexare a cipului ESP32.
Deși puteți defini proprietățile pinii pe software, există pini alocați implicit, așa cum se arată în figura următoareÎn plus, există știfturi cu caracteristici specifice care îi fac potriviti sau nu pentru un anumit proiect. Următorul tabel arată ce pini sunt cei mai buni de utilizat ca intrări, ieșiri și care trebuie să fiți precaut.
Pinurile evidențiate în verde sunt OK de utilizat. Cele evidențiate cu galben sunt OK de folosit, dar trebuie să fiți atenți deoarece pot avea un comportament neașteptat mai ales la boot. Pinii evidențiați cu roșu nu sunt recomandate pentru utilizare ca intrări sau ieșiri.

GP IO	Intrare	Ieșire	Note
0	tras în sus	OK	emite semnal PWM la pornire, trebuie să fie LOW pentru a intra în modul intermitent
1	pin TX	OK	ieșire de depanare la pornire
2	OK	OK	conectat la LED-ul de bord, trebuie lăsat să plutească sau LOW pentru a intra în modul intermitent
3	OK	Pin RX	HIGH la cizmă
4	OK	OK
5	OK	OK	scoate semnal PWM la pornire, pin de fixare
12	OK	OK	cizma eșuează dacă este trasă sus, știftul de curele
13	OK	OK
14	OK	OK	scoate semnal PWM la pornire
15	OK	OK	scoate semnal PWM la pornire, pin de fixare

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		numai intrare
35	OK		numai intrare
36	OK		numai intrare
39	OK		numai intrare

Continuați să citiți pentru o analiză mai detaliată și aprofundată a GPIO-urilor ESP32 și a funcțiilor sale.
Introduceți doar pini
GPIO-urile de la 34 la 39 sunt GPI-uri – introduceți doar pini. Acești pini nu au rezistențe interne de tragere sau tragere în jos. Ele nu pot fi folosite ca ieșiri, așa că utilizați acești pini doar ca intrări:

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

Bliț SPI integrat pe ESP-WROOM-32
GPIO 6 până la GPIO 11 sunt expuse în unele plăci de dezvoltare ESP32. Cu toate acestea, acești pini sunt conectați la blițul SPI integrat pe cipul ESP-WROOM-32 și nu sunt recomandați pentru alte utilizări. Deci, nu utilizați acești pini în proiectele dvs.:

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

GPIO-uri tactile capacitive
ESP32 are 10 senzori tactili capacitivi interni. Acestea pot simți variații în orice care deține o sarcină electrică, cum ar fi pielea umană. Astfel, ei pot detecta variațiile induse atunci când ating GPIO-urile cu degetul. Acești pini pot fi integrati cu ușurință în plăcuțele capacitive și înlocuiesc butoanele mecanice. Pinii tactili capacitivi pot fi folosiți și pentru a trezi ESP32 din somn profund. Acei senzori tactili interni sunt conectați la aceste GPIO-uri:

• 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)

Convertor analog-digital (ADC)
ESP32 are canale de intrare ADC de 18 x 12 biți (în timp ce ESP8266 are doar 1 ADC de 10 biți). Acestea sunt GPIO-urile care pot fi utilizate ca ADC și canalele respective:

• 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)

Nota: Pinii ADC2 nu pot fi utilizați când este utilizat Wi-Fi. Deci, dacă utilizați Wi-Fi și întâmpinați probleme la obținerea valorii de la un GPIO ADC2, puteți lua în considerare utilizarea unui GPIO ADC1. Asta ar trebui să-ți rezolve problema.
Canalele de intrare ADC au o rezoluție de 12 biți. Aceasta înseamnă că puteți obține citiri analogice de la 0 la 4095, în care 0 corespunde la 0V și 4095 la 3.3V. De asemenea, puteți seta rezoluția canalelor dvs. pe cod și gama ADC.
Pinii ADC ESP32 nu au un comportament liniar. Probabil că nu veți putea distinge între 0 și 0.1 V sau între 3.2 și 3.3 V. Trebuie să țineți cont de acest lucru atunci când utilizați pinii ADC. Veți obține un comportament similar cu cel prezentat în figura următoare.Convertor digital în analog (DAC)
Există 2 canale DAC pe 8 biți pe ESP32 pentru a converti semnalele digitale în volum analogictagieșiri de semnal. Acestea sunt canalele DAC:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

RTC GPIO
Există suport RTC GPIO pe ESP32. GPIO-urile direcționate către subsistemul RTC de consum redus pot fi utilizate atunci când ESP32 este în stare de repaus profund. Aceste GPIO-uri RTC pot fi folosite pentru a trezi ESP32 din somn profund atunci când este Ultra Low
Coprocesorul de alimentare (ULP) rulează. Următoarele GPIO-uri pot fi utilizate ca sursă de trezire externă.

• 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
Controlerul ESP32 LED PWM are 16 canale independente care pot fi configurate pentru a genera semnale PWM cu proprietăți diferite. Toți pinii care pot acționa ca ieșiri pot fi utilizați ca pini PWM (GPIO-urile 34 până la 39 nu pot genera PWM).
Pentru a seta un semnal PWM, trebuie să definiți acești parametri în cod:

• Frecvența semnalului;
• Ciclu de funcționare;
• canal PWM;
• GPIO unde doriți să scoateți semnalul.

I2C
ESP32 are două canale I2C și orice pin poate fi setat ca SDA sau SCL. Când utilizați ESP32 cu Arduino IDE, pinii I2C impliciti sunt:

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

Dacă doriți să utilizați alți pini atunci când utilizați biblioteca de fire, trebuie doar să sunați:
Wire.begin(SDA, SCL);
SPI
În mod implicit, maparea pinului pentru SPI este:

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

Întrerupe
Toate GPIO-urile pot fi configurate ca întreruperi.
Ace de curele
Cipul ESP32 are următorii pini de fixare:

• GPIO 0 (trebuie să fie LOW pentru a intra în modul de pornire)
• GPIO 2 (trebuie să fie plutitor sau LOW în timpul pornirii)
• GPIO 4
• GPIO 5 (trebuie să fie HIGH în timpul pornirii)
• GPIO 12 (trebuie să fie LOW în timpul pornirii)
• GPIO 15 (trebuie să fie HIGH în timpul pornirii)

Acestea sunt folosite pentru a pune ESP32 în modul bootloader sau intermitent. Pe majoritatea plăcilor de dezvoltare cu USB/Serial încorporat, nu trebuie să vă faceți griji cu privire la starea acestor pini. Placa pune pinii în starea potrivită pentru modul intermitent sau de pornire. Mai multe informații despre selecția modului de pornire ESP32 pot fi găsite aici.
Cu toate acestea, dacă aveți periferice conectate la acești pini, este posibil să aveți probleme la încercarea de a încărca un cod nou, de a flashiza ESP32 cu un firmware nou sau de a reseta placa. Dacă aveți unele periferice conectate la pinii de prindere și aveți probleme la încărcarea codului sau la intermiterea ESP32, este posibil să fie din cauza că acele periferice împiedică ESP32 să intre în modul corect. Citiți documentația de selecție a modului de pornire pentru a vă ghida în direcția corectă. După resetare, clipire sau pornire, acești pini funcționează conform așteptărilor.
Pins HIGH la Boot
Unele GPIO-uri își schimbă starea în HIGH sau scot semnale PWM la pornire sau la resetare.
Aceasta înseamnă că, dacă aveți ieșiri conectate la aceste GPIO, este posibil să obțineți rezultate neașteptate atunci când ESP32 se resetează sau pornește.

• GPIO 1
• GPIO 3
• GPIO 5
• GPIO 6 la GPIO 11 (conectat la memoria flash SPI integrată ESP32 – nu se recomandă utilizarea).
• GPIO 14
• GPIO 15

Activați (EN)
Enable (EN) este pinul de activare al regulatorului de 3.3 V. Este tras în sus, așa că conectați-vă la masă pentru a dezactiva regulatorul de 3.3 V. Aceasta înseamnă că puteți folosi acest pin conectat la un buton pentru a reporni ESP32, de example.
GPIO consumat de curent
Curentul maxim absolut absorbit per GPIO este de 40 mA conform secțiunii „Condiții de operare recomandate” din fișa de date ESP32.
Senzor cu efect Hall încorporat ESP32
ESP32 are, de asemenea, un senzor cu efect Hall încorporat care detectează modificările câmpului magnetic din împrejurimile sale
ESP32 Arduino IDE
Există un add-on pentru Arduino IDE care vă permite să programați ESP32 folosind Arduino IDE și limbajul său de programare. În acest tutorial vă vom arăta cum să instalați placa ESP32 în Arduino IDE, indiferent dacă utilizați Windows, Mac OS X sau Linux.
Cerințe preliminare: Arduino IDE instalat
Înainte de a începe această procedură de instalare, trebuie să aveți Arduino IDE instalat pe computer. Există două versiuni ale IDE-ului Arduino pe care le puteți instala: versiunea 1 și versiunea 2.
Puteți descărca și instala Arduino IDE făcând clic pe următorul link: arduino.cc/en/Main/Software
Ce versiune Arduino IDE recomandăm? Momentan, sunt unele plugins pentru ESP32 (cum ar fi SPIFFS FileSystem Uploader Plugin) care nu sunt încă acceptate pe Arduino 2. Deci, dacă intenționați să utilizați pluginul SPIFFS în viitor, vă recomandăm să instalați versiunea moștenită 1.8.X. Trebuie doar să derulați în jos pe pagina software-ului Arduino pentru a-l găsi.
Instalarea suplimentului ESP32 în Arduino IDE
Pentru a instala placa ESP32 în IDE-ul dvs. Arduino, urmați următoarele instrucțiuni:

1. În IDE-ul tău Arduino, accesează File> Preferințe
2. Introduceți următoarele în „Manager de consiliu suplimentar URLcâmpul s”:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Apoi, faceți clic pe butonul „OK”:Nota: dacă aveți deja plăcile ESP8266 URL, puteți separa URLs cu virgulă, după cum urmează:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Deschideți Managerul Boards. Accesați Instrumente > Board > Manager Boards...Caută ESP32 and press install button for the “ESP32 by Espressif Systems“:Asta este. Ar trebui instalat după câteva secunde.

Încărcați codul de testare

Conectați placa ESP32 la computer. Cu IDE-ul Arduino deschis, urmați acești pași:

1. Selectați-vă placa în meniul Instrumente > Placă (în cazul meu este modulul ESP32 DEV)
2. Selectați portul (dacă nu vedeți portul COM în IDE-ul dvs. Arduino, trebuie să instalați driverele CP210x USB la UART Bridge VCP):
3. Deschideți următorul example under File > Exampfișiere > WiFi
   (ESP32) > WiFiScan
4. Se deschide o nouă schiță în IDE-ul tău Arduino:
5. Apăsați butonul Încărcare din Arduino IDE. Așteptați câteva secunde în timp ce codul se compila și se încarcă pe placa dvs.
6. Dacă totul a decurs conform așteptărilor, ar trebui să vedeți „Încărcare finalizată”. mesaj.
7. Deschideți monitorul serial Arduino IDE la o viteză de transmisie de 115200:
8. Apăsați butonul de activare integrat al ESP32 și ar trebui să vedeți rețelele disponibile lângă ESP32:

Depanare

Dacă încercați să încărcați o nouă schiță pe ESP32 și primiți acest mesaj de eroare „A apărut o eroare fatală: Conectarea eșuată la ESP32: Timp expirat… Conectare…”. Înseamnă că ESP32 nu este în modul intermitent/încărcare.
Având numele corect al plăcii și porul COM selectat, urmați acești pași:
Țineți apăsat butonul „BOOT” de pe placa ESP32

• Apăsați butonul „Încărcați” din Arduino IDE pentru a vă încărca schița:
• După ce vedeți „Se conectează...”. mesaj în IDE-ul dvs. Arduino, eliberați degetul de pe butonul „BOOT”:
• După aceea, ar trebui să vedeți mesajul „Încărcare terminată”.
  Asta este. ESP32 ar trebui să aibă noua schiță în funcțiune. Apăsați butonul „ACTIVARE” pentru a reporni ESP32 și a rula noua schiță încărcată.
  De asemenea, va trebui să repetați acea secvență de butoane de fiecare dată când doriți să încărcați o nouă schiță.

Proiect 1 ESP32 Intrări Ieșiri

În acest ghid introductiv, veți învăța cum să citiți intrările digitale cum ar fi un buton și să controlați ieșirile digitale precum un LED folosind ESP32 cu Arduino IDE.
Cerințe preliminare
Vom programa ESP32 folosind Arduino IDE. Așadar, asigurați-vă că aveți instalat suplimentul pentru plăcile ESP32 înainte de a continua:

• Instalarea suplimentului ESP32 în Arduino IDE

ESP32 controlează ieșirile digitale
Mai întâi, trebuie să setați GPIO pe care doriți să-l controlați ca IEȘIRE. Utilizați funcția pinMode() după cum urmează:
pinMode(GPIO, OUTPUT);
Pentru a controla o ieșire digitală trebuie doar să utilizați funcția digitalWrite(), care acceptă ca argumente, GPIO (numărul int) la care vă referiți și starea, fie HIGH sau LOW.
digitalWrite(GPIO, STATE);
Toate GPIO-urile pot fi utilizate ca ieșiri, cu excepția GPIO-urilor 6 până la 11 (conectate la flash-ul SPI integrat) și GPIO-urile 34, 35, 36 și 39 (numai GPIO-urile de intrare);
Aflați mai multe despre ESP32 GPIO: ESP32 GPIO Reference Guide
ESP32 Citire intrări digitale
Mai întâi, setați GPIO pe care doriți să-l citiți ca INPUT, folosind funcția pinMode() după cum urmează:
pinMode(GPIO, INPUT);
Pentru a citi o intrare digitală, ca un buton, utilizați funcția digitalRead(), care acceptă ca argument, GPIO (numărul int) la care vă referiți.
digitalRead(GPIO);
Toate GPIO-urile ESP32 pot fi utilizate ca intrări, cu excepția GPIO-urilor 6 până la 11 (conectate la blițul SPI integrat).
Aflați mai multe despre ESP32 GPIO: ESP32 GPIO Reference Guide
Proiect Example
Pentru a vă arăta cum să utilizați intrările și ieșirile digitale, vom construi un proiect simplu de example cu un buton și un LED. Vom citi starea butonului și vom aprinde LED-ul în consecință, așa cum este ilustrat în figura următoare.

Piese necesare
Iată o listă cu părțile de care aveți nevoie pentru a construi circuitul:

• ESP32 DEVKIT V1
• LED de 5 mm
• Rezistor de 220 Ohm
• Apasa butonul
• Rezistor de 10k Ohm
• Breadboard
• Fire jumper

Diagrama schematică
Înainte de a continua, trebuie să asamblați un circuit cu un LED și un buton.
Vom conecta LED-ul la GPIO 5 și butonul de apăsare la GPIO 4.Cod
Deschideți codul Project_1_ESP32_Inputs_Outputs.ino în arduino IDECum funcționează codul
În următoarele două rânduri, creați variabile pentru a atribui pini:

Butonul este conectat la GPIO 4 și LED-ul este conectat la GPIO 5. Când utilizați Arduino IDE cu ESP32, 4 corespunde GPIO 4 și 5 corespunde GPIO 5.
Apoi, creați o variabilă pentru a menține starea butonului. În mod implicit, este 0 (nu este apăsat).
int buttonState = 0;
În setup(), inițializați butonul ca INTRARE și LED-ul ca IEȘIRE.
Pentru asta, utilizați funcția pinMode() care acceptă pinul la care vă referiți și modul: INPUT sau OUTPUT.
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
În bucla () este locul în care citiți starea butonului și setați LED-ul în consecință.
În rândul următor, citiți starea butonului și o salvați în variabila buttonState.
După cum am văzut anterior, utilizați funcția digitalRead().
buttonState = digitalRead(buttonPin);
Următoarea instrucțiune if, verifică dacă starea butonului este HIGH. Dacă este, pornește LED-ul folosind funcția digitalWrite() care acceptă ca argument ledPin și starea HIGH.
dacă (buttonState == HIGH)Dacă starea butonului nu este HIGH, stingeți LED-ul. Doar setați LOW ca al doilea argument în funcția digitalWrite().Încărcarea Codului
Înainte de a face clic pe butonul de încărcare, accesați Instrumente > Placă și selectați placa : DOIT ESP32 DEVKIT V1.
Accesați Instrumente > Port și selectați portul COM la care este conectat ESP32. Apoi, apăsați butonul de încărcare și așteptați mesajul „Încărcare terminată”.Notă: Dacă vedeți o mulțime de puncte (se conectează…__…__) în fereastra de depanare și mesajul „Eșuat la conectare la ESP32: Timp expirat în așteptarea antetului pachetului”, înseamnă că trebuie să apăsați butonul ESP32 ON-board BOOT butonul după puncte
începe să apară.Depanare

Demonstraţie

După ce ați încărcat codul, testați-vă circuitul. LED-ul ar trebui să se aprindă când apăsați butonul:Și opriți când îl eliberați:

Proiect 2 Intrări analogice ESP32

Acest proiect arată cum să citiți intrările analogice cu ESP32 folosind Arduino IDE.
Citirea analogică este utilă pentru a citi valorile de la rezistențe variabile, cum ar fi potențiometre sau senzori analogici.
Intrări analogice (ADC)
Citirea unei valori analogice cu ESP32 înseamnă că puteți măsura volum variabiltage niveluri între 0 V și 3.3 V.
VoltagE măsurată este apoi atribuită unei valori cuprinse între 0 și 4095, în care 0 V corespunde cu 0, iar 3.3 V corespunde cu 4095. Orice vol.tage între 0 V și 3.3 V i se va da valoarea corespunzătoare între ele.ADC este neliniar
În mod ideal, v-ați aștepta la un comportament liniar atunci când utilizați pinii ADC ESP32.
Totuși, asta nu se întâmplă. Ceea ce veți obține este un comportament așa cum se arată în următorul grafic:Acest comportament înseamnă că ESP32 nu poate distinge 3.3 V de 3.2 V.
Veți obține aceeași valoare pentru ambele voltages: 4095.
Același lucru se întâmplă și pentru volum foarte scăzuttagValorile e: pentru 0 V și 0.1 V veți obține aceeași valoare: 0. Trebuie să aveți în vedere acest lucru atunci când utilizați pinii ADC ESP32.
Funcția analogRead().
Citirea unei intrări analogice cu ESP32 folosind Arduino IDE este la fel de simplă ca și utilizarea funcției analogRead(). Acceptă ca argument, GPIO pe care doriți să-l citiți:
analogRead(GPIO);
Doar 15 sunt disponibile pe placa DEVKIT V1 (versiunea cu 30 GPIO).
Luați pinout-ul plăcii ESP32 și localizați pinii ADC. Acestea sunt evidențiate cu un chenar roșu în figura de mai jos.Acești pini de intrare analogic au o rezoluție de 12 biți. Aceasta înseamnă că atunci când citiți o intrare analogică, intervalul acesteia poate varia de la 0 la 4095.
Notă: Pinii ADC2 nu pot fi utilizați atunci când este utilizat Wi-Fi. Deci, dacă utilizați Wi-Fi și întâmpinați probleme în obținerea valorii de la un GPIO ADC2, puteți lua în considerare utilizarea unui GPIO ADC1, asta ar trebui să vă rezolve problema.
Pentru a vedea cum totul se leagă împreună, vom face un fost simpluample pentru a citi o valoare analogică de la un potențiometru.
Piese necesare
Pentru acest example, aveți nevoie de următoarele părți:

• Placă ESP32 DEVKIT V1
• Potențiometru
• Breadboard
• Fire jumper

Schematic
Conectați un potențiometru la ESP32. Pinul din mijloc al potențiometrului trebuie conectat la GPIO 4. Puteți utiliza următoarea diagramă schematică ca referință.Cod
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDE
Deschideți codul Project_2_ESP32_Inputs_Outputs.ino în arduino IDEAcest cod pur și simplu citește valorile de pe potențiometru și imprimă acele valori în monitorul serial.
În cod, începeți prin definirea GPIO la care este conectat potențiometrul. În acest example, GPIO 4.În setup(), inițializați o comunicare serială la o viteză de transmisie de 115200.În bucla(), utilizați funcția analogRead() pentru a citi intrarea analogică din potPin.La final, tipăriți valorile citite de la potențiometru în monitorul serial.Încărcați codul furnizat pe ESP32. Asigurați-vă că aveți placa potrivită și portul COM selectate în meniul Instrumente.
Testarea example
După încărcarea codului și apăsarea butonului de resetare ESP32, deschideți monitorul serial la o viteză de transmisie de 115200. Rotiți potențiometrul și vedeți cum se schimbă valorile.Valoarea maximă pe care o veți obține este 4095, iar valoarea minimă este 0.

Încheierea

În acest articol ați învățat cum să citiți intrările analogice folosind ESP32 cu Arduino IDE. În concluzie:

• Placa ESP32 DEVKIT V1 DOIT (versiunea cu 30 de pini) are 15 pini ADC pe care îi puteți folosi pentru a citi intrările analogice.
• Acești pini au o rezoluție de 12 biți, ceea ce înseamnă că puteți obține valori de la 0 la 4095.
• Pentru a citi o valoare în IDE-ul Arduino, utilizați pur și simplu funcția analogRead().
• Pinii ADC ESP32 nu au un comportament liniar. Probabil că nu veți putea distinge între 0 și 0.1 V sau între 3.2 și 3.3 V. Trebuie să țineți cont de acest lucru atunci când utilizați pinii ADC.

Project 3 ESP32 PWM (ieșire analogică)

În acest tutorial vă vom arăta cum să generați semnale PWM cu ESP32 folosind Arduino IDE. Ca un exampVom construi un circuit simplu care atenuează un LED folosind controlerul LED PWM al ESP32.Controler ESP32 LED PWM
ESP32 are un controler LED PWM cu 16 canale independente care pot fi configurate pentru a genera semnale PWM cu proprietăți diferite.
Iată pașii pe care va trebui să-i urmezi pentru a estompa un LED cu PWM folosind IDE-ul Arduino:

1. În primul rând, trebuie să alegeți un canal PWM. Există 16 canale de la 0 la 15.
2. Apoi, trebuie să setați frecvența semnalului PWM. Pentru un LED, o frecvență de 5000 Hz este bine de utilizat.
3. De asemenea, trebuie să setați rezoluția ciclului de lucru al semnalului: aveți rezoluții de la 1 la 16 biți. Vom folosi rezoluția de 8 biți, ceea ce înseamnă că puteți controla luminozitatea LED-ului folosind o valoare de la 0 la 255.
4.  Apoi, trebuie să specificați la ce GPIO sau GPIO-uri va apărea semnalul. Pentru asta vei folosi următoarea funcție:
   ledcAttachPin(GPIO, canal)
   Această funcție acceptă două argumente. Primul este GPIO care va scoate semnalul, iar al doilea este canalul care va genera semnalul.
5. În cele din urmă, pentru a controla luminozitatea LED-ului folosind PWM, utilizați următoarea funcție:

ledcWrite(canal, dutycycle)
Această funcție acceptă ca argumente canalul care generează semnalul PWM și ciclul de lucru.
Piese necesare
Pentru a urma acest tutorial aveți nevoie de aceste părți:

• Placă ESP32 DEVKIT V1
• LED de 5 mm
• Rezistor de 220 Ohm
•  Breadboard
• Fire jumper

Schematic
Conectați un LED la ESP32 ca în schema următoare. LED-ul ar trebui să fie conectat la GPIO 4.Nota: puteți folosi orice pin doriți, atâta timp cât poate acționa ca o ieșire. Toți pinii care pot acționa ca ieșiri pot fi utilizați ca pini PWM. Pentru mai multe informații despre ESP32 GPIO, citiți: ESP32 Pinout Reference: Ce pini GPIO ar trebui să utilizați?
Cod
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDE
Deschideți codul Project_3_ESP32_PWM.ino în arduino IDEÎncepeți prin a defini pinul de care este atașat LED-ul. În acest caz, LED-ul este atașat la GPIO 4.Apoi, setați proprietățile semnalului PWM. Definiți o frecvență de 5000 Hz, alegeți canalul 0 pentru a genera semnalul și setați o rezoluție de 8 biți. Puteți alege alte proprietăți, diferite de acestea, pentru a genera semnale PWM diferite.În setup(), trebuie să configurați LED PWM cu proprietățile pe care le-ați definit mai devreme folosind funcția ledcSetup() care acceptă ca argumente, ledChannel, frecvența și rezoluția, după cum urmează:Apoi, trebuie să alegeți GPIO de la care veți primi semnalul. Pentru asta utilizați funcția ledcAttachPin() care acceptă ca argumente GPIO de unde doriți să obțineți semnalul și canalul care generează semnalul. În acest example, vom primi semnalul în ledPin GPIO, care corespunde cu GPIO 4. Canalul care generează semnalul este ledChannel, care corespunde canalului 0.În buclă, veți varia ciclul de lucru între 0 și 255 pentru a crește luminozitatea LED-ului.Și apoi, între 255 și 0 pentru a reduce luminozitatea.Pentru a seta luminozitatea LED-ului, trebuie doar să utilizați funcția ledcWrite() care acceptă ca argumente canalul care generează semnalul și ciclul de lucru.Deoarece folosim rezoluția de 8 biți, ciclul de lucru va fi controlat folosind o valoare de la 0 la 255. Rețineți că în funcția ledcWrite() folosim canalul care generează semnalul și nu GPIO.

Testarea example

Încărcați codul pe ESP32. Asigurați-vă că ați selectat placa și portul COM potrivite. Uită-te la circuitul tău. Ar trebui să aveți un LED dimmer care crește și scade luminozitatea.

Senzor de mișcare PIR Project 4 ESP32

Acest proiect arată cum să detectați mișcarea cu ESP32 folosind un senzor de mișcare PIR. Soneria va suna o alarmă când este detectată mișcare și va opri alarma când nu este detectată nicio mișcare pentru un timp prestabilit (cum ar fi 4 secunde)
Cum funcționează senzorul de mișcare HC-SR501
.Principiul de funcționare al senzorului HC-SR501 se bazează pe modificarea radiației infraroșii asupra obiectului în mișcare. Pentru a fi detectat de senzorul HC-SR501, obiectul trebuie să îndeplinească două cerințe:

• Obiectul emite prin infraroșu.
• Obiectul se mișcă sau se scutură

Aşa:
Dacă un obiect emite raze infraroșii, dar nu se mișcă (de exemplu, o persoană stă nemișcată fără să se miște), acesta NU este detectat de senzor.
Dacă un obiect se mișcă, dar NU emite raze infraroșii (de exemplu, robot sau vehicul), acesta NU este detectat de senzor.
Prezentarea cronometrelor
În acest exampVom introduce și cronometre. Dorim ca LED-ul să rămână aprins pentru un număr predeterminat de secunde după ce este detectată mișcarea. În loc să folosim o funcție delay() care vă blochează codul și nu vă permite să faceți altceva pentru un număr determinat de secunde, ar trebui să folosim un cronometru.Funcția delay().
Ar trebui să fiți familiarizați cu funcția delay() deoarece este utilizată pe scară largă. Această funcție este destul de simplu de utilizat. Acceptă un singur număr int ca argument.
Acest număr reprezintă timpul în milisecunde pe care programul trebuie să aștepte până la trecerea la următoarea linie de cod.Când faceți întârziere (1000), programul dumneavoastră se oprește pe acea linie timp de 1 secundă.
delay() este o funcție de blocare. Funcțiile de blocare împiedică un program să facă orice altceva până când respectiva sarcină este finalizată. Dacă aveți nevoie de mai multe sarcini în același timp, nu puteți utiliza delay().
Pentru majoritatea proiectelor, ar trebui să evitați utilizarea întârzierilor și să utilizați în schimb cronometre.
Funcția millis().
Folosind o funcție numită millis() puteți returna numărul de milisecunde care au trecut de la începutul programului.De ce este utilă această funcție? Pentru că, folosind ceva matematică, puteți verifica cu ușurință cât timp a trecut fără a vă bloca codul.
Piese necesare
Pentru a urma acest tutorial aveți nevoie de următoarele părți

• Placă ESP32 DEVKIT V1
• Senzor de mișcare PIR (HC-SR501)
• Buzzer activ
• Fire jumper
• Breadboard

SchematicNota: Vol. de lucrutage de HC-SR501 este de 5V. Utilizați pinul Vin pentru a-l alimenta.
Cod
Înainte de a continua cu acest tutorial, ar trebui să aveți suplimentul ESP32 instalat în IDE-ul dvs. Arduino. Urmați unul dintre următoarele tutoriale pentru a instala ESP32 pe Arduino IDE, dacă nu ați făcut deja acest pas. (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDE
Deschideți codul Project_4_ESP32_PIR_Motion_Sensor.ino în arduino IDE.
Demonstraţie
Încărcați codul pe placa ESP32. Asigurați-vă că ați selectat placa și portul COM potrivite. Încărcați pașii de referință a codului.
Deschideți monitorul serial la o viteză de transmisie de 115200.Mișcă-ți mâna în fața senzorului PIR. Soneria ar trebui să pornească, iar mesajul este tipărit pe monitorul serial care spune „Mișcare detectată! Alarma sonerie”.
După 4 secunde, soneria ar trebui să se oprească.

Comutator Project 5 ESP32 Web Server

În acest proiect veți crea un autonom web server cu un ESP32 care controlează ieșirile (două LED-uri) folosind mediul de programare Arduino IDE. The web serverul este mobil responsive și poate fi accesat cu orice dispozitiv ca browser în rețeaua locală. Vă vom arăta cum să creați web server și cum funcționează codul pas cu pas.
Proiect încheiatview
Înainte de a merge direct la proiect, este important să subliniem ceea ce avem web server va face, astfel încât să fie mai ușor să urmați pașii mai târziu.

• The web server veți construi comenzi două LED-uri conectate la ESP32 GPIO 26 și GPIO 27;
• Puteți accesa ESP32 web server prin tastarea adresei IP ESP32 pe un browser din rețeaua locală;
• Făcând clic pe butoanele de pe dvs web server puteți schimba instantaneu starea fiecărui LED.

Piese necesare
Pentru acest tutorial veți avea nevoie de următoarele părți:

• Placă ESP32 DEVKIT V1
• 2x LED de 5 mm
• 2x rezistor de 200 Ohm
• Breadboard
• Fire jumper

Schematic
Începeți prin a construi circuitul. Conectați două LED-uri la ESP32, așa cum se arată în următoarea diagramă schematică - un LED conectat la GPIO 26, iar celălalt la GPIO 27.
Nota: Folosim placa ESP32 DEVKIT DOIT cu 36 de pini. Înainte de a asambla circuitul, asigurați-vă că verificați pinout-ul plăcii pe care o utilizați.Cod
Aici oferim codul care creează ESP32 web server. Deschide codul Project_5_ESP32_Switch _Web_Server.ino în arduino IDE, dar nu-l încărcați încă. Trebuie să faceți câteva modificări pentru ca acesta să funcționeze pentru dvs.
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDE
Setarea acreditărilor de rețea
Trebuie să modificați următoarele rânduri cu acreditările de rețea: SSID și parola. Codul este bine comentat unde ar trebui să faceți modificările.Încărcarea Codului
Acum, puteți încărca codul și și web serverul va funcționa imediat.
Urmați următorii pași pentru a încărca codul pe ESP32:

1. Conectați-vă placa ESP32 la computer;
2. În Arduino IDE, selectați placa dvs. în Instrumente > Placă (în cazul nostru, folosim placa ESP32 DEVKIT DOIT);
3. Selectați portul COM în Instrumente > Port.
4. Apăsați butonul Încărcare din Arduino IDE și așteptați câteva secunde în timp ce codul se compilează și se încarcă pe placa dvs.
5. Așteptați mesajul „Încărcare terminată”.

Găsirea adresei IP ESP
După încărcarea codului, deschideți Serial Monitor la o viteză de transmisie de 115200.Apăsați butonul ESP32 EN (resetare). ESP32 se conectează la Wi-Fi și emite adresa IP ESP pe monitorul serial. Copiați acea adresă IP, pentru că aveți nevoie de ea pentru a accesa ESP32 web server.Accesarea Web Server
Pentru a accesa web server, deschideți browserul, inserați adresa IP ESP32 și veți vedea următoarea pagină.
Nota: Browserul și ESP32 ar trebui să fie conectate la aceeași rețea LAN.Dacă aruncați o privire la monitorul serial, puteți vedea ce se întâmplă pe fundal. ESP primește o solicitare HTTP de la un client nou (în acest caz, browserul dvs.).De asemenea, puteți vedea și alte informații despre solicitarea HTTP.
Demonstraţie
Acum puteți testa dacă dvs web serverul funcționează corect. Faceți clic pe butoane pentru a controla LED-urile.În același timp, puteți arunca o privire la Monitorul serial pentru a vedea ce se întâmplă în fundal. De example, când faceți clic pe butonul pentru a porni GPIO 26, ESP32 primește o solicitare pe /26/on URL.Când ESP32 primește această solicitare, pornește LED-ul atașat la GPIO 26 și își actualizează starea pe web pagină.Butonul pentru GPIO 27 funcționează într-un mod similar. Testați dacă funcționează corect.

Cum funcționează codul

În această secțiune, vom arunca o privire mai atentă asupra codului pentru a vedea cum funcționează.
Primul lucru pe care trebuie să-l faceți este să includeți biblioteca WiFi.După cum am menționat anterior, trebuie să introduceți ssid-ul și parola în rândurile următoare, în interiorul ghilimelelor.Apoi, setați dvs web server la portul 80.Următoarea linie creează o variabilă pentru a stoca antetul solicitării HTTP:Apoi, creați variabile auxiliare pentru a stoca starea curentă a ieșirilor dvs. Dacă doriți să adăugați mai multe ieșiri și să salvați starea acesteia, trebuie să creați mai multe variabile.De asemenea, trebuie să atribuiți un GPIO fiecărei ieșiri. Aici folosim GPIO 26 și GPIO 27. Puteți folosi orice alte GPIO adecvate.înființat()
Acum, să trecem la setup(). În primul rând, începem o comunicare în serie la o viteză de transmisie de 115200 în scopuri de depanare.De asemenea, vă definiți GPIO-urile ca IEȘIRI și le setați la LOW.Următoarele rânduri încep conexiunea Wi-Fi cu WiFi.begin(ssid, parola), așteptați o conexiune reușită și imprimați adresa IP ESP în monitorul serial.buclă()
În bucla() programăm ce se întâmplă când un nou client stabilește o conexiune cu web server.
ESP32 ascultă mereu clienții care sosesc cu următoarea linie:Când se primește o solicitare de la un client, vom salva datele primite. Bucla while care urmează va rula atâta timp cât clientul rămâne conectat. Nu vă recomandăm să schimbați următoarea parte a codului decât dacă știți exact ce faceți.Următoarea secțiune a declarațiilor if și else verifică ce buton a fost apăsat în dvs web pagina și controlează ieșirile în consecință. După cum am văzut anterior, facem o solicitare pe diferite URLs în funcție de butonul apăsat.De example, dacă ați apăsat butonul GPIO 26 ON, ESP32 primește o solicitare pe /26/ON URL (putem vedea că acele informații sunt pe antetul HTTP de pe monitorul serial). Deci, putem verifica dacă antetul conține expresia GET /26/on. Dacă conține, schimbăm variabila output26state la ON, iar ESP32 aprinde LED-ul.
Acest lucru funcționează în mod similar pentru celelalte butoane. Deci, dacă doriți să adăugați mai multe ieșiri, ar trebui să modificați această parte a codului pentru a le include.
Afișarea codului HTML web pagină
Următorul lucru pe care trebuie să-l faceți este să creați web pagină. ESP32 va trimite un răspuns browser-ului dvs. cu un cod HTML pentru a construi web pagină.
The web pagina este trimisă clientului utilizând acest expres client.println(). Ar trebui să introduceți ceea ce doriți să trimiteți clientului ca argument.
Primul lucru pe care ar trebui să-l trimitem este întotdeauna următoarea linie, care indică faptul că trimitem HTML.Apoi, următoarea linie face web pagina receptivă în orice web browser.Și următoarele sunt folosite pentru a preveni solicitările pe favicon. – Nu trebuie să-ți faci griji pentru această linie.

Stilizarea Web Pagină

În continuare, avem niște text CSS pentru a stila butoanele și web aspectul paginii.
Alegem fontul Helvetica, definim conținutul care urmează să fie afișat ca bloc și aliniat la centru.Ne stilăm butoanele cu culoarea #4CAF50, fără chenar, text în culoarea albă, și cu această umplutură: 16px 40px. De asemenea, setăm decorul textului la niciunul, definim dimensiunea fontului, marginea și cursorul la un indicator.De asemenea, definim stilul pentru un al doilea buton, cu toate proprietățile butonului pe care le-am definit mai devreme, dar cu o culoare diferită. Acesta va fi stilul pentru butonul de oprire.

Setarea Web Prima pagină a titlului
În rândul următor puteți seta primul titlu al dvs web pagină. Aici avem „ESP32 Web Server”, dar puteți schimba acest text în orice doriți.Afișarea butoanelor și a stării corespunzătoare
Apoi, scrieți un paragraf pentru a afișa starea curentă a GPIO 26. După cum puteți vedea, folosim variabila output26State, astfel încât starea să se actualizeze instantaneu atunci când această variabilă se modifică.Apoi, afișăm butonul pornit sau oprit, în funcție de starea curentă a GPIO. Dacă starea curentă a GPIO este oprită, afișăm butonul ON, dacă nu, afișăm butonul OFF.Folosim aceeași procedură pentru GPIO 27.
Închiderea conexiunii
În cele din urmă, când răspunsul se termină, ștergem variabila antet și oprim conexiunea cu clientul cu client.stop().

Încheierea

În acest tutorial v-am arătat cum să construiți un web server cu ESP32. Ți-am arătat un fost simpluample care controlează două LED-uri, dar ideea este să înlocuiți acele LED-uri cu un releu sau orice altă ieșire pe care doriți să o controlați.

Proiect 6 LED RGB Web Server

În acest proiect vă vom arăta cum să controlați de la distanță un LED RGB cu o placă ESP32 folosind un web server cu un selector de culoare.
Proiect încheiatview
Înainte de a începe, să vedem cum funcționează acest proiect:

• ESP32 web serverul afișează un selector de culori.
• Când alegeți o culoare, browserul dvs. face o solicitare pe a URL care conține parametrii R, G și B ai culorii selectate.
• ESP32 primește cererea și împarte valoarea pentru fiecare parametru de culoare.
• Apoi, trimite un semnal PWM cu valoarea corespunzătoare către GPIO-urile care controlează LED-ul RGB.

Cum funcționează LED-urile RGB?
Într-un LED RGB cu catod comun, toate cele trei LED-uri au o conexiune negativă (catod). Toate incluse în kit sunt RGB cu catod comun.Cum se creează culori diferite?
Cu un LED RGB puteți, desigur, să produceți lumină roșie, verde și albastră, iar prin configurarea intensității fiecărui LED, puteți produce și alte culori.
De exampPentru a produce lumină pur albastră, ați seta LED-ul albastru la cea mai mare intensitate și LED-urile verzi și roșii la cea mai mică intensitate. Pentru o lumină albă, ați seta toate cele trei LED-uri la cea mai mare intensitate.
Amestecarea culorilor
Pentru a produce alte culori, puteți combina cele trei culori în intensități diferite. Pentru a regla intensitatea fiecărui LED puteți folosi un semnal PWM.
Deoarece LED-urile sunt foarte aproape unele de altele, ochii noștri văd rezultatul combinației de culori, mai degrabă decât cele trei culori individual.
Pentru a avea o idee despre cum să combinați culorile, aruncați o privire la următorul grafic.
Aceasta este cea mai simplă diagramă de amestecare a culorilor, dar vă oferă o idee despre cum funcționează și cum să produceți diferite culori.Piese necesare
Pentru acest proiect aveți nevoie de următoarele părți:

• Placă ESP32 DEVKIT V1
• LED RGB
• 3x rezistențe de 220 ohmi
• Fire jumper
• Breadboard

SchematicCod
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)

• Instalarea suplimentului ESP32 în Arduino IDE

După asamblarea circuitului, deschideți codul
Project_6_RGB_LED_Web_Server.ino în IDE arduino.
Înainte de a încărca codul, nu uitați să introduceți acreditările de rețea, astfel încât ESP să se poată conecta la rețeaua locală.Cum funcționează codul
Schița ESP32 folosește biblioteca WiFi.h.Următoarele linii definesc variabilele șir pentru a păstra parametrii R, G și B din cerere.Următoarele patru variabile sunt folosite pentru a decoda solicitarea HTTP mai târziu.Creați trei variabile pentru GPIO-uri care vor controla parametrii benzii R, G și B. În acest caz, folosim GPIO 13, GPIO 12 și GPIO 14.Aceste GPIO trebuie să emită semnale PWM, așa că trebuie să configuram mai întâi proprietățile PWM. Setați frecvența semnalului PWM la 5000 Hz. Apoi, asociați un canal PWM pentru fiecare culoareȘi, în sfârșit, setați rezoluția canalelor PWM la 8 bițiÎn setup(), atribuiți proprietățile PWM canalelor PWMAtașați canalele PWM la GPIO-urile corespunzătoareUrmătoarea secțiune de cod afișează selectorul de culori din dvs web pagină și face o solicitare pe baza culorii pe care ați ales-o.Când alegeți o culoare, primiți o solicitare cu următorul format.

Deci, trebuie să împărțim acest șir pentru a obține parametrii R, G și B. Parametrii sunt salvați în variabilele redString, greenString și blueString și pot avea valori între 0 și 255.Pentru a controla banda cu ESP32, utilizați funcția ledcWrite() pentru a genera semnale PWM cu valorile decodificate din HTTP cerere.Nota: aflați mai multe despre PWM cu ESP32: Project 3 ESP32 PWM (Ieșire analogică)
Pentru a controla banda cu ESP8266, trebuie doar să folosim
funcția analogWrite() pentru a genera semnale PWM cu valorile decodificate din cererea HTPP.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
Deoarece obținem valorile într-o variabilă șir, trebuie să le convertim în numere întregi folosind metoda toInt().
Demonstraţie
După ce ați introdus acreditările de rețea, selectați placa și portul COM potrivite și încărcați codul în ESP32. Pașii de referință a codului de încărcare.
După încărcare, deschideți Serial Monitor la o viteză de transmisie de 115200 și apăsați butonul ESP Enable/Reset. Ar trebui să obțineți adresa IP a plăcii.Deschideți browserul și introduceți adresa IP ESP. Acum, utilizați selectorul de culori pentru a alege o culoare pentru LED-ul RGB.
Apoi, trebuie să apăsați butonul „Schimbați culoarea” pentru ca culoarea să aibă efect.Pentru a opri LED-ul RGB, selectați culoarea neagră.
Cele mai puternice culori (în partea de sus a selectorului de culori), sunt cele care vor produce rezultate mai bune.

Proiectul 7 ESP32 Releu Web Server

Utilizarea unui releu cu ESP32 este o modalitate excelentă de a controla de la distanță aparatele electrocasnice AC. Acest tutorial explică cum să controlezi un modul releu cu ESP32.
Vom arunca o privire la modul în care funcționează un modul releu, cum să conectați releul la ESP32 și să construim un web server pentru a controla un releu de la distanță.
Prezentarea releelor
Un releu este un comutator actionat electric si ca orice alt intrerupator, acesta poate fi pornit sau oprit, lasand curentul sa treaca sau nu. Poate fi controlat cu volum scăzuttages, la fel ca 3.3V furnizat de ESP32 GPIO-urile și ne permite să controlăm volumul ridicattageste ca 12V, 24V sau rețea voltage (230V în Europa și 120V în SUA).Pe partea stângă, există două seturi de trei prize pentru a conecta volum maretages, iar pinii din partea dreaptă (vol. joasătage) conectați-vă la GPIO-urile ESP32.
Rețeaua Voltage ConexiuniModulul releului prezentat în fotografia anterioară are doi conectori, fiecare cu trei prize: comun (COM), normal închis (NC) și normal deschis (NO).

• COM: conectați curentul pe care doriți să-l controlați (voltagși).
• NC (Normally Closed): configurația normal închis este utilizată atunci când doriți ca releul să fie închis în mod implicit. Pinii NC sunt COM sunt conectați, ceea ce înseamnă că curentul curge dacă nu trimiteți un semnal de la ESP32 la modulul releu pentru a deschide circuitul și a opri fluxul de curent.
• NO (Normally Open): configurația normal deschisă funcționează invers: nu există nicio conexiune între pinii NO și COM, deci circuitul este întrerupt dacă nu trimiteți un semnal de la ESP32 pentru a închide circuitul.

Pinii de controlVolumul scăzuttagPartea are un set de patru știfturi și un set de trei știfturi. Primul set este format din VCC și GND pentru a porni modulul și intrarea 1 (IN1) și intrarea 2 (IN2) pentru a controla releele de jos și, respectiv, de sus.
Dacă modulul releu are un singur canal, veți avea doar un pin IN. Dacă aveți patru canale, veți avea patru pini IN și așa mai departe.
Semnalul pe care îl trimiteți către pinii IN, determină dacă releul este activ sau nu. Releul este declanșat atunci când intrarea scade sub aproximativ 2V. Aceasta înseamnă că veți avea următoarele scenarii:

• Configurație normal închisă (NC):
• Semnal ÎNALT – curentul curge
• Semnal LOW – curentul nu circulă
• Configurație normal deschisă (NU):
• Semnal HIGH – curentul nu circulă
• Semnal LOW – curent în curgere

Ar trebui să utilizați o configurație normal închisă atunci când curentul ar trebui să curgă de cele mai multe ori și doriți să o opriți doar ocazional.
Utilizați o configurație normal deschisă atunci când doriți ca curentul să curgă ocazional (de example, turn on alamp ocazional).
Selectarea sursei de alimentareAl doilea set de pini este format din pini GND, VCC și JD-VCC.
Pinul JD-VCC alimentează electromagnetul releului. Observați că modulul are un capac de jumper care conectează pinii VCC și JD-VCC; cel afișat aici este galben, dar al tău poate avea o culoare diferită.
Cu capacul jumperului pus, pinii VCC și JD-VCC sunt conectați. Aceasta înseamnă că electromagnetul releului este alimentat direct de la pinul de alimentare ESP32, astfel încât modulul releului și circuitele ESP32 nu sunt izolate fizic unele de altele.
Fără capacul jumper, trebuie să furnizați o sursă de alimentare independentă pentru a alimenta electromagnetul releului prin pinul JD-VCC. Această configurație izolează fizic releele de ESP32 cu optocuplerul încorporat al modulului, ceea ce previne deteriorarea ESP32 în cazul unor vârfuri electrice.
SchematicAvertizare: Utilizarea volumului ridicattagSursele de alimentare pot provoca vătămări grave.
Prin urmare, se folosesc LED-uri de 5 mm în loc de volum mare de alimentaretage becuri în experiment. Dacă nu sunteți familiarizat cu rețeaua voltagÎntreabă pe cineva care să te ajute. În timp ce programați ESP sau conectați circuitul, asigurați-vă că totul este deconectat de la rețea voltage.Instalarea bibliotecii pentru ESP32
Pentru a construi asta web server, folosim ESPAsyncWebBiblioteca de server și Biblioteca AsyncTCP.
Instalarea ESPAsyncWebBiblioteca serverului
Urmați pașii următori pentru a instala ESPAsyncWebServer bibliotecă:

1. Faceți clic aici pentru a descărca ESPAsyncWebBiblioteca serverului. Ar trebui să fii
   un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui să obțineți ESPAsyncWebDosarul server-master
3. Redenumiți-vă folderul din ESPAsyncWebServer-master la ESPAsyncWebServer
4. Mutați ESPAsyncWebfolderul server în folderul biblioteci de instalare Arduino IDE

Alternativ, în IDE-ul dvs. Arduino, puteți merge la Schiță > Include
Bibliotecă > Adăugați o bibliotecă .ZIP... și selectați biblioteca pe care tocmai ați descărcat-o.
Instalarea bibliotecii AsyncTCP pentru ESP32
The ESPAsyncWebServer biblioteca necesită AsyncTCP biblioteca să lucreze. Urmăriți
următorii pași pentru a instala biblioteca respectivă:

1. Faceți clic aici pentru a descărca biblioteca AsyncTCP. Ar trebui să aveți un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui să obțineți folderul AsyncTCP-master
   1. Redenumiți folderul din AsyncTCP-master în AsyncTCP
   3. Mutați folderul AsyncTCP în folderul biblioteci de instalare Arduino IDE
   4. În cele din urmă, redeschideți IDE-ul dvs. Arduino

Alternativ, în IDE-ul dvs. Arduino, puteți merge la Schiță > Include
Bibliotecă > Adăugați o bibliotecă .ZIP... și selectați biblioteca pe care tocmai ați descărcat-o.
Cod
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDE
După instalarea bibliotecilor necesare, deschideți codul Project_7_ESP32_Relay_Web_Server.ino în IDE arduino.
Înainte de a încărca codul, nu uitați să introduceți acreditările de rețea, astfel încât ESP să se poată conecta la rețeaua locală.Demonstraţie
După efectuarea modificărilor necesare, încărcați codul în ESP32. Pașii de referință pentru codul de încărcare.
Deschideți monitorul serial la o viteză de transmisie de 115200 și apăsați butonul ESP32 EN pentru a obține adresa IP a acestuia. Apoi, deschideți un browser în rețeaua locală și introduceți adresa IP ESP32 pentru a obține acces la web server.
Deschideți monitorul serial la o viteză de transmisie de 115200 și apăsați butonul ESP32 EN pentru a obține adresa IP a acestuia. Apoi, deschideți un browser în rețeaua locală și introduceți adresa IP ESP32 pentru a obține acces la web server.Nota: Browserul și ESP32 ar trebui să fie conectate la aceeași rețea LAN.
Ar trebui să obțineți ceva după cum urmează, cu două butoane ca numărul de relee pe care le-ați definit în cod.Acum, puteți folosi butoanele pentru a vă controla releele folosind smartphone-ul.

Project_8_Output_State_Synchronization_ Web_Server

Acest proiect arată cum să controlați ieșirile ESP32 sau ESP8266 folosind un web server și un buton fizic simultan. Starea de ieșire este actualizată pe web pagina dacă este schimbat prin intermediul butonului fizic sau web server.
Proiect încheiatview
Să aruncăm o privire rapidă asupra modului în care funcționează proiectul.ESP32 sau ESP8266 găzduiește a web server care vă permite să controlați starea unei ieșiri;

• Starea curentă a ieșirii este afișată pe web Server;
• ESP este, de asemenea, conectat la un buton fizic care controlează aceeași ieșire;
• Dacă modificați starea de ieșire folosind butonul fizic, starea sa curentă este actualizată și pe web server.

În rezumat, acest proiect vă permite să controlați aceeași ieșire folosind a web server și un buton simultan. Ori de câte ori starea de ieșire se schimbă, web serverul este actualizat.
Piese necesare
Iată o listă cu părțile de care aveți nevoie pentru a construi circuitul:

• Placă ESP32 DEVKIT V1
• LED de 5 mm
• Rezistor de 220 ohmi
• Apasa butonul
• Rezistor de 10k Ohm
• Breadboard
• Fire jumper

SchematicInstalarea bibliotecii pentru ESP32
Pentru a construi asta web server, folosim ESPAsyncWebBiblioteca de server și Biblioteca AsyncTCP. (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea ESPAsyncWebBiblioteca serverului
Urmați pașii următori pentru a instala ESPAsyncWebBiblioteca serverului:

1. Faceți clic aici pentru a descărca ESPAsyncWebBiblioteca serverului. Ar trebui să fii
   un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui să obțineți ESPAsyncWebDosarul server-master
3. Redenumiți-vă folderul din ESPAsyncWebServer-master la ESPAsyncWebServer
4. Mutați ESPAsyncWebfolderul server în folderul biblioteci de instalare Arduino IDE
   Alternativ, în IDE-ul dvs. Arduino, puteți merge la Schiță > Include
   Bibliotecă > Adăugați o bibliotecă .ZIP... și selectați biblioteca pe care tocmai ați descărcat-o.

Instalarea bibliotecii AsyncTCP pentru ESP32
ESPAsyncWebBiblioteca de server necesită biblioteca AsyncTCP pentru a funcționa. Urmați următorii pași pentru a instala biblioteca respectivă:

1. Faceți clic aici pentru a descărca biblioteca AsyncTCP. Ar trebui să aveți un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui să obțineți folderul AsyncTCP-master
3. Redenumiți folderul din AsyncTCP-master în AsyncTCP
4. Mutați folderul AsyncTCP în folderul biblioteci de instalare Arduino IDE
5. În cele din urmă, redeschideți IDE-ul dvs. Arduino
   Alternativ, în IDE-ul dvs. Arduino, puteți merge la Schiță > Include
   Bibliotecă > Adăugați o bibliotecă .ZIP... și selectați biblioteca pe care tocmai ați descărcat-o.

Cod
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDE
După instalarea bibliotecilor necesare, deschideți codul
Project_8_Output_State_Synchronization_Web_Server.ino în IDE arduino.
Înainte de a încărca codul, nu uitați să introduceți acreditările de rețea, astfel încât ESP să se poată conecta la rețeaua locală.

Cum funcționează codul

Stare buton și stare ieșire
Variabila ledState deține starea de ieșire a LED-ului. În mod implicit, atunci când web serverul pornește, este LOW.

ButonState și lastButtonState sunt folosite pentru a detecta dacă butonul a fost apăsat sau nu.Buton (web Server)
Nu am inclus codul HTML pentru a crea butonul pentru variabila index_html.
Asta pentru ca vrem sa-l putem schimba in functie de starea curenta a LED-ului care poate fi schimbata si cu butonul.
Deci, am creat un substituent pentru butonul %BUTTONPLACEHOLDER% care va fi înlocuit cu text HTML pentru a crea butonul mai târziu în cod (acest lucru se face în funcția procesor()).procesor()
Funcția procesor() înlocuiește orice substituen din textul HTML cu valori reale. În primul rând, verifică dacă textele HTML conțin vreunul
substituenți %BUTTONPLACEHOLDER%.Apoi, apelați funcția OutputState() care returnează starea curentă de ieșire. Îl salvăm în variabila outputStateValue.După aceea, utilizați acea valoare pentru a crea textul HTML pentru a afișa butonul cu starea corectă:HTTP GET Solicitare de modificare a stării de ieșire (JavaScript)
Când apăsați butonul, este apelată funcția toggleCheckbox(). Această funcție va face o solicitare pe diferite URLs pentru a porni sau opri LED-ul.Pentru a porni LED-ul, face o solicitare pe /update?state=1 URL:În caz contrar, face o solicitare pe /update?state=0 URL.
HTTP GET Solicitare de actualizare a stării (JavaScript)
Pentru a menține starea de ieșire actualizată pe web server, numim următoarea funcție care face o nouă solicitare pe /state URL fiecare secundă.Gestionați cererile
Apoi, trebuie să ne ocupăm de ceea ce se întâmplă atunci când ESP32 sau ESP8266 primește solicitări pentru acestea URLs.
Când se primește o solicitare pe rădăcină /URL, trimitem pagina HTML precum și procesorul.Următoarele rânduri verifică dacă ați primit o solicitare pe /update?state=1 sau /update?state=0 URL și schimbă ledState în consecință.Când se primește o solicitare pe /state URL, trimitem starea curentă de ieșire:buclă()
În loop(), depășim butonul și pornim sau stingem LED-ul în funcție de valoarea ledState variabilă.Demonstraţie
Încărcați codul pe placa dvs. ESP32. Încărcați pașii de referință a codului.
Apoi, deschideți monitorul serial la o viteză de transmisie de 115200. Apăsați butonul EN/RST de la bord pentru a obține adresa IP.Deschideți un browser în rețeaua locală și introduceți adresa IP ESP. Ar trebui să aveți acces la web server așa cum se arată mai jos.
Nota: Browserul și ESP32 ar trebui să fie conectate la aceeași rețea LAN.Puteți comuta butonul de pe web server pentru a aprinde LED-ul.De asemenea, puteți controla același LED cu butonul fizic. Starea acestuia va fi întotdeauna actualizată automat pe web server.

Proiect 9 ESP32 DHT11 Web Server

În acest proiect, veți învăța cum să construiți un ESP32 asincron web server cu DHT11 care afișează temperatura și umiditatea folosind Arduino IDE.
Cerințe preliminare
The web serverul, vom construi automat actualizările citirilor, fără a fi nevoie să reîmprospătăm web pagină.
Cu acest proiect veți învăța:

• Cum să citiți temperatura și umiditatea de la senzorii DHT;
• Construiește un asincron web server folosind ESPAsyncWebBiblioteca serverului;
• Actualizați automat citirile senzorului, fără a fi nevoie să reîmprospătați web pagină.

Asincron Web Server
Pentru a construi web serverul vom folosi ESPAsyncWebBiblioteca serverului care oferă o modalitate ușoară de a construi un asincron web server. Construirea unui asincron web serverul are mai multe advantageste așa cum este menționat în pagina GitHub a bibliotecii, cum ar fi:

• „Gestionați mai multe conexiuni în același timp”;
• „Când trimiteți răspunsul, sunteți imediat gata să gestionați alte conexiuni în timp ce serverul se ocupă de trimiterea răspunsului în fundal”;
• „Motor simplu de procesare a șabloanelor pentru a gestiona șabloanele”;

Piese necesare
Pentru a finaliza acest tutorial aveți nevoie de următoarele părți:

• Placa de dezvoltare ESP32
• Modulul DHT11
• Breadboard
• Fire jumper

SchematicInstalarea Bibliotecilor
Trebuie să instalați câteva biblioteci pentru acest proiect:

• The DHT iar cel Senzor unificat Adafruit Biblioteci de drivere de citit de la senzorul DHT.
• ESPAsyncWebServer şi TCP asincron biblioteci pentru a construi asincronul web server.
  Urmați următoarele instrucțiuni pentru a instala acele biblioteci:

Instalarea bibliotecii de senzori DHT
Pentru a citi de la senzorul DHT folosind Arduino IDE, trebuie să instalați Biblioteca de senzori DHT. Urmați pașii următori pentru a instala biblioteca.

1. Faceți clic aici pentru a descărca biblioteca DHT Sensor. Ar trebui să aveți un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui să obțineți folderul DHT-sensor-library-master
3. Redenumiți folderul din DHT-sensor-library-master în DHT_sensor
4. Mutați folderul DHT_sensor în folderul biblioteci de instalare Arduino IDE
5. În cele din urmă, redeschideți IDE-ul dvs. Arduino

Instalarea driverului Adafruit Unified Sensor
De asemenea, trebuie să instalați Biblioteca Adafruit Unified Sensor Driver pentru a lucra cu senzorul DHT. Urmați pașii următori pentru a instala biblioteca.

1. Faceți clic aici pentru a descărca biblioteca Adafruit Unified Sensor. Ar trebui să aveți un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui să obțineți folderul Adafruit_sensor-master
3. Redenumiți folderul din Adafruit_sensor-master în Adafruit_sensor
4. Mutați folderul Adafruit_sensor în folderul biblioteci de instalare Arduino IDE
5. În cele din urmă, redeschideți IDE-ul dvs. Arduino

Instalarea ESPAsyncWebBiblioteca serverului

Urmați pașii următori pentru a instala ESPAsyncWebServer bibliotecă:

1. Faceți clic aici pentru a descărca ESPAsyncWebBiblioteca serverului. Ar trebui să fii
   un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui
   obține ESPAsyncWebDosarul server-master
3. Redenumiți-vă folderul din ESPAsyncWebServer-master la ESPAsyncWebServer
4. Mutați ESPAsyncWebfolderul server în folderul biblioteci de instalare Arduino IDE

Instalarea bibliotecii Async TCP pentru ESP32
The ESPAsyncWebServer biblioteca necesită AsyncTCP bibliotecă să lucreze. Urmați următorii pași pentru a instala biblioteca respectivă:

1. Faceți clic aici pentru a descărca biblioteca AsyncTCP. Ar trebui să aveți un folder .zip în dosarul Descărcări
2. Dezarhivați folderul .zip și ar trebui să obțineți folderul AsyncTCP-master
3. Redenumiți folderul din AsyncTCP-master în AsyncTCP
4. Mutați folderul AsyncTCP în folderul biblioteci de instalare Arduino IDE
5. În cele din urmă, redeschideți IDE-ul dvs. Arduino

Cod
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDE
După instalarea bibliotecilor necesare, deschideți codul
Project_9_ESP32_DHT11_Web_Server.ino în IDE arduino.
Înainte de a încărca codul, nu uitați să introduceți acreditările de rețea, astfel încât ESP să se poată conecta la rețeaua locală.Cum funcționează codul
În paragrafele următoare vom explica cum funcționează codul. Continuați să citiți dacă doriți să aflați mai multe sau să treceți la secțiunea Demonstrație pentru a vedea rezultatul final.
Importul bibliotecilor
Mai întâi, importați bibliotecile necesare. WiFi, ESPAsyncWebServerul și ESPAsyncTCP sunt necesare pentru a construi web server. Bibliotecile Adafruit_Sensor și DHT sunt necesare pentru a citi de la senzorii DHT11 sau DHT22.Definirea variabilelor
Definiți GPIO la care este conectat pinul de date DHT. În acest caz, este conectat la GPIO 4.Apoi, selectați tipul de senzor DHT pe care îl utilizați. În fostul nostruample, folosim DHT22. Dacă utilizați alt tip, trebuie doar să decomentați senzorul și să-i comentați pe toți ceilalți.

Instanciați un obiect DHT cu tipul și pinul pe care le-am definit mai devreme.Creați un AsyncWebObiect server pe portul 80.Citiți Funcțiile de temperatură și umiditate
Am creat două funcții: una pentru a citi temperatura Am creat două funcții: una pentru a citi temperatura (readDHTTemperature()) și cealaltă pentru a citi umiditatea (readDHTHumidity()).Obținerea citirilor senzorului este la fel de simplă ca și folosirea Obținerea citirilor senzorului este la fel de simplă ca utilizarea metodelor readTemperature() și readHumidity() pe obiectul dht.Avem și o condiție care returnează două liniuțe (–) în cazul în care senzorul nu reușește să obțină citirile.Citirile sunt returnate ca tip șir. Pentru a converti un float într-un șir, utilizați funcția String().În mod implicit, citim temperatura în grade Celsius. Pentru a obține temperatura în grade Fahrenheit, comentați temperatura în Celsius și decomentați temperatura în Fahrenheit, astfel încât să aveți următoarele:Încărcați Codul
Acum, încărcați codul pe ESP32. Asigurați-vă că ați selectat placa și portul COM potrivite. Încărcați pașii de referință a codului.
După încărcare, deschideți monitorul serial la o viteză de transmisie de 115200. Apăsați butonul de resetare ESP32. Adresa IP ESP32 ar trebui să fie tipărită în serie monitor.Demonstraţie
Deschideți un browser și introduceți adresa IP ESP32. Dvs web serverul ar trebui să afișeze cele mai recente citiri ale senzorului.
Nota: Browserul și ESP32 ar trebui să fie conectate la aceeași rețea LAN.
Observați că citirile de temperatură și umiditate sunt actualizate automat, fără a fi nevoie să reîmprospătați web pagină.

Project_10_ESP32_OLED_Display

Acest proiect arată cum să utilizați afișajul OLED SSD0.96 de 1306 inchi cu ESP32 folosind Arduino IDE.
Vă prezentăm un ecran OLED de 0.96 inchi
The Afișaj OLED pe care îl vom folosi în acest tutorial este modelul SSD1306: un afișaj monocolor, de 0.96 inci, cu 128×64 pixeli, așa cum se arată în figura următoare.Ecranul OLED nu necesită lumină de fundal, ceea ce are ca rezultat un contrast foarte frumos în medii întunecate. În plus, pixelii săi consumă energie doar atunci când sunt aprinși, astfel încât afișajul OLED consumă mai puțină energie în comparație cu alte afișaje.
Deoarece afișajul OLED utilizează protocolul de comunicare I2C, cablarea este foarte simplă. Puteți utiliza următorul tabel ca referință.

Pin OLED	ESP32
Vin	3.3V
GND	GND
SCL	GPIO 22
SDA	GPIO 21

SchematicInstalarea bibliotecii OLED SSD1306 – ESP32
Există mai multe biblioteci disponibile pentru a controla afișajul OLED cu ESP32.
În acest tutorial vom folosi două biblioteci Adafruit: Biblioteca Adafruit_SSD1306 şi Biblioteca Adafruit_GFX.
Urmați pașii următori pentru a instala acele biblioteci.

1. Deschideți Arduino IDE și accesați Sketch > Include Library > Manage Libraries. Managerul bibliotecii ar trebui să se deschidă.
2. Tastați „SSD1306” în caseta de căutare și instalați biblioteca SSD1306 de la Adafruit.
3. După instalarea bibliotecii SSD1306 de la Adafruit, tastați „GFX” în caseta de căutare și instalați biblioteca.
4. După instalarea bibliotecilor, reporniți IDE-ul Arduino.

Cod
După instalarea bibliotecilor necesare, deschideți Project_10_ESP32_OLED_Display.ino în arduino IDE. cod
Vom programa ESP32 folosind Arduino IDE, așa că asigurați-vă că aveți instalat suplimentul ESP32 înainte de a continua: (Dacă ați făcut deja acest pas, puteți sări la pasul următor.)
Instalarea suplimentului ESP32 în Arduino IDECum funcționează codul
Importul bibliotecilor
Mai întâi, trebuie să importați bibliotecile necesare. Biblioteca Wire pentru a utiliza I2C și bibliotecile Adafruit pentru a scrie pe afișaj: Adafruit_GFX și Adafruit_SSD1306.Inițializați afișajul OLED
Apoi, definiți lățimea și înălțimea OLED-ului. În acest exampdar, folosim un afișaj OLED de 128×64. Dacă utilizați alte dimensiuni, le puteți modifica în variabilele SCREEN_WIDTH și SCREEN_HEIGHT.Apoi, inițializați un obiect de afișare cu lățimea și înălțimea definite mai devreme cu protocolul de comunicare I2C (&Wire).Parametrul (-1) înseamnă că afișajul dvs. OLED nu are un pin RESET. Dacă afișajul dvs. OLED are un pin RESET, acesta ar trebui să fie conectat la un GPIO. În acest caz, ar trebui să treceți numărul GPIO ca parametru.
În setup(), inițializați monitorul serial la o viteză de baud de 115200 pentru scopuri de depanare.Inițializați afișajul OLED cu metoda begin() după cum urmează:Acest fragment tipărește și un mesaj pe monitorul serial, în cazul în care nu ne putem conecta la afișaj.

În cazul în care utilizați un afișaj OLED diferit, poate fi necesar să schimbați adresa OLED. În cazul nostru, adresa este 0x3C.După inițializarea afișajului, adăugați o întârziere de două secunde, astfel încât OLED-ul să aibă suficient timp pentru a se inițializa înainte de a scrie text:Afișaj clar, setați dimensiunea fontului, culoarea și scrieți textul
După inițializarea afișajului, ștergeți tamponul de afișare cu metoda clearDisplay():

Înainte de a scrie text, trebuie să setați dimensiunea textului, culoarea și unde va fi afișat textul în OLED.
Setați dimensiunea fontului folosind metoda setTextSize():Setați culoarea fontului cu metoda setTextColor():
WHITE setează fontul alb și fundalul negru.
Definiți poziția în care începe textul folosind metoda setCursor(x,y). În acest caz, setăm textul să înceapă la coordonatele (0,0) – în colțul din stânga sus.În cele din urmă, puteți trimite textul pe afișaj folosind metoda println(), după cum urmeazăApoi, trebuie să apelați metoda display() pentru a afișa textul pe ecran.

Biblioteca OLED Adafruit oferă metode utile pentru a derula cu ușurință textul.

• startscrollright(0x00, 0x0F): derulați textul de la stânga la dreapta
• startscrollleft(0x00, 0x0F): derulați textul de la dreapta la stânga
• startscrolldiagright(0x00, 0x07): derulați textul din colțul din stânga jos la colțul din dreapta sus startscrolldiagleft(0x00, 0x07): derulați textul din colțul din dreapta jos până la colțul din stânga sus

Încărcați Codul
Acum, încărcați codul în ESP32. Pașii de referință pentru codul de încărcare.
După încărcarea codului, OLED-ul va afișa text de defilare.

Documente/Resurse

Kit de pornire de bază LAFVIN ESP32 [pdfManual de instrucțiuni Kit de pornire de bază ESP32, ESP32, Kit de pornire de bază, Kit de pornire

Referințe

• Manual de utilizare