ESP32 Basic Starter
Kit

Listahan ng Pag-iimpake

ESP32 Panimula

Bago sa ESP32? Magsimula dito! Ang ESP32 ay isang serye ng mga low-cost at low-power System on a Chip (SoC) microcontrollers na binuo ni Espressif na kinabibilangan ng Wi-Fi at Bluetooth wireless na mga kakayahan at dual-core processor. Kung pamilyar ka sa ESP8266, ang ESP32 ang kapalit nito, na puno ng maraming bagong feature.Mga Detalye ng ESP32
Kung nais mong makakuha ng kaunti pang teknikal at tiyak, maaari mong tingnan ang sumusunod na mga detalyadong detalye ng ESP32 (pinagmulan: http://esp32.net/)—para sa higit pang mga detalye, suriin ang datasheet):

• Wireless connectivity WiFi: 150.0 Mbps data rate na may HT40
• Bluetooth: BLE (Bluetooth Low Energy) at Bluetooth Classic
• Processor: Tensilica Xtensa Dual-Core 32-bit LX6 microprocessor, tumatakbo sa 160 o 240 MHz
• Memorya:
• ROM: 448 KB (para sa booting at mga pangunahing function)
• SRAM: 520 KB (para sa data at mga tagubilin)
• RTC fas SRAM: 8 KB (para sa imbakan ng data at pangunahing CPU sa panahon ng RTC Boot mula sa deep-sleep mode)
• RTC slow SRAM: 8KB (para sa pag-access ng co-processor habang deep-sleep mode) eFuse: 1 Kbit (kung saan 256 bits ang ginagamit para sa system (MAC address at chip configuration) at ang natitirang 768 bits ay nakalaan para sa mga application ng customer, kasama ang Flash-Encryption at Chip-ID)

Naka-embed na flash: internal na konektado ang flash sa pamamagitan ng IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 at SD_DATA_1 sa ESP32-D2WD at ESP32-PICO-D4.

• 0 MiB (ESP32-D0WDQ6, ESP32-D0WD, at ESP32-S0WD chips)
• 2 MiB (ESP32-D2WD chip)
• 4 MiB (ESP32-PICO-D4 SiP module)

Mababang Power: tinitiyak na magagamit mo pa rin ang mga conversion ng ADC, halimbawaample, habang mahimbing na natutulog.
Peripheral Input/Output:

• peripheral interface na may DMA na may kasamang capacitive touch
• Mga ADC (Analog-to-Digital Converter)
• Mga DAC (Digital-to-Analog Converter)
• I²C (Inter-Integrated Circuit)
• UART (Universal Asynchronous Receiver/Transmitter)
• SPI (Serial Peripheral Interface)
• I²S (Integrated Interchip Sound)
• RMII (Reduced Media-Independent Interface)
• PWM (Pulse-Width Modulation)

Seguridad: mga hardware accelerator para sa AES at SSL/TLS

ESP32 Development Boards

Ang ESP32 ay tumutukoy sa hubad na ESP32 chip. Gayunpaman, ang terminong "ESP32" ay ginagamit din upang sumangguni sa mga development board ng ESP32. Ang paggamit ng ESP32 bare chips ay hindi madali o praktikal, lalo na kapag nag-aaral, sumusubok, at nag-prototyping. Kadalasan, gugustuhin mong gumamit ng ESP32 development board.
Gagamitin namin ang ESP32 DEVKIT V1 board bilang reference. Ipinapakita ng larawan sa ibaba ang ESP32 DEVKIT V1 board, bersyon na may 30 GPIO pin.Mga Pagtutukoy – ESP32 DEVKIT V1
Ang sumusunod na talahanayan ay nagpapakita ng buod ng mga tampok at detalye ng ESP32 DEVKIT V1 DOIT board:

Bilang ng mga core	2 (dalawang core)
Wi-Fi	2.4 GHz hanggang 150 Mbits/s
Bluetooth	BLE (Bluetooth Low Energy) at legacy na Bluetooth
Arkitektura	32 bits
Dalas ng orasan	Hanggang 240 MHz
RAM	512 KB
Mga pin	30 (depende sa modelo)

Mga peripheral	Capacitive touch, ADC (analog to digital converter), DAC (digital to analog converter), 12C (Inter-Integrated Circuit), UART (universal asynchronous receiver/transmitter), CAN 2.0 (Controller Area Netwokr), SPI (Serial Peripheral Interface) , 12S (Integrated Inter-IC Tunog), RMII (Reduced Media-Independent Interface), PWM (pulse width modulation), at higit pa.
Mga built-in na button	I-reset at BOOT ang mga pindutan
Mga built-in na LED	built-in na asul na LED na konektado sa GPIO2; built-in na pulang LED na nagpapakitang pinapagana ang board
USB sa UART tulay	CP2102

May kasama itong microUSB interface na magagamit mo para ikonekta ang board sa iyong computer para mag-upload ng code o mag-apply ng power.
Ginagamit nito ang CP2102 chip (USB to UART) para makipag-ugnayan sa iyong computer sa pamamagitan ng COM port gamit ang serial interface. Ang isa pang sikat na chip ay ang CH340. Suriin kung ano ang USB to UART chip converter sa iyong board dahil kakailanganin mong i-install ang mga kinakailangang driver para makipag-ugnayan ang iyong computer sa board (higit pang impormasyon tungkol dito sa susunod na gabay na ito).
Ang board na ito ay mayroon ding isang RESET button (maaaring may label na EN) upang i-restart ang board at isang BOOT button upang ilagay ang board sa flashing mode (available para makatanggap ng code). Tandaan na maaaring walang BOOT button ang ilang board.
Mayroon din itong built-in na asul na LED na panloob na konektado sa GPIO 2. Ang LED na ito ay kapaki-pakinabang para sa pag-debug upang magbigay ng ilang uri ng visual na pisikal na output. Mayroon ding pulang LED na umiilaw kapag nagbigay ka ng kuryente sa board.ESP32 Pinout
Kasama sa mga peripheral ng ESP32 ang:

• 18 Analog-to-Digital Converter (ADC) na mga channel
• 3 mga interface ng SPI
• 3 UART interface
• 2 mga interface ng I2C
• 16 na PWM output channel
• 2 Digital-to-Analog Converters (DAC)
• 2 I2S na mga interface
• 10 Capacitive sensing GPIOs

Ang mga feature ng ADC (analog to digital converter) at DAC (digital to analog converter) ay nakatalaga sa mga partikular na static na pin. Gayunpaman, maaari kang magpasya kung aling mga pin ang UART, I2C, SPI, PWM, atbp - kailangan mo lamang na italaga ang mga ito sa code. Posible ito dahil sa tampok na multiplexing ng ESP32 chip.
Bagama't maaari mong tukuyin ang mga katangian ng pin sa software, may mga pin na nakatalaga bilang default tulad ng ipinapakita sa sumusunod na figureBukod pa rito, may mga pin na may mga partikular na feature na ginagawang angkop o hindi para sa isang partikular na proyekto. Ipinapakita ng sumusunod na talahanayan kung anong mga pin ang pinakamahusay na gamitin bilang mga input, output at kung alin ang kailangan mong maging maingat.
Ang mga pin na naka-highlight sa berde ay OK na gamitin. Ang mga naka-highlight sa dilaw ay OK na gamitin, ngunit kailangan mong bigyang pansin dahil maaaring magkaroon sila ng hindi inaasahang pag-uugali pangunahin sa boot. Ang mga pin na naka-highlight sa pula ay hindi inirerekomenda na gamitin bilang mga input o output.

GP IO	Input	Output	Mga Tala
0	hinila pataas	OK	naglalabas ng PWM signal sa boot, dapat ay LOW para makapasok sa flashing mode
1	TX pin	OK	debug output sa boot
2	OK	OK	nakakonekta sa on-board LED, dapat iwanang lumulutang o LOW para makapasok sa flashing mode
3	OK	RX pin	MATAAS sa boot
4	OK	OK
5	OK	OK	naglalabas ng PWM signal sa boot, strapping pin
12	OK	OK	nabigo ang boot kung hinila ng mataas, strapping pin
13	OK	OK
14	OK	OK	naglalabas ng PWM signal sa boot
15	OK	OK	naglalabas ng PWM signal sa boot, strapping pin

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		input lamang
35	OK		input lamang
36	OK		input lamang
39	OK		input lamang

Magpatuloy sa pagbabasa para sa higit pang detalye at malalim na pagsusuri ng mga ESP32 GPIO at mga function nito.
Input lang ang mga pin
Ang mga GPIO 34 hanggang 39 ay mga GPI - mga pin lang ang input. Ang mga pin na ito ay walang panloob na pull-up o pull-down resistors. Hindi magagamit ang mga ito bilang mga output, kaya gamitin lang ang mga pin na ito bilang mga input:

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

SPI flash na isinama sa ESP-WROOM-32
Ang GPIO 6 hanggang GPIO 11 ay nakalantad sa ilang ESP32 development board. Gayunpaman, ang mga pin na ito ay konektado sa pinagsamang SPI flash sa ESP-WROOM-32 chip at hindi inirerekomenda para sa iba pang gamit. Kaya, huwag gamitin ang mga pin na ito sa iyong mga proyekto:

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

Capacitive touch GPIOs
Ang ESP32 ay may 10 panloob na capacitive touch sensor. Nararamdaman nito ang mga pagkakaiba-iba sa anumang bagay na may singil sa kuryente, tulad ng balat ng tao. Para ma-detect nila ang mga variation na naiimpluwensyahan kapag hinawakan ang mga GPIO gamit ang isang daliri. Ang mga pin na ito ay madaling maisama sa mga capacitive pad at palitan ang mga mechanical button. Ang mga capacitive touch pin ay maaari ding gamitin upang gisingin ang ESP32 mula sa mahimbing na pagtulog. Ang mga panloob na touch sensor na iyon ay konektado sa mga GPIO na ito:

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

Analog sa Digital Converter (ADC)
Ang ESP32 ay may 18 x 12 bits ADC input channels (habang ang ESP8266 ay mayroon lamang 1x 10 bits ADC). Ito ang mga GPIO na maaaring gamitin bilang ADC at kani-kanilang mga channel:

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

Tandaan: Hindi magagamit ang mga ADC2 pin kapag Wi-Fi ang ginamit. Kaya, kung gumagamit ka ng Wi-Fi at nagkakaproblema ka sa pagkuha ng halaga mula sa isang ADC2 GPIO, maaari mong isaalang-alang ang paggamit ng ADC1 GPIO sa halip. Iyan ay dapat malutas ang iyong problema.
Ang mga channel ng input ng ADC ay may 12-bit na resolusyon. Nangangahulugan ito na maaari kang makakuha ng mga analog na pagbabasa mula 0 hanggang 4095, kung saan ang 0 ay tumutugma sa 0V at 4095 hanggang 3.3V. Maaari mo ring itakda ang resolution ng iyong mga channel sa code at sa hanay ng ADC.
Ang mga ESP32 ADC pin ay walang linear na gawi. Malamang na hindi mo magagawang makilala ang pagitan ng 0 at 0.1V, o sa pagitan ng 3.2 at 3.3V. Kailangan mong isaisip iyon kapag ginagamit ang mga ADC pin. Makakakuha ka ng gawi na katulad ng ipinapakita sa sumusunod na figure.Digital to Analog Converter (DAC)
Mayroong 2 x 8 bits na DAC channel sa ESP32 upang i-convert ang mga digital signal sa analog voltage signal outputs. Ito ang mga channel ng DAC:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

Mga RTC GPIO
Mayroong suporta sa RTC GPIO sa ESP32. Ang mga GPIO na na-ruta sa RTC na low-power subsystem ay maaaring gamitin kapag ang ESP32 ay nasa malalim na pagtulog. Ang mga RTC GPIO na ito ay maaaring gamitin upang gisingin ang ESP32 mula sa mahimbing na pagtulog kapag ang Ultra Low
Gumagana ang co-processor ng Power (ULP). Ang mga sumusunod na GPIO ay maaaring gamitin bilang isang panlabas na mapagkukunan ng paggising.

• 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
Ang ESP32 LED PWM controller ay may 16 na independiyenteng channel na maaaring i-configure upang makabuo ng mga PWM signal na may iba't ibang katangian. Ang lahat ng mga pin na maaaring kumilos bilang mga output ay maaaring gamitin bilang mga PWM pin (ang mga GPIO 34 hanggang 39 ay hindi makakabuo ng PWM).
Upang magtakda ng signal ng PWM, kailangan mong tukuyin ang mga parameter na ito sa code:

• dalas ng signal;
• Ikot ng tungkulin;
• PWM channel;
• GPIO kung saan mo gustong i-output ang signal.

I2C
Ang ESP32 ay may dalawang I2C channel at anumang pin ay maaaring itakda bilang SDA o SCL. Kapag ginagamit ang ESP32 kasama ang Arduino IDE, ang mga default na I2C pin ay:

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

Kung gusto mong gumamit ng iba pang mga pin kapag ginagamit ang wire library, kailangan mo lang tumawag sa:
Wire.begin(SDA, SCL);
SPI
Bilang default, ang pin mapping para sa SPI ay:

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

Mga agwat
Maaaring i-configure ang lahat ng GPIO bilang mga interrupt.
Strapping Pins
Ang ESP32 chip ay may mga sumusunod na strapping pins:

• GPIO 0 (dapat LOW para makapasok sa boot mode)
• GPIO 2 (dapat nakalutang o LOW habang nag-boot)
• GPIO 4
• GPIO 5 (dapat na HIGH sa panahon ng boot)
• GPIO 12 (dapat MABA sa panahon ng boot)
• GPIO 15 (dapat na HIGH sa panahon ng boot)

Ginagamit ang mga ito upang ilagay ang ESP32 sa bootloader o flashing mode. Sa karamihan ng mga development board na may built-in na USB/Serial, hindi mo kailangang mag-alala tungkol sa estado ng mga pin na ito. Inilalagay ng board ang mga pin sa tamang estado para sa flashing o boot mode. Higit pang impormasyon sa ESP32 Boot Mode Selection ay matatagpuan dito.
Gayunpaman, kung mayroon kang mga peripheral na nakakonekta sa mga pin na iyon, maaaring nahihirapan kang subukang mag-upload ng bagong code, i-flash ang ESP32 gamit ang bagong firmware, o i-reset ang board. Kung mayroon kang ilang peripheral na nakakonekta sa mga strapping pin at nagkakaproblema ka sa pag-upload ng code o pag-flash ng ESP32, maaaring ito ay dahil pinipigilan ng mga peripheral na iyon ang ESP32 na pumasok sa tamang mode. Basahin ang dokumentasyon ng Boot Mode Selection para gabayan ka sa tamang direksyon. Pagkatapos mag-reset, mag-flash, o mag-boot, gumagana ang mga pin na iyon gaya ng inaasahan.
Mga Pin HIGH sa Boot
Binabago ng ilang GPIO ang kanilang estado sa HIGH o naglalabas ng mga PWM signal sa boot o pag-reset.
Nangangahulugan ito na kung mayroon kang mga output na konektado sa mga GPIO na ito maaari kang makakuha ng mga hindi inaasahang resulta kapag nag-reset o nag-boot ang ESP32.

• GPIO 1
• GPIO 3
• GPIO 5
• GPIO 6 hanggang GPIO 11 (nakakonekta sa ESP32 integrated SPI flash memory – hindi inirerekomendang gamitin).
• GPIO 14
• GPIO 15

Paganahin (EN)
Ang Enable (EN) ay ang enable pin ng 3.3V regulator. Ito ay hinila pataas, kaya kumonekta sa lupa upang hindi paganahin ang 3.3V regulator. Nangangahulugan ito na maaari mong gamitin ang pin na ito na nakakonekta sa isang pushbutton upang i-restart ang iyong ESP32, halimbawaample.
GPIO kasalukuyang iginuhit
Ang ganap na maximum na kasalukuyang iginuhit sa bawat GPIO ay 40mA ayon sa seksyong "Inirerekomendang Operating Condition" sa ESP32 datasheet.
ESP32 Built-In Hall Effect Sensor
Nagtatampok din ang ESP32 ng built-in na hall effect sensor na nakakakita ng mga pagbabago sa magnetic field sa paligid nito
ESP32 Arduino IDE
Mayroong add-on para sa Arduino IDE na nagbibigay-daan sa iyong i-program ang ESP32 gamit ang Arduino IDE at ang programming language nito. Sa tutorial na ito, ipapakita namin sa iyo kung paano i-install ang ESP32 board sa Arduino IDE kung gumagamit ka ng Windows, Mac OS X o Linux.
Mga Kinakailangan: Naka-install ang Arduino IDE
Bago simulan ang pamamaraang ito sa pag-install, kailangan mong i-install ang Arduino IDE sa iyong computer. Mayroong dalawang bersyon ng Arduino IDE na maaari mong i-install: bersyon 1 at bersyon 2.
Maaari mong i-download at i-install ang Arduino IDE sa pamamagitan ng pag-click sa sumusunod na link: arduino.cc/en/Main/Software
Aling bersyon ng Arduino IDE ang inirerekomenda namin? Sa ngayon, may ilan plugins para sa ESP32 (tulad ng SPIFFS Filesystem Uploader Plugin) na hindi pa sinusuportahan sa Arduino 2. Kaya, kung balak mong gamitin ang SPIFFS plugin sa hinaharap, inirerekomenda namin ang pag-install ng legacy na bersyon 1.8.X. Kailangan mo lang mag-scroll pababa sa pahina ng software ng Arduino upang mahanap ito.
Pag-install ng ESP32 Add-on sa Arduino IDE
Upang i-install ang ESP32 board sa iyong Arduino IDE, sundin ang mga susunod na tagubiling ito:

1. Sa iyong Arduino IDE, pumunta sa File> Mga Kagustuhan
2. Ilagay ang sumusunod sa “Additional Board Manager URLs” field:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Pagkatapos, i-click ang "OK" na buton:Tandaan: kung mayroon ka nang ESP8266 boards URL, maaari mong paghiwalayin ang URLs na may kuwit tulad ng sumusunod:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Buksan ang Boards Manager. Pumunta sa Tools > Board > Boards Manager...Maghanap para sa ESP32 and press install button for the “ESP32 by Espressif Systems“:yun lang. Dapat itong mai-install pagkatapos ng ilang segundo.

Mag-upload ng Test Code

Isaksak ang ESP32 board sa iyong computer. Kapag nakabukas ang iyong Arduino IDE, sundin ang mga hakbang na ito:

1. Piliin ang iyong Board sa Tools > Board menu (sa aking kaso ito ang ESP32 DEV Module）
2. Piliin ang Port (kung hindi mo nakikita ang COM Port sa iyong Arduino IDE, kailangan mong i-install ang CP210x USB sa UART Bridge VCP Drivers):
3. Buksan ang sumusunod na exampsa ilalim File > Halamples > WiFi
   (ESP32) > WiFiScan
4. Isang bagong sketch ang bubukas sa iyong Arduino IDE:
5. Pindutin ang pindutan ng Upload sa Arduino IDE. Maghintay ng ilang segundo habang ang code ay nag-compile at nag-a-upload sa iyong board.
6. Kung nangyari ang lahat gaya ng inaasahan, dapat mong makita ang isang "Tapos na sa pag-upload." mensahe.
7. Buksan ang Arduino IDE Serial Monitor sa isang baud rate na 115200:
8. Pindutin ang ESP32 on-board Enable button at dapat mong makita ang mga network na available malapit sa iyong ESP32:

Pag-troubleshoot

Kung susubukan mong mag-upload ng bagong sketch sa iyong ESP32 at makuha mo ang mensahe ng error na ito “Naganap ang isang nakamamatay na error: Nabigong kumonekta sa ESP32: Nag-time out… Kumokonekta…“. Nangangahulugan ito na ang iyong ESP32 ay wala sa flashing/uploading mode.
Ang pagkakaroon ng tamang board name at COM por napili, sundin ang mga hakbang na ito:
Pindutin nang matagal ang "BOOT" na buton sa iyong ESP32 board

• Pindutin ang button na “Upload” sa Arduino IDE para i-upload ang iyong sketch:
• Pagkatapos mong makita ang “Kumokonekta….” mensahe sa iyong Arduino IDE, bitawan ang daliri mula sa "BOOT" na buton:
• Pagkatapos nito, dapat mong makita ang mensaheng "Tapos na sa pag-upload".
  yun lang. Ang iyong ESP32 ay dapat magkaroon ng bagong sketch na tumatakbo. Pindutin ang button na “ENABLE” para i-restart ang ESP32 at patakbuhin ang bagong na-upload na sketch.
  Kakailanganin mo ring ulitin ang sequence ng button na iyon sa tuwing gusto mong mag-upload ng bagong sketch.

Project 1 ESP32 Mga Input na Output

Sa gabay na ito sa pagsisimula, matututunan mo kung paano magbasa ng mga digital input tulad ng switch ng button at kontrolin ang mga digital na output tulad ng LED gamit ang ESP32 na may Arduino IDE.
Mga kinakailangan
Ipo-program namin ang ESP32 gamit ang Arduino IDE. Kaya, siguraduhing mayroon kang naka-install na ESP32 boards add-on bago magpatuloy:

• Pag-install ng ESP32 Add-on sa Arduino IDE

ESP32 Kontrolin ang Mga Digital na Output
Una, kailangan mong itakda ang GPIO na gusto mong kontrolin bilang isang OUTPUT. Gamitin ang pinMode() function gaya ng sumusunod:
pinMode(GPIO, OUTPUT);
Upang makontrol ang isang digital na output kailangan mo lang gamitin ang digitalWrite() function, na tumatanggap bilang mga argumento, ang GPIO (int number) na iyong tinutukoy, at ang estado, alinman sa HIGH o LOW.
digitalWrite(GPIO, STATE);
Ang lahat ng GPIO ay maaaring gamitin bilang mga output maliban sa GPIOs 6 hanggang 11 (konektado sa integrated SPI flash) at GPIOs 34, 35, 36 at 39 (input only GPIOs);
Matuto pa tungkol sa ESP32 GPIOs: ESP32 GPIO Reference Guide
ESP32 Read Digital Inputs
Una, itakda ang GPIO na gusto mong basahin bilang INPUT, gamit ang pinMode() function tulad ng sumusunod:
pinMode(GPIO, INPUT);
Upang magbasa ng digital input, tulad ng isang button, ginagamit mo ang digitalRead() function, na tumatanggap bilang argumento, ang GPIO (int number) na iyong tinutukoy.
digitalRead(GPIO);
Ang lahat ng ESP32 GPIO ay maaaring gamitin bilang mga input, maliban sa mga GPIO 6 hanggang 11 (nakakonekta sa integrated SPI flash).
Matuto pa tungkol sa ESP32 GPIOs: ESP32 GPIO Reference Guide
Proyekto Halample
Para ipakita sa iyo kung paano gumamit ng mga digital na input at digital na output, gagawa kami ng isang simpleng proyekto halample na may pushbutton at isang LED. Babasahin namin ang estado ng pushbutton at sindihan ang LED nang naaayon tulad ng inilalarawan sa sumusunod na figure.

Mga Bahaging Kinakailangan
Narito ang isang listahan ng mga bahagi na kailangan mo upang bumuo ng circuit:

• ESP32 DEVKIT V1
• 5 mm na LED
• 220 Ohm risistor
• Pushbutton
• 10k Ohm risistor
• Breadboard
• Mga wire ng jumper

Schematic Diagram
Bago magpatuloy, kailangan mong mag-ipon ng isang circuit na may isang LED at isang pushbutton.
Ikokonekta namin ang LED sa GPIO 5 at ang pushbutton sa GPIO 4.Code
Buksan ang code na Project_1_ESP32_Inputs_Outputs.ino sa arduino IDEPaano Gumagana ang Code
Sa sumusunod na dalawang linya, lumikha ka ng mga variable upang magtalaga ng mga pin:

Ang pindutan ay konektado sa GPIO 4 at ang LED ay konektado sa GPIO 5. Kapag ginagamit ang Arduino IDE na may ESP32, 4 ay tumutugma sa GPIO 4 at 5 ay tumutugma sa GPIO 5.
Susunod, lumikha ka ng isang variable upang hawakan ang estado ng pindutan. Bilang default, ito ay 0 (hindi pinindot).
int buttonState = 0;
Sa setup(), inisimulan mo ang button bilang INPUT, at ang LED bilang OUTPUT.
Para diyan, ginagamit mo ang pinMode() function na tumatanggap sa pin na iyong tinutukoy, at ang mode: INPUT o OUTPUT.
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
Sa loop() ay kung saan mo basahin ang estado ng button at itakda ang LED nang naaayon.
Sa susunod na linya, babasahin mo ang estado ng button at i-save ito sa variable na buttonState.
Gaya ng nakita natin dati, ginagamit mo ang digitalRead() function.
buttonState = digitalRead(buttonPin);
Ang sumusunod na if statement, ay nagsusuri kung HIGH ang status ng button. Kung oo, ini-on nito ang LED gamit ang digitalWrite() function na tinatanggap bilang argumento ang ledPin, at ang estado na HIGH.
kung (buttonState == HIGH)Kung hindi HIGH ang estado ng button, i-set mo ang LED off. Itakda lamang ang LOW bilang pangalawang argumento sa digitalWrite() function.Pag-upload ng Code
Bago i-click ang upload button, pumunta sa Tools > Board, at piliin ang board :DOIT ESP32 DEVKIT V1 board.
Pumunta sa Tools > Port at piliin ang COM port kung saan nakakonekta ang ESP32. Pagkatapos, pindutin ang pindutan ng pag-upload at hintayin ang mensaheng "Tapos na sa pag-upload".Tandaan: Kung makakita ka ng maraming tuldok (kumukonekta…__…__) sa debugging window at ang mensaheng “Nabigong kumonekta sa ESP32: Nag-time out sa paghihintay para sa packet header,” nangangahulugan iyon na kailangan mong pindutin ang ESP32 on-board BOOT pindutan pagkatapos ng mga tuldok
magsimulang lumitaw.Pag-troubleshoot

Pagpapakita

Pagkatapos i-upload ang code, subukan ang iyong circuit. Dapat umilaw ang iyong LED kapag pinindot mo ang pushbutton:At i-off kapag binitawan mo ito:

Project 2 ESP32 Analog Inputs

Ipinapakita ng proyektong ito kung paano magbasa ng mga analog input sa ESP32 gamit ang Arduino IDE.
Kapaki-pakinabang ang pagbabasa ng analog upang basahin ang mga halaga mula sa mga variable na resistor tulad ng mga potentiometer, o mga analog na sensor.
Mga Analog Input (ADC)
Ang pagbabasa ng isang analog na halaga sa ESP32 ay nangangahulugan na maaari mong sukatin ang iba't ibang voltage antas sa pagitan ng 0 V at 3.3 V.
Ang voltagAng sinusukat ay pagkatapos ay itinalaga sa isang halaga sa pagitan ng 0 at 4095, kung saan ang 0 V ay tumutugma sa 0, at 3.3 V ay tumutugma sa 4095. Anumang voltage sa pagitan ng 0 V at 3.3 V ay bibigyan ng katumbas na halaga sa pagitan.Ang ADC ay Non-linear
Sa isip, aasahan mo ang isang linear na pag-uugali kapag ginagamit ang ESP32 ADC pin.
Gayunpaman, hindi iyon nangyayari. Ang makukuha mo ay isang pag-uugali tulad ng ipinapakita sa sumusunod na tsart:Ang pag-uugali na ito ay nangangahulugan na ang iyong ESP32 ay hindi nakikilala ang 3.3 V mula sa 3.2 V.
Makakakuha ka ng parehong halaga para sa parehong voltagay: 4095.
Ang parehong nangyayari para sa napakababang voltage value: para sa 0 V at 0.1 V makakakuha ka ng parehong halaga: 0. Kailangan mong tandaan ito kapag ginagamit ang ESP32 ADC pin.
analogRead() function
Ang pagbabasa ng analog input gamit ang ESP32 gamit ang Arduino IDE ay kasing simple ng paggamit ng analogRead() function. Tinatanggap nito bilang argumento, ang GPIO na gusto mong basahin:
analogRead(GPIO);
15 lang ang available sa DEVKIT V1board (bersyon na may 30 GPIO).
Kunin ang iyong ESP32 board pinout at hanapin ang mga ADC pin. Ang mga ito ay naka-highlight na may pulang hangganan sa figure sa ibaba.Ang mga analog input pin na ito ay may 12-bit na resolution. Nangangahulugan ito na kapag nagbasa ka ng analog input, maaaring mag-iba ang saklaw nito mula 0 hanggang 4095.
Tandaan: Hindi magagamit ang mga ADC2 pin kapag Wi-Fi ang ginamit. Kaya, kung gumagamit ka ng Wi-Fi at nagkakaproblema ka sa pagkuha ng halaga mula sa isang ADC2 GPIO, maaari mong isaalang-alang ang paggamit ng isang ADC1 GPIO sa halip, na dapat malutas ang iyong problema.
Para makita kung paano magkakaugnay ang lahat, gagawa tayo ng isang simpleng example upang basahin ang isang analog na halaga mula sa isang potentiometer.
Mga Bahaging Kinakailangan
Para itong example, kailangan mo ang mga sumusunod na bahagi:

• ESP32 DEVKIT V1 Board
• Potensyomiter
• Breadboard
• Mga wire ng jumper

Eskematiko
Mag-wire ng potentiometer sa iyong ESP32. Ang potentiometer middle pin ay dapat na konektado sa GPIO 4. Maaari mong gamitin ang sumusunod na schematic diagram bilang isang sanggunian.Code
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDE
Buksan ang code na Project_2_ESP32_Inputs_Outputs.ino sa arduino IDEBinabasa lang ng code na ito ang mga value mula sa potentiometer at ini-print ang mga value na iyon sa Serial Monitor.
Sa code, magsisimula ka sa pamamagitan ng pagtukoy sa GPIO kung saan konektado ang potentiometer. Sa ex na itoample, GPIO 4.Sa setup(), magpasimula ng serial communication sa baud rate na 115200.Sa loop(), gamitin ang analogRead() function para basahin ang analog input mula sa potPin.Panghuli, i-print ang mga value na nabasa mula sa potentiometer sa serial monitor.I-upload ang code na ibinigay sa iyong ESP32. Tiyaking napili mo ang tamang board at COM port sa menu ng Mga Tool.
Pagsubok sa Halample
Pagkatapos i-upload ang code at pindutin ang ESP32 reset button, buksan ang Serial Monitor sa baud rate na 115200. I-rotate ang potentiometer at tingnan ang pagbabago ng mga value.Ang maximum na value na makukuha mo ay 4095 at ang minimum na value ay 0.

Pagbabalot

Sa artikulong ito natutunan mo kung paano magbasa ng mga analog input gamit ang ESP32 gamit ang Arduino IDE. Sa buod:

• Ang ESP32 DEVKIT V1 DOIT board (bersyon na may 30 pin) ay may 15 ADC pin na magagamit mo para magbasa ng mga analog input.
• Ang mga pin na ito ay may resolution na 12 bits, na nangangahulugang makakakuha ka ng mga value mula 0 hanggang 4095.
• Upang basahin ang isang halaga sa Arduino IDE, gagamitin mo lang ang analogRead() function.
• Ang mga ESP32 ADC pin ay walang linear na gawi. Malamang na hindi mo matukoy ang pagkakaiba sa pagitan ng 0 at 0.1V, o sa pagitan ng 3.2 at 3.3V. Kailangan mong isaisip iyon kapag ginagamit ang mga ADC pin.

Project 3 ESP32 PWM(Analog Output)

Sa tutorial na ito, ipapakita namin sa iyo kung paano bumuo ng mga PWM signal gamit ang ESP32 gamit ang Arduino IDE. Bilang isang exampgagawa tayo ng simpleng circuit na nagpapalabo ng LED gamit ang LED PWM controller ng ESP32.ESP32 LED PWM Controller
Ang ESP32 ay may LED PWM controller na may 16 na independiyenteng channel na maaaring i-configure upang makabuo ng mga PWM signal na may iba't ibang katangian.
Narito ang mga hakbang na kailangan mong sundin upang madilim ang isang LED na may PWM gamit ang Arduino IDE:

1. Una, kailangan mong pumili ng PWM channel. Mayroong 16 na channel mula 0 hanggang 15.
2. Pagkatapos, kailangan mong itakda ang dalas ng signal ng PWM. Para sa isang LED, ang dalas ng 5000 Hz ay ​​mainam na gamitin.
3. Kailangan mo ring itakda ang resolution ng duty cycle ng signal: mayroon kang mga resolution mula 1 hanggang 16 bits. Gagamit kami ng 8-bit na resolution, na nangangahulugang makokontrol mo ang LED brightness gamit ang value mula 0 hanggang 255.
4.  Susunod, kailangan mong tukuyin kung aling mga GPIO o GPIO ang lalabas ng signal. Para diyan gagamitin mo ang sumusunod na function:
   ledcAttachPin(GPIO, channel)
   Tumatanggap ang function na ito ng dalawang argumento. Ang una ay ang GPIO na maglalabas ng signal, at ang pangalawa ay ang channel na bubuo ng signal.
5. Panghuli, para makontrol ang liwanag ng LED gamit ang PWM, ginagamit mo ang sumusunod na function:

ledcWrite(channel, dutycycle)
Tinatanggap ng function na ito bilang argumento ang channel na bumubuo ng PWM signal, at ang duty cycle.
Mga Bahaging Kinakailangan
Upang sundin ang tutorial na ito kailangan mo ang mga bahaging ito:

• ESP32 DEVKIT V1 Board
• 5mm LED
• 220 Ohm risistor
•  Breadboard
• Mga wire ng jumper

Eskematiko
Mag-wire ng LED sa iyong ESP32 tulad ng sa sumusunod na schematic diagram. Ang LED ay dapat na konektado sa GPIO 4.Tandaan: maaari mong gamitin ang anumang pin na gusto mo, hangga't maaari itong kumilos bilang isang output. Ang lahat ng mga pin na maaaring kumilos bilang mga output ay maaaring gamitin bilang mga PWM pin. Para sa higit pang impormasyon tungkol sa mga ESP32 GPIO, basahin ang: ESP32 Pinout Reference: Aling mga GPIO pin ang dapat mong gamitin?
Code
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDE
Buksan ang code na Project_3_ESP32_PWM.ino sa arduino IDEMagsisimula ka sa pamamagitan ng pagtukoy sa pin kung saan naka-attach ang LED. Sa kasong ito, ang LED ay nakakabit sa GPIO 4.Pagkatapos, itinakda mo ang mga katangian ng signal ng PWM. Tinukoy mo ang dalas ng 5000 Hz, pipiliin ang channel 0 upang makabuo ng signal, at magtakda ng resolution na 8 bits. Maaari kang pumili ng iba pang mga katangian, naiiba sa mga ito, upang makabuo ng iba't ibang mga signal ng PWM.Sa setup(), kailangan mong i-configure ang LED PWM gamit ang mga property na tinukoy mo nang mas maaga sa pamamagitan ng paggamit ng ledcSetup() function na tumatanggap bilang mga argumento, ang ledChannel, ang frequency, at ang resolution, tulad ng sumusunod:Susunod, kailangan mong piliin ang GPIO kung saan mo makukuha ang signal. Para doon gamitin ang ledcAttachPin() function na tumatanggap bilang mga argumento sa GPIO kung saan mo gustong makuha ang signal, at ang channel na bumubuo ng signal. Sa ex na itoampLe, kukunin natin ang signal sa ledPin GPIO, na tumutugma sa GPIO 4. Ang channel na bumubuo ng signal ay ang ledChannel, na tumutugma sa channel 0.Sa loop, iba-iba mo ang duty cycle sa pagitan ng 0 at 255 upang mapataas ang liwanag ng LED.At pagkatapos, sa pagitan ng 255 at 0 upang bawasan ang liwanag.Upang itakda ang liwanag ng LED, kailangan mo lang gamitin ang ledcWrite() function na tumatanggap bilang argumento sa channel na bumubuo ng signal, at ang duty cycle.Habang gumagamit kami ng 8-bit na resolution, ang duty cycle ay makokontrol gamit ang isang value mula 0 hanggang 255. Tandaan na sa ledcWrite() function ginagamit namin ang channel na bumubuo ng signal, at hindi ang GPIO.

Pagsubok sa Halample

I-upload ang code sa iyong ESP32. Tiyaking napili mo ang tamang board at COM port. Tingnan ang iyong circuit. Dapat ay mayroon kang dimmer LED na nagpapataas at nagpapababa ng liwanag.

Project 4 ESP32 PIR Motion Sensor

Ipinapakita ng proyektong ito kung paano mag-detect ng motion gamit ang ESP32 gamit ang PIR motion sensor. Magpapatunog ang buzzer ng alarm kapag may na-detect na paggalaw, at ihihinto ang alarm kapag walang natukoy na paggalaw sa loob ng preset na oras (tulad ng 4 na segundo)
Paano Gumagana ang HC-SR501 Motion Sensor
.Ang prinsipyo ng pagtatrabaho ng HC-SR501 sensor ay batay sa pagbabago ng infrared radiation sa gumagalaw na bagay. Upang matukoy ng HC-SR501 sensor, dapat matugunan ng bagay ang dalawang kinakailangan:

• Ang bagay ay nagpapalabas ng infrared na paraan.
• Ang bagay ay gumagalaw o nanginginig

Kaya:
Kung ang isang bagay ay naglalabas ng infrared ray ngunit Hindi gumagalaw (hal., ang isang tao ay nakatayo nang hindi gumagalaw), hindi ito nade-detect ng sensor.
Kung ang isang bagay ay gumagalaw ngunit Hindi naglalabas ng infrared ray (hal., robot o sasakyan), HINDI ito nadetect ng sensor.
Ipinapakilala ang mga Timer
Sa ex na itoample magpapakilala din kami ng mga timer. Gusto naming manatili ang LED sa isang paunang natukoy na bilang ng mga segundo pagkatapos matukoy ang paggalaw. Sa halip na gumamit ng delay() function na humaharang sa iyong code at hindi nagpapahintulot sa iyo na gumawa ng anupaman para sa isang tiyak na bilang ng mga segundo, dapat kaming gumamit ng timer.Ang delay() function
Dapat ay pamilyar ka sa delay() function dahil malawak itong ginagamit. Ang function na ito ay medyo tapat na gamitin. Tumatanggap ito ng isang int number bilang argumento.
Ang numerong ito ay kumakatawan sa oras sa milliseconds na kailangang maghintay ng program hanggang sa lumipat sa susunod na linya ng code.Kapag naantala(1000) ang iyong programa ay hihinto sa linyang iyon nang 1 segundo.
delay() ay isang blocking function. Ang pag-block ng mga function ay pumipigil sa isang programa sa paggawa ng anupaman hanggang sa makumpleto ang partikular na gawain. Kung kailangan mo ng maraming gawain na mangyari nang sabay, hindi mo magagamit ang delay().
Para sa karamihan ng mga proyekto dapat mong iwasan ang paggamit ng mga pagkaantala at sa halip ay gumamit ng mga timer.
Ang millis() function
Gamit ang isang function na tinatawag na millis() maaari mong ibalik ang bilang ng mga millisecond na lumipas mula noong unang nagsimula ang programa.Bakit kapaki-pakinabang ang function na iyon? Dahil sa paggamit ng ilang matematika, madali mong mabe-verify kung gaano katagal ang lumipas nang hindi hinaharangan ang iyong code.
Mga Bahaging Kinakailangan
Upang sundin ang tutorial na ito kailangan mo ang mga sumusunod na bahagi

• ESP32 DEVKIT V1 Board
• PIR motion sensor (HC-SR501)
• Aktibong Buzzer
• Mga wire ng jumper
• Breadboard

EskematikoTandaan: Ang gumaganang voltage ng HC-SR501 ay 5V. Gamitin ang Vin pin para paganahin ito.
Code
Bago magpatuloy sa tutorial na ito dapat ay mayroon kang ESP32 add-on na naka-install sa iyong Arduino IDE. Sundin ang isa sa mga sumusunod na tutorial upang i-install ang ESP32 sa Arduino IDE, kung hindi mo pa nagagawa. (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDE
Buksan ang code na Project_4_ESP32_PIR_Motion_Sensor.ino sa arduino IDE.
Pagpapakita
I-upload ang code sa iyong ESP32 board. Tiyaking napili mo ang tamang board at COM port. Mag-upload ng mga hakbang sa pagtukoy ng code.
Buksan ang Serial Monitor sa baud rate na 115200.Ilipat ang iyong kamay sa harap ng PIR sensor. Dapat na naka-on ang buzzer, at ang mensahe ay naka-print sa Serial Monitor na nagsasabing "Nakita ang paggalaw! Buzzer alarm".
Pagkatapos ng 4 na segundo dapat patayin ang buzzer.

Project 5 ESP32 Switch Web server

Sa proyektong ito gagawa ka ng isang standalone web server na may ESP32 na kumokontrol sa mga output (dalawang LED) gamit ang Arduino IDE programming environment. Ang web Ang server ay mobile na tumutugon at maaaring ma-access sa anumang device na bilang isang browser sa lokal na network. Ipapakita namin sa iyo kung paano gawin ang web server at kung paano gumagana ang code nang sunud-sunod.
Tapos na ang Projectview
Bago dumiretso sa proyekto, mahalagang balangkasin kung ano ang ating web gagawin ng server, upang mas madaling sundin ang mga hakbang sa susunod.

• Ang web server na bubuuin mo ay kumokontrol sa dalawang LED na konektado sa ESP32 GPIO 26 at GPIO 27;
• Maaari mong ma-access ang ESP32 web server sa pamamagitan ng pag-type ng ESP32 IP address sa isang browser sa lokal na network;
• Sa pamamagitan ng pag-click sa mga pindutan sa iyong web server maaari mong agad na baguhin ang estado ng bawat LED.

Mga Bahaging Kinakailangan
Para sa tutorial na ito kakailanganin mo ang mga sumusunod na bahagi:

• ESP32 DEVKIT V1 Board
• 2x 5mm LED
• 2x 200 Ohm risistor
• Breadboard
• Mga wire ng jumper

Eskematiko
Magsimula sa pamamagitan ng pagbuo ng circuit. Ikonekta ang dalawang LED sa ESP32 tulad ng ipinapakita sa sumusunod na schematic diagram - isang LED na konektado sa GPIO 26, at ang isa sa GPIO 27.
Tandaan: Ginagamit namin ang ESP32 DEVKIT DOIT board na may 36 na pin. Bago i-assemble ang circuit, siguraduhing suriin mo ang pinout para sa board na iyong ginagamit.Code
Dito ibinibigay namin ang code na lumilikha ng ESP32 web server. Buksan ang code Project_5_ESP32_Switch _Web_Server.ino sa arduino IDE, ngunit huwag mo pa itong i-upload. Kailangan mong gumawa ng ilang pagbabago para magawa ito para sa iyo.
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDE
Pagtatakda ng Iyong Mga Kredensyal sa Network
Kailangan mong baguhin ang mga sumusunod na linya gamit ang iyong mga kredensyal sa network: SSID at password. Ang code ay mahusay na nagkomento sa kung saan mo dapat gawin ang mga pagbabago.Pag-upload ng Code
Ngayon, maaari mong i-upload ang code at at ang web gagana kaagad ang server.
Sundin ang mga susunod na hakbang upang mag-upload ng code sa ESP32:

1. Isaksak ang iyong ESP32 board sa iyong computer;
2. Sa Arduino IDE piliin ang iyong board sa Tools > Board (sa aming kaso ginagamit namin ang ESP32 DEVKIT DOIT board);
3. Piliin ang COM port sa Tools > Port.
4. Pindutin ang button na Upload sa Arduino IDE at maghintay ng ilang segundo habang ang code ay nag-compile at nag-a-upload sa iyong board.
5. Hintayin ang mensaheng “Tapos na sa pag-upload.”

Paghahanap ng ESP IP Address
Pagkatapos i-upload ang code, buksan ang Serial Monitor sa baud rate na 115200.Pindutin ang ESP32 EN button (i-reset). Ang ESP32 ay kumokonekta sa Wi-Fi, at naglalabas ng ESP IP address sa Serial Monitor. Kopyahin ang IP address na iyon, dahil kailangan mo ito upang ma-access ang ESP32 web server.Pag-access sa Web server
Upang ma-access ang web server, buksan ang iyong browser, i-paste ang ESP32 IP address, at makikita mo ang sumusunod na pahina.
Tandaan: Ang iyong browser at ESP32 ay dapat na konektado sa parehong LAN.Kung titingnan mo ang Serial Monitor, makikita mo kung ano ang nangyayari sa background. Ang ESP ay tumatanggap ng HTTP na kahilingan mula sa isang bagong kliyente (sa kasong ito, ang iyong browser).Maaari mo ring makita ang iba pang impormasyon tungkol sa kahilingan sa HTTP.
Pagpapakita
Ngayon ay maaari mong subukan kung ang iyong web gumagana nang maayos ang server. I-click ang mga pindutan upang kontrolin ang mga LED.Kasabay nito, maaari mong tingnan ang Serial Monitor upang makita kung ano ang nangyayari sa background. Para kay example, kapag na-click mo ang button para i-ON ang GPIO 26, makakatanggap ang ESP32 ng kahilingan sa /26/on URL.Kapag natanggap ng ESP32 ang kahilingang iyon, ini-ON nito ang LED na nakakabit sa GPIO 26 at ina-update ang estado nito sa web pahina.Ang pindutan para sa GPIO 27 ay gumagana sa katulad na paraan. Subukan kung ito ay gumagana nang maayos.

Paano Gumagana ang Code

Sa seksyong ito ay titingnan ang code upang makita kung paano ito gumagana.
Ang unang bagay na kailangan mong gawin ay isama ang WiFi library.Gaya ng nabanggit dati, kailangan mong ipasok ang iyong ssid at password sa mga sumusunod na linya sa loob ng double quotes.Pagkatapos, itakda mo ang iyong web server sa port 80.Ang sumusunod na linya ay lumilikha ng isang variable upang iimbak ang header ng kahilingan sa HTTP:Susunod, lumikha ka ng mga auxiliar na variable upang iimbak ang kasalukuyang estado ng iyong mga output. Kung gusto mong magdagdag ng higit pang mga output at i-save ang estado nito, kailangan mong lumikha ng higit pang mga variable.Kailangan mo ring magtalaga ng GPIO sa bawat isa sa iyong mga output. Dito ginagamit namin ang GPIO 26 at GPIO 27. Maaari kang gumamit ng anumang iba pang angkop na GPIO.setup()
Ngayon, pumunta tayo sa setup(). Una, magsisimula kami ng serial communication sa baud rate na 115200 para sa mga layunin ng pag-debug.Tinukoy mo rin ang iyong mga GPIO bilang mga OUTPUT at itinakda ang mga ito sa LOW.Ang mga sumusunod na linya ay nagsisimula sa koneksyon ng Wi-Fi gamit ang WiFi.begin(ssid, password), maghintay para sa isang matagumpay na koneksyon at i-print ang ESP IP address sa Serial Monitor.loop()
Sa loop() pino-program namin kung ano ang mangyayari kapag ang isang bagong kliyente ay nagtatatag ng koneksyon sa web server.
Ang ESP32 ay palaging nakikinig para sa mga papasok na kliyente na may sumusunod na linya:Kapag natanggap ang isang kahilingan mula sa isang kliyente, ise-save namin ang papasok na data. Ang while loop na kasunod ay tatakbo hangga't ang kliyente ay mananatiling konektado. Hindi namin inirerekumenda na baguhin ang sumusunod na bahagi ng code maliban kung alam mo nang eksakto kung ano ang iyong ginagawa.Sinusuri ng susunod na seksyon ng if and else statement kung aling button ang pinindot sa iyong web pahina, at kinokontrol ang mga output nang naaayon. Gaya ng nakita namin dati, humihiling kami sa iba URLs depende sa pindutan na pinindot.Para kay example, kung pinindot mo ang GPIO 26 ON button, ang ESP32 ay makakatanggap ng kahilingan sa /26/ON URL (makikita natin na ang impormasyong iyon sa header ng HTTP sa Serial Monitor). Kaya, maaari nating suriin kung ang header ay naglalaman ng expression na GET /26/on. Kung naglalaman ito, babaguhin namin ang output26state variable sa ON, at i-on ng ESP32 ang LED.
Ito ay gumagana nang katulad para sa iba pang mga pindutan. Kaya, kung gusto mong magdagdag ng higit pang mga output, dapat mong baguhin ang bahaging ito ng code upang maisama ang mga ito.
Ipinapakita ang HTML web pahina
Ang susunod na bagay na kailangan mong gawin, ay ang paglikha ng web pahina. Ang ESP32 ay magpapadala ng tugon sa iyong browser na may ilang HTML code upang mabuo ang web pahina.
Ang web Ang pahina ay ipinadala sa kliyente gamit ang pagpapahayag ng client na ito.println(). Dapat mong ipasok ang gusto mong ipadala sa kliyente bilang argumento.
Ang unang bagay na dapat naming ipadala ay palaging ang sumusunod na linya, na nagpapahiwatig na kami ay nagpapadala ng HTML.Pagkatapos, ang sumusunod na linya ay gumagawa ng web tumutugon ang pahina sa anumang web browser.At ang sumusunod ay ginagamit upang maiwasan ang mga kahilingan sa favicon. – Hindi mo kailangang mag-alala tungkol sa linyang ito.

Pag-istilo ng Web Pahina

Susunod, mayroon kaming ilang CSS na teksto upang i-istilo ang mga pindutan at ang web hitsura ng pahina.
Pinipili namin ang font ng Helvetica, tinutukoy ang nilalaman na ipapakita bilang isang bloke at nakahanay sa gitna.Ini-istilo namin ang aming mga button gamit ang kulay na #4CAF50, walang hangganan, puting kulay, at may ganitong padding: 16px 40px. Itinakda rin namin ang text-decoration sa wala, tukuyin ang laki ng font, margin, at ang cursor sa isang pointer.Tinutukoy din namin ang istilo para sa pangalawang button, kasama ang lahat ng katangian ng button na tinukoy namin kanina, ngunit may ibang kulay. Ito ang magiging istilo para sa off button.

Pagtatakda ng Web Unang Pamagat ng Pahina
Sa susunod na linya maaari mong itakda ang unang heading ng iyong web pahina. Narito mayroon kaming "ESP32 Web Server", ngunit maaari mong baguhin ang tekstong ito sa anumang gusto mo.Pagpapakita ng Mga Pindutan at Kaukulang Estado
Pagkatapos, sumulat ka ng isang talata upang ipakita ang kasalukuyang estado ng GPIO 26. Tulad ng nakikita mo, ginagamit namin ang variable na output26State, upang agad na mag-update ang estado kapag nagbago ang variable na ito.Pagkatapos, ipinapakita namin ang on o ang off na button, depende sa kasalukuyang estado ng GPIO. Kung ang kasalukuyang estado ng GPIO ay naka-off, ipinapakita namin ang ON button, kung hindi, ipinapakita namin ang OFF button.Ginagamit namin ang parehong pamamaraan para sa GPIO 27.
Pagsara ng Koneksyon
Sa wakas, kapag natapos na ang tugon, iki-clear namin ang variable ng header, at ihihinto ang koneksyon sa client gamit ang client.stop().

Pagbabalot

Sa tutorial na ito ipinakita namin sa iyo kung paano bumuo ng isang web server na may ESP32. Nagpakita kami sa iyo ng isang simpleng exampna kumokontrol sa dalawang LED, ngunit ang ideya ay palitan ang mga LED na iyon ng relay, o anumang iba pang output na gusto mong kontrolin.

Project 6 RGB LED Web server

Sa proyektong ito ipapakita namin sa iyo kung paano malayuang kontrolin ang isang RGB LED na may ESP32 board gamit ang isang web server na may tagapili ng kulay.
Tapos na ang Projectview
Bago magsimula, tingnan natin kung paano gumagana ang proyektong ito:

• Ang ESP32 web nagpapakita ang server ng color picker.
• Kapag pumili ka ng isang kulay, humihiling ang iyong browser sa a URL na naglalaman ng mga parameter ng R, G, at B ng napiling kulay.
• Natatanggap ng iyong ESP32 ang kahilingan at hinahati ang halaga para sa bawat parameter ng kulay.
• Pagkatapos, nagpapadala ito ng PWM signal na may katumbas na halaga sa mga GPIO na kumokontrol sa RGB LED.

Paano gumagana ang RGB LEDs?
Sa isang karaniwang cathode RGB LED, lahat ng tatlong LED ay may negatibong koneksyon (cathode). Lahat ng kasama sa kit ay common-cathode RGB.Paano lumikha ng iba't ibang kulay?
Sa isang RGB LED, maaari kang, siyempre, gumawa ng pula, berde, at asul na ilaw, at sa pamamagitan ng pag-configure sa intensity ng bawat LED, makakagawa ka rin ng iba pang mga kulay.
Para kay exampAt, para makagawa ng puro asul na liwanag, itatakda mo ang asul na LED sa pinakamataas na intensity at ang berde at pulang LED sa pinakamababang intensity. Para sa isang puting ilaw, itatakda mo ang lahat ng tatlong LED sa pinakamataas na intensity.
Paghahalo ng mga kulay
Upang makagawa ng iba pang mga kulay, maaari mong pagsamahin ang tatlong kulay sa iba't ibang intensity. Upang ayusin ang intensity ng bawat LED maaari kang gumamit ng PWM signal.
Dahil ang mga LED ay napakalapit sa isa't isa, nakikita ng ating mga mata ang resulta ng kumbinasyon ng mga kulay, sa halip na ang tatlong kulay nang paisa-isa.
Upang magkaroon ng ideya kung paano pagsamahin ang mga kulay, tingnan ang sumusunod na tsart.
Ito ang pinakasimpleng tsart ng paghahalo ng kulay, ngunit nagbibigay sa iyo ng ideya kung paano ito gumagana at kung paano gumawa ng iba't ibang kulay.Mga Bahaging Kinakailangan
Para sa proyektong ito kailangan mo ang mga sumusunod na bahagi:

• ESP32 DEVKIT V1 Board
• RGB LED
• 3x 220 ohm resistors
• Mga wire ng jumper
• Breadboard

EskematikoCode
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)

• Pag-install ng ESP32 Add-on sa Arduino IDE

Pagkatapos i-assemble ang circuit, Buksan ang code
Project_6_RGB_LED_Web_Server.ino sa arduino IDE.
Bago i-upload ang code, huwag kalimutang ipasok ang iyong mga kredensyal sa network upang ang ESP ay makakonekta sa iyong lokal na network.Paano gumagana ang code
Ang ESP32 sketch ay gumagamit ng WiFi.h library.Tinutukoy ng mga sumusunod na linya ang mga variable ng string upang hawakan ang mga parameter ng R, G, at B mula sa kahilingan.Ang susunod na apat na variable ay ginagamit upang i-decode ang kahilingan ng HTTP sa ibang pagkakataon.Gumawa ng tatlong variable para sa mga GPIO na kumokontrol sa strip R, G, at B na mga parameter. Sa kasong ito, ginagamit namin ang GPIO 13, GPIO 12, at GPIO 14.Ang mga GPIO na ito ay kailangang mag-output ng mga signal ng PWM, kaya kailangan muna nating i-configure ang mga katangian ng PWM. Itakda ang PWM signal frequency sa 5000 Hz. Pagkatapos, iugnay ang isang PWM channel para sa bawat kulayAt sa wakas, itakda ang resolution ng PWM channels sa 8-bitSa setup(), italaga ang mga katangian ng PWM sa mga channel ng PWMIlakip ang mga PWM channel sa mga kaukulang GPIOAng sumusunod na seksyon ng code ay nagpapakita ng tagapili ng kulay sa iyong web page at gumawa ng kahilingan batay sa kulay na iyong pinili.Kapag pumili ka ng isang kulay, makakatanggap ka ng isang kahilingan na may sumusunod na format.

Kaya, kailangan nating hatiin ang string na ito upang makuha ang mga parameter ng R, G, at B. Ang mga parameter ay naka-save sa redString, greenString, at blueString na mga variable at maaaring magkaroon ng mga halaga sa pagitan ng 0 at 255.Upang kontrolin ang strip gamit ang ESP32, gamitin ang ledcWrite() function upang bumuo ng mga PWM signal na may mga value na na-decode mula sa HTTP kahilingan.Tandaan: matuto nang higit pa tungkol sa PWM na may ESP32: Project 3 ESP32 PWM(Analog Output)
Para makontrol ang strip gamit ang ESP8266, kailangan lang nating gamitin
ang analogWrite() function upang makabuo ng mga PWM signal na may mga value na na-decode mula sa kahilingan ng HTPP.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
Dahil nakukuha namin ang mga value sa isang string variable, kailangan naming i-convert ang mga ito sa mga integer gamit ang toInt() method.
Pagpapakita
Pagkatapos ipasok ang iyong mga kredensyal sa network, piliin ang tamang board at COM port at i-upload ang code sa iyong ESP32. Mag-upload ng mga hakbang sa sanggunian ng code.
Pagkatapos mag-upload, buksan ang Serial Monitor sa baud rate na 115200 at pindutin ang ESP Enable/Reset button. Dapat mong makuha ang board IP address.Buksan ang iyong browser at ipasok ang ESP IP address. Ngayon, gamitin ang color picker para pumili ng kulay para sa RGB LED.
Pagkatapos, kailangan mong pindutin ang button na "Baguhin ang Kulay" para magkabisa ang kulay.Upang i-off ang RGB LED , piliin ang itim na kulay.
Ang pinakamalakas na kulay (sa tuktok ng tagapili ng kulay), ay ang mga magbubunga ng mas magagandang resulta.

Project 7 ESP32 Relay Web server

Ang paggamit ng relay na may ESP32 ay isang mahusay na paraan upang kontrolin ang mga gamit sa sambahayan ng AC nang malayuan. Ipinapaliwanag ng tutorial na ito kung paano kontrolin ang isang relay module gamit ang ESP32.
Titingnan natin kung paano gumagana ang isang relay module, kung paano ikonekta ang relay sa ESP32 at bumuo ng isang web server upang kontrolin ang isang relay nang malayuan.
Pagpapakilala ng mga Relay
Ang relay ay isang electrically operated switch at tulad ng ibang switch, ito ay maaaring i-on o i-off, hayaan ang kasalukuyang dumaan o hindi. Maaari itong kontrolin sa mababang voltages, tulad ng 3.3V na ibinigay ng mga ESP32 GPIO at nagbibigay-daan sa amin na kontrolin ang mataas na voltagay tulad ng 12V, 24V o mains voltage (230V sa Europe at 120V sa US).Sa kaliwang bahagi, mayroong dalawang set ng tatlong socket upang kumonekta sa mataas na voltages, at ang mga pin sa kanang bahagi (low-voltage) kumonekta sa mga ESP32 GPIO.
Mains Voltage Mga KoneksyonAng relay module na ipinakita sa nakaraang larawan ay may dalawang connector, bawat isa ay may tatlong socket: common (COM), Normally Closed (NC), at Normally Open (NO).

• COM: ikonekta ang kasalukuyang nais mong kontrolin (mains voltagat).
• NC (Normally Closed): ang normally closed configuration ay ginagamit kapag gusto mong isara ang relay bilang default. Ang NC ay COM pins ay konektado, ibig sabihin ang kasalukuyang ay dumadaloy maliban kung magpadala ka ng signal mula sa ESP32 sa relay module upang buksan ang circuit at itigil ang kasalukuyang daloy.
• HINDI (Normally Open): ang normally open na configuration ay gumagana sa kabaligtaran: walang koneksyon sa pagitan ng NO at COM pin, kaya nasira ang circuit maliban kung magpadala ka ng signal mula sa ESP32 para isara ang circuit.

Kontrolin ang mga PinsAng low-voltage side ay may isang set ng apat na pin at isang set ng tatlong pin. Ang unang set ay binubuo ng VCC at GND para paganahin ang module, at input 1 (IN1) at input 2 (IN2) upang kontrolin ang mga relay sa ibaba at itaas, ayon sa pagkakabanggit.
Kung ang iyong relay module ay may isang channel lang, magkakaroon ka lang ng isang IN pin. Kung mayroon kang apat na channel, magkakaroon ka ng apat na IN pin, at iba pa.
Ang signal na ipinadala mo sa mga IN pin, ay tumutukoy kung ang relay ay aktibo o hindi. Ang relay ay na-trigger kapag ang input ay bumaba ng humigit-kumulang 2V. Nangangahulugan ito na magkakaroon ka ng mga sumusunod na sitwasyon:

• Karaniwang Sarado na pagsasaayos (NC):
• HIGH signal – dumadaloy ang kasalukuyang
• MABABANG signal – hindi dumadaloy ang kasalukuyang
• Karaniwang Buksan ang configuration (NO):
• HIGH signal – hindi dumadaloy ang kasalukuyang
• MABABANG signal – kasalukuyang dumadaloy

Dapat kang gumamit ng isang karaniwang saradong configuration kapag ang kasalukuyang ay dapat na dumadaloy sa karamihan ng mga oras, at gusto mo lamang itong ihinto paminsan-minsan.
Gumamit ng isang karaniwang bukas na pagsasaayos kapag gusto mong dumaloy ang kasalukuyang paminsan-minsan (para sa halample, i-on ang alamp paminsan-minsan).
Pagpili ng Power SupplyAng pangalawang hanay ng mga pin ay binubuo ng GND, VCC, at JD-VCC pin.
Pinapatakbo ng JD-VCC pin ang electromagnet ng relay. Pansinin na ang module ay may jumper cap na kumukonekta sa VCC at JD-VCC pin; ang ipinapakita dito ay dilaw, ngunit ang sa iyo ay maaaring ibang kulay.
Kapag naka-on ang jumper cap, nakakonekta ang VCC at JD-VCC pin. Nangangahulugan iyon na ang relay electromagnet ay direktang pinapagana mula sa ESP32 power pin, kaya ang relay module at ang ESP32 circuit ay hindi pisikal na nakahiwalay sa isa't isa.
Kung wala ang takip ng jumper, kailangan mong magbigay ng independiyenteng pinagmumulan ng kuryente upang palakasin ang electromagnet ng relay sa pamamagitan ng JD-VCC pin. Pisikal na inihihiwalay ng configuration na iyon ang mga relay mula sa ESP32 gamit ang built-in na optocoupler ng module, na pumipigil sa pagkasira ng ESP32 sa kaso ng mga electrical spike.
EskematikoBabala: Paggamit ng mataas na voltage maaaring magdulot ng malubhang pinsala ang mga supply ng kuryente.
Samakatuwid, 5mm LEDs ang ginagamit sa halip na mataas na supply voltage bumbilya sa eksperimento. Kung hindi ka pamilyar sa mains voltagtanungin mo ang isang tao na tutulong sa iyo. Habang nagprograma ng ESP o mga kable sa iyong circuit siguraduhin na ang lahat ay hindi nakakonekta sa mains voltage.Pag-install ng Library para sa ESP32
Upang maitayo ito web server, ginagamit namin ang ESPAsyncWebServer library at AsyncTCP Library.
Pag-install ng ESPAsyncWebLibrary ng server
Sundin ang mga susunod na hakbang upang i-install ang ESPAsyncWebserver aklatan:

1. Mag-click dito upang i-download ang ESPAsyncWebLibrary ng server. Dapat mayroon ka
   isang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip folder at dapat kang makakuha ng ESPAsyncWebServer-master folder
3. Palitan ang pangalan ng iyong folder mula sa ESPAsyncWebServer-master sa ESPAsyncWebserver
4. Ilipat ang ESPAsyncWebServer folder sa iyong Arduino IDE installation library folder

Bilang kahalili, sa iyong Arduino IDE, maaari kang pumunta sa Sketch > Isama
Library > Magdagdag ng .ZIP library... at piliin ang library na kaka-download mo lang.
Pag-install ng AsyncTCP Library para sa ESP32
Ang ESPAsyncWebserver ang aklatan ay nangangailangan ng AsyncTCP library para magtrabaho. Sundin
ang mga susunod na hakbang para i-install ang library na iyon:

1. Mag-click dito upang i-download ang library ng AsyncTCP. Dapat ay mayroon kang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip na folder at dapat kang makakuha ng AsyncTCP-master folder
   1. Palitan ang pangalan ng iyong folder mula sa AsyncTCP-master patungong AsyncTCP
   3. Ilipat ang AsyncTCP folder sa iyong Arduino IDE installation library folder
   4. Sa wakas, muling buksan ang iyong Arduino IDE

Bilang kahalili, sa iyong Arduino IDE, maaari kang pumunta sa Sketch > Isama
Library > Magdagdag ng .ZIP library... at piliin ang library na kaka-download mo lang.
Code
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDE
Pagkatapos i-install ang mga kinakailangang aklatan, Buksan ang code Project_7_ESP32_Relay_Web_Server.ino sa arduino IDE.
Bago i-upload ang code, huwag kalimutang ipasok ang iyong mga kredensyal sa network upang ang ESP ay makakonekta sa iyong lokal na network.Pagpapakita
Pagkatapos gawin ang mga kinakailangang pagbabago, i-upload ang code sa iyong ESP32. I-upload ang mga hakbang sa sanggunian ng code.
Buksan ang Serial Monitor sa baud rate na 115200 at pindutin ang ESP32 EN button para makuha ang IP address nito. Pagkatapos, magbukas ng browser sa iyong lokal na network at i-type ang ESP32 IP address para makakuha ng access sa web server.
Buksan ang Serial Monitor sa baud rate na 115200 at pindutin ang ESP32 EN button para makuha ang IP address nito. Pagkatapos, magbukas ng browser sa iyong lokal na network at i-type ang ESP32 IP address para makakuha ng access sa web server.Tandaan: Ang iyong browser at ESP32 ay dapat na konektado sa parehong LAN.
Dapat kang makakuha ng isang bagay tulad ng sumusunod na may bilang ng dalawang mga pindutan bilang ang bilang ng mga relay na iyong tinukoy sa iyong code.Ngayon, maaari mong gamitin ang mga pindutan upang kontrolin ang iyong mga relay gamit ang iyong smartphone.

Project_8_Output_State_Synchronization_ Web_Server

Ipinapakita ng Proyektong ito kung paano kontrolin ang mga output ng ESP32 o ESP8266 gamit ang a web server at isang pisikal na pindutan nang sabay-sabay. Ang estado ng output ay ina-update sa web pahina kung ito ay binago sa pamamagitan ng pisikal na pindutan o web server.
Tapos na ang Projectview
Tingnan natin kung paano gumagana ang proyekto.Ang ESP32 o ESP8266 ay nagho-host ng a web server na nagpapahintulot sa iyo na kontrolin ang estado ng isang output;

• Ang kasalukuyang estado ng output ay ipinapakita sa web server;
• Ang ESP ay konektado din sa isang pisikal na pushbutton na kumokontrol sa parehong output;
• Kung babaguhin mo ang estado ng output gamit ang pisikal na puhsbutton, ang kasalukuyang estado nito ay ina-update din sa web server.

Sa buod, pinapayagan ka ng proyektong ito na kontrolin ang parehong output gamit ang a web server at isang push button nang sabay-sabay. Sa tuwing nagbabago ang estado ng output, ang web na-update ang server.
Mga Bahaging Kinakailangan
Narito ang isang listahan ng mga bahagi na kailangan mo upang bumuo ng circuit:

• ESP32 DEVKIT V1 Board
• 5 mm na LED
• 220Ohm risistor
• Pushbutton
• 10k Ohm risistor
• Breadboard
• Mga wire ng jumper

EskematikoPag-install ng Library para sa ESP32
Upang maitayo ito web server, ginagamit namin ang ESPAsyncWebServer library at AsyncTCP Library.(Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESPAsyncWebLibrary ng server
Sundin ang mga susunod na hakbang para i-install ang ESPAsyncWebLibrary ng server:

1. Mag-click dito upang i-download ang ESPAsyncWebLibrary ng server. Dapat mayroon ka
   isang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip folder at dapat kang makakuha ng ESPAsyncWebServer-master folder
3. Palitan ang pangalan ng iyong folder mula sa ESPAsyncWebServer-master sa ESPAsyncWebserver
4. Ilipat ang ESPAsyncWebServer folder sa iyong Arduino IDE installation library folder
   Bilang kahalili, sa iyong Arduino IDE, maaari kang pumunta sa Sketch > Isama
   Library > Magdagdag ng .ZIP library... at piliin ang library na kaka-download mo lang.

Pag-install ng AsyncTCP Library para sa ESP32
Ang ESPAsyncWebKinakailangan ng library ng server na gumana ang library ng AsyncTCP. Sundin ang mga susunod na hakbang para i-install ang library na iyon:

1. Mag-click dito upang i-download ang library ng AsyncTCP. Dapat ay mayroon kang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip na folder at dapat kang makakuha ng AsyncTCP-master folder
3. Palitan ang pangalan ng iyong folder mula sa AsyncTCP-master patungong AsyncTCP
4. Ilipat ang AsyncTCP folder sa iyong Arduino IDE installation library folder
5. Sa wakas, muling buksan ang iyong Arduino IDE
   Bilang kahalili, sa iyong Arduino IDE, maaari kang pumunta sa Sketch > Isama
   Library > Magdagdag ng .ZIP library... at piliin ang library na kaka-download mo lang.

Code
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDE
Pagkatapos i-install ang mga kinakailangang aklatan, Buksan ang code
Project_8_Output_State_Synchronization_Web_Server.ino sa arduino IDE.
Bago i-upload ang code, huwag kalimutang ipasok ang iyong mga kredensyal sa network upang ang ESP ay makakonekta sa iyong lokal na network.

Paano Gumagana ang Code

Estado ng Pindutan at Estado ng Output
Ang ledState variable ay nagtataglay ng LED output state. Para sa default, kapag ang web magsisimula ang server, ito ay LOW.

Ang buttonState at lastButtonState ay ginagamit upang makita kung ang pushbutton ay pinindot o hindi.Pindutan (web server)
Hindi namin isinama ang HTML para gawin ang button sa index_html variable.
Iyon ay dahil gusto naming mapalitan ito depende sa kasalukuyang estado ng LED na maaari ding baguhin gamit ang pushbutton.
Kaya, gumawa kami ng placeholder para sa button na %BUTTONPLACEHOLDER% na papalitan ng HTML na text para gawin ang button sa paglaon sa code (ito ay ginagawa sa processor() function).processor()
Pinapalitan ng function na processor() ang anumang mga placeholder sa HTML na teksto ng mga aktwal na halaga. Una, sinusuri nito kung naglalaman ang mga HTML na teksto ng anuman
mga placeholder %BUTTONPLACEHOLDER%.Pagkatapos, tawagan ang theoutputState() function na nagbabalik ng kasalukuyang output state. Ise-save namin ito sa outputStateValue variable.Pagkatapos nito, gamitin ang halagang iyon upang lumikha ng HTML na teksto upang ipakita ang pindutan na may tamang estado:HTTP GET Request to Change Output State (JavaScript)
Kapag pinindot mo ang button, tinatawag ang toggleCheckbox() function. Ang function na ito ay gagawa ng isang kahilingan sa iba't ibang URLs upang i-on o i-off ang LED.Upang i-on ang LED, humihiling ito sa /update?state=1 URL:Kung hindi, humihiling ito sa /update?state=0 URL.
HTTP GET Request to Update State (JavaScript)
Upang panatilihing na-update ang estado ng output sa web server, tinatawag namin ang sumusunod na function na gumagawa ng bagong kahilingan sa /state URL bawat segundo.Pangasiwaan ang mga Kahilingan
Pagkatapos, kailangan nating pangasiwaan kung ano ang mangyayari kapag nakatanggap ang ESP32 o ESP8266 ng mga kahilingan sa mga iyon. URLs.
Kapag natanggap ang isang kahilingan sa ugat /URL, ipinapadala namin ang HTML page pati na rin ang processor.Tinitingnan ng mga sumusunod na linya kung nakatanggap ka ng kahilingan sa /update?state=1 o /update?state=0 URL at binabago ang ledState nang naaayon.Kapag natanggap ang isang kahilingan sa /state URL, ipinapadala namin ang kasalukuyang estado ng output:loop()
Sa loop(), i-debounce namin ang pushbutton at i-on o i-off ang LED depende sa halaga ng ledState variable.Pagpapakita
I-upload ang code sa iyong ESP32 board. I-upload ang mga hakbang sa sanggunian ng code.
Pagkatapos, buksan ang Serial Monitor sa baud rate na 115200. Pindutin ang on-board na EN/RST na button para makuha ang IP address.Magbukas ng browser sa iyong lokal na network, at i-type ang ESP IP address. Dapat kang magkaroon ng access sa web server tulad ng ipinapakita sa ibaba.
Tandaan: Ang iyong browser at ESP32 ay dapat na konektado sa parehong LAN.Maaari mong i-toggle ang button sa web server upang i-on ang LED.Maaari mo ring kontrolin ang parehong LED gamit ang pisikal na pushbutton. Ang estado nito ay palaging awtomatikong maa-update sa web server.

Project 9 ESP32 DHT11 Web server

Sa proyektong ito, matututunan mo kung paano bumuo ng isang asynchronous na ESP32 web server na may DHT11 na nagpapakita ng temperatura at halumigmig gamit ang Arduino IDE.
Mga kinakailangan
Ang web server, awtomatiko kaming bubuo ng mga update sa mga pagbabasa nang hindi na kailangang i-refresh ang web pahina.
Sa proyektong ito matututunan mo ang:

• Paano basahin ang temperatura at halumigmig mula sa mga sensor ng DHT;
• Bumuo ng asynchronous web server gamit ang ESPAsyncWebLibrary ng server;
• Awtomatikong i-update ang mga pagbabasa ng sensor nang hindi kailangang i-refresh ang web pahina.

Asynchronous Web server
Upang maitayo ang web server na gagamitin namin ang ESPAsyncWebLibrary ng server na nagbibigay ng madaling paraan upang bumuo ng isang asynchronous web server. Pagbuo ng isang asynchronous web may ilang advan ang servertages tulad ng nabanggit sa pahina ng GitHub ng library, tulad ng:

• "Hasiwaan ang higit sa isang koneksyon sa parehong oras";
• "Kapag ipinadala mo ang tugon, handa ka kaagad na pangasiwaan ang iba pang mga koneksyon habang inaasikaso ng server ang pagpapadala ng tugon sa background";
• "Simple template processing engine upang mahawakan ang mga template";

Mga Bahaging Kinakailangan
Upang makumpleto ang tutorial na ito kailangan mo ang mga sumusunod na bahagi:

• ESP32 development board
• Module ng DHT11
• Breadboard
• Mga wire ng jumper

EskematikoPag-install ng mga Aklatan
Kailangan mong mag-install ng ilang library para sa proyektong ito:

• Ang DHT at ang Adafruit Unified Sensor Mga aklatan ng driver na babasahin mula sa sensor ng DHT.
• ESPAsyncWebserver at Async TCP mga aklatan upang bumuo ng asynchronous web server.
  Sundin ang mga susunod na tagubilin para i-install ang mga library na iyon:

Pag-install ng DHT Sensor Library
Upang basahin mula sa DHT sensor gamit ang Arduino IDE, kailangan mong i-install ang DHT sensor library. Sundin ang mga susunod na hakbang para i-install ang library.

1. Mag-click dito upang i-download ang DHT Sensor library. Dapat ay mayroon kang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip folder at dapat kang makakuha ng DHT-sensor-library-master folder
3. Palitan ang pangalan ng iyong folder mula sa DHT-sensor-library-master sa DHT_sensor
4. Ilipat ang DHT_sensor folder sa iyong Arduino IDE installation library folder
5. Sa wakas, muling buksan ang iyong Arduino IDE

Pag-install ng Adafruit Unified Sensor Driver
Kailangan mo ring i-install ang Adafruit Unified Sensor Driver library upang gumana sa sensor ng DHT. Sundin ang mga susunod na hakbang para i-install ang library.

1. Mag-click dito upang i-download ang library ng Adafruit Unified Sensor. Dapat ay mayroon kang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip folder at dapat kang makakuha ng Adafruit_sensor-master folder
3. Palitan ang pangalan ng iyong folder mula sa Adafruit_sensor-master sa Adafruit_sensor
4. Ilipat ang folder na Adafruit_sensor sa iyong Arduino IDE installation library folder
5. Sa wakas, muling buksan ang iyong Arduino IDE

Pag-install ng ESPAsyncWebLibrary ng server

Sundin ang mga susunod na hakbang upang i-install ang ESPAsyncWebserver aklatan:

1. Mag-click dito upang i-download ang ESPAsyncWebLibrary ng server. Dapat mayroon ka
   isang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip folder at dapat
   kumuha ng ESPAsyncWebServer-master folder
3. Palitan ang pangalan ng iyong folder mula sa ESPAsyncWebServer-master sa ESPAsyncWebserver
4. Ilipat ang ESPAsyncWebServer folder sa iyong Arduino IDE installation library folder

Pag-install ng Async TCP Library para sa ESP32
Ang ESPAsyncWebserver ang aklatan ay nangangailangan ng AsyncTCP library para magtrabaho. Sundin ang mga susunod na hakbang para i-install ang library na iyon:

1. Mag-click dito upang i-download ang library ng AsyncTCP. Dapat ay mayroon kang .zip folder sa iyong Downloads folder
2. I-unzip ang .zip na folder at dapat kang makakuha ng AsyncTCP-master folder
3. Palitan ang pangalan ng iyong folder mula sa AsyncTCP-master patungong AsyncTCP
4. Ilipat ang AsyncTCP folder sa iyong Arduino IDE installation library folder
5. Sa wakas, muling buksan ang iyong Arduino IDE

Code
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDE
Pagkatapos i-install ang mga kinakailangang aklatan, Buksan ang code
Project_9_ESP32_DHT11_Web_Server.ino sa arduino IDE.
Bago i-upload ang code, huwag kalimutang ipasok ang iyong mga kredensyal sa network upang ang ESP ay makakonekta sa iyong lokal na network.Paano Gumagana ang Code
Sa mga sumusunod na talata ipapaliwanag namin kung paano gumagana ang code. Panatilihin ang pagbabasa kung gusto mong matuto nang higit pa o pumunta sa seksyong Pagpapakita upang makita ang huling resulta.
Pag-import ng mga aklatan
Una, i-import ang mga kinakailangang aklatan. Ang WiFi, ESPAsyncWebAng server at ang ESPAsyncTCP ay kailangan para mabuo ang web server. Ang Adafruit_Sensor at ang mga aklatan ng DHT ay kailangan upang mabasa mula sa mga sensor ng DHT11 o DHT22.Kahulugan ng mga variable
Tukuyin ang GPIO kung saan nakakonekta ang DHT data pin. Sa kasong ito, ito ay konektado sa GPIO 4.Pagkatapos, piliin ang uri ng sensor ng DHT na iyong ginagamit. Sa ex natinample, ginagamit namin ang DHT22. Kung gumagamit ka ng ibang uri, kailangan mo lang i-uncomment ang iyong sensor at ikomento ang lahat ng iba pa.

Mag-instantiate ng isang DHT object gamit ang uri at pin na tinukoy namin kanina.Gumawa ng AsyncWebobject ng server sa port 80.Basahin ang Temperatura at Humidity Function
Gumawa kami ng dalawang function: isa para basahin ang temperatura Gumawa kami ng dalawang function: isa para basahin ang temperatura (readDHTTemperature()) at isa pa para basahin ang humidity (readDHTHumidity()).Ang pagkuha ng mga pagbabasa ng sensor ay kasing simple ng paggamit Ang pagkuha ng mga pagbabasa ng sensor ay kasing simple ng paggamit ng readTemperature() at readHumidity() na mga pamamaraan sa dht object.Mayroon din kaming kundisyon na nagbabalik ng dalawang gitling (–) kung sakaling hindi makuha ng sensor ang mga pagbabasa.Ang mga pagbabasa ay ibinalik bilang uri ng string. Upang i-convert ang float sa isang string, gamitin ang String() functionBilang default, binabasa namin ang temperatura sa Celsius degrees. Upang makuha ang temperatura sa Fahrenheit degrees, ikomento ang temperatura sa Celsius at alisin sa komento ang temperatura sa Fahrenheit, upang magkaroon ka ng sumusunod:I-upload ang Code
Ngayon, i-upload ang code sa iyong ESP32. Tiyaking napili mo ang tamang board at COM port. Mag-upload ng mga hakbang sa pagtukoy ng code.
Pagkatapos mag-upload, buksan ang Serial Monitor sa baud rate na 115200. Pindutin ang ESP32 reset button. Ang ESP32 IP address ay dapat na naka-print sa serial subaybayan.Pagpapakita
Magbukas ng browser at i-type ang ESP32 IP address. Iyong web dapat ipakita ng server ang pinakabagong mga pagbabasa ng sensor.
Tandaan: Ang iyong browser at ESP32 ay dapat na konektado sa parehong LAN.
Pansinin na ang temperatura at halumigmig na pagbabasa ay awtomatikong ina-update nang hindi na kailangang i-refresh ang web pahina.

Project_10_ESP32_OLED_Display

Ipinapakita ng proyektong ito kung paano gamitin ang 0.96 inch SSD1306 OLED display na may ESP32 gamit ang Arduino IDE.
Ipinapakilala ang 0.96 pulgadang OLED Display
Ang OLED na display na gagamitin namin sa tutorial na ito ay ang SSD1306 model: isang monocolor, 0.96 inch na display na may 128×64 pixels gaya ng ipinapakita sa sumusunod na figure.Ang OLED display ay hindi nangangailangan ng backlight, na nagreresulta sa isang napakagandang contrast sa madilim na kapaligiran. Bukod pa rito, ang mga pixel nito ay kumokonsumo ng enerhiya lamang kapag sila ay naka-on, kaya ang OLED display ay kumokonsumo ng mas kaunting kapangyarihan kapag inihambing sa iba pang mga display.
Dahil ang OLED display ay gumagamit ng I2C communication protocol, ang mga wiring ay napakasimple. Maaari mong gamitin ang sumusunod na talahanayan bilang sanggunian.

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

EskematikoPag-install ng SSD1306 OLED Library - ESP32
Mayroong ilang mga aklatan na magagamit upang kontrolin ang OLED display gamit ang ESP32.
Sa tutorial na ito gagamitin namin ang dalawang library ng Adafruit: Adafruit_SSD1306 library at Adafruit_GFX library.
Sundin ang mga susunod na hakbang para i-install ang mga library na iyon.

1. Buksan ang iyong Arduino IDE at pumunta sa Sketch > Include Library > Manage Libraries. Dapat magbukas ang Library Manager.
2. I-type ang "SSD1306" sa box para sa paghahanap at i-install ang SSD1306 library mula sa Adafruit.
3. Pagkatapos i-install ang SSD1306 library mula sa Adafruit, i-type ang "GFX" sa box para sa paghahanap at i-install ang library.
4. Pagkatapos i-install ang mga aklatan, i-restart ang iyong Arduino IDE.

Code
Pagkatapos i-install ang mga kinakailangang aklatan, Buksan ang Project_10_ESP32_OLED_Display.ino sa arduino IDE. code
Ipo-program namin ang ESP32 gamit ang Arduino IDE, kaya siguraduhing mayroon kang ESP32 add-on na naka-install bago magpatuloy: (Kung nagawa mo na ang hakbang na ito, maaari kang lumaktaw sa susunod na hakbang.)
Pag-install ng ESP32 Add-on sa Arduino IDEPaano Gumagana ang Code
Pag-import ng mga aklatan
Una, kailangan mong i-import ang mga kinakailangang aklatan. Ang Wire library para gamitin ang I2C at ang Adafruit library para sumulat sa display: Adafruit_GFX at Adafruit_SSD1306.Simulan ang OLED display
Pagkatapos, tukuyin mo ang iyong lapad at taas ng OLED. Sa ex na itoampNgayon, gumagamit kami ng 128×64 OLED display. Kung gumagamit ka ng iba pang mga laki, maaari mong baguhin iyon sa mga variable na SCREEN_WIDTH, at SCREEN_HEIGHT.Pagkatapos, simulan ang isang display object na may lapad at taas na tinukoy nang mas maaga gamit ang I2C communication protocol (&Wire).Ang (-1) parameter ay nangangahulugan na ang iyong OLED display ay walang RESET pin. Kung ang iyong OLED display ay may RESET pin, dapat itong konektado sa isang GPIO. Sa kasong iyon, dapat mong ipasa ang numero ng GPIO bilang isang parameter.
Sa setup(), simulan ang Serial Monitor sa isang baud raute na 115200 para sa mga layunin ng pag-debug.Simulan ang OLED display gamit ang begin() na paraan tulad ng sumusunod:Ang snippet na ito ay nagpi-print din ng mensahe sa Serial Monitor, kung sakaling hindi kami makakonekta sa display.

Kung sakaling gumagamit ka ng ibang OLED display, maaaring kailanganin mong baguhin ang OLED address. Sa aming kaso, ang address ay 0x3C.Pagkatapos simulan ang display, magdagdag ng dalawang segundong pagkaantala, upang ang OLED ay magkaroon ng sapat na oras upang magsimula bago magsulat ng teksto:I-clear ang display, itakda ang laki ng font, kulay at magsulat ng teksto
Pagkatapos simulan ang display, i-clear ang display buffer gamit ang clearDisplay() method:

Bago magsulat ng text, kailangan mong itakda ang laki ng text, kulay at kung saan ipapakita ang text sa OLED.
Itakda ang laki ng font gamit ang setTextSize() na pamamaraan:Itakda ang kulay ng font gamit ang setTextColor() na pamamaraan:
Ang WHITE ay nagtatakda ng puting font at itim na background.
Tukuyin ang posisyon kung saan nagsisimula ang text gamit ang setCursor(x,y) method. Sa kasong ito, itinatakda namin ang teksto upang magsimula sa (0,0) mga coordinate – sa kaliwang sulok sa itaas.Sa wakas, maaari mong ipadala ang teksto sa display gamit ang println() na pamamaraan, tulad ng sumusunodPagkatapos, kailangan mong tawagan ang display() na paraan upang aktwal na ipakita ang teksto sa screen.

Ang Adafruit OLED library ay nagbibigay ng mga kapaki-pakinabang na pamamaraan para madaling mag-scroll ng text.

• startscrollright(0x00, 0x0F): mag-scroll ng text mula kaliwa pakanan
• startscrollleft(0x00, 0x0F): mag-scroll ng text mula kanan pakaliwa
• startscrolldiagright(0x00, 0x07): mag-scroll ng text mula sa kaliwa sa ibabang sulok hanggang sa kanang itaas na sulok startscrolldiagleft(0x00, 0x07): mag-scroll ng text mula sa kanang ibabang sulok hanggang sa kaliwang itaas na sulok

I-upload ang Code
Ngayon, i-upload ang code sa iyong ESP32. I-upload ang mga hakbang sa sanggunian ng code.
Pagkatapos i-upload ang code, ang OLED ay magpapakita ng scrolling text.

Mga Dokumento / Mga Mapagkukunan

LAFVIN ESP32 Basic Starter Kit [pdf] Manwal ng Pagtuturo ESP32 Basic Starter Kit, ESP32, Basic Starter Kit, Starter Kit

Mga sanggunian

• User Manual