ESP32 ძირითადი დამწყები
ნაკრები
შეფუთვის სია
ESP32 შესავალი
ახალია ESP32? დაიწყე აქედან! ESP32 არის ჩიპზე (SoC) მიკროკონტროლერების სერია, რომელიც შემუშავებულია Espressif-ის მიერ, რომელიც მოიცავს Wi-Fi და Bluetooth უკაბელო შესაძლებლობებს და ორბირთვიან პროცესორს. თუ თქვენ იცნობთ ESP8266-ს, ESP32 არის მისი მემკვიდრე, დატვირთული უამრავი ახალი ფუნქციით.
ESP32 სპეციფიკაციები
თუ გსურთ მიიღოთ ცოტა უფრო ტექნიკური და კონკრეტული, შეგიძლიათ გადახედოთ ESP32-ის შემდეგ დეტალურ სპეციფიკაციებს (წყარო: http://esp32.net/) - დამატებითი დეტალებისთვის, შეამოწმეთ მონაცემთა ფურცელი):
- უსადენო კავშირი WiFi: 150.0 Mbps მონაცემთა სიჩქარე HT40-ით
- Bluetooth: BLE (Bluetooth Low Energy) და Bluetooth Classic
- პროცესორი: Tensilica Xtensa Dual-Core 32-bit LX6 მიკროპროცესორი, მუშაობს 160 ან 240 MHz-ზე
- მეხსიერება:
- ROM: 448 KB (ჩატვირთვისა და ძირითადი ფუნქციებისთვის)
- SRAM: 520 KB (მონაცემებისა და ინსტრუქციებისთვის)
- RTC fas SRAM: 8 KB (მონაცემთა შესანახად და მთავარი CPU-სთვის RTC ჩატვირთვისას ღრმა ძილის რეჟიმიდან)
- RTC ნელი SRAM: 8KB (თანაპროცესორთან წვდომისთვის ღრმა ძილის რეჟიმში) eFuse: 1 Kbit (აქედან 256 ბიტი გამოიყენება სისტემისთვის (MAC მისამართი და ჩიპის კონფიგურაცია) და დარჩენილი 768 ბიტი დაცულია მომხმარებლის აპლიკაციებისთვის, მათ შორის Flash-შიფრაცია და Chip-ID)
ჩაშენებული ფლეშ: ფლეშ ჩართულია შიდა IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 და SD_DATA_1 ESP32-D2WD-ზე და ESP32-PICO-D4-ზე.
- 0 MiB (ESP32-D0WDQ6, ESP32-D0WD და ESP32-S0WD ჩიპები)
- 2 MiB (ESP32-D2WD ჩიპი)
- 4 MiB (ESP32-PICO-D4 SiP მოდული)
დაბალი სიმძლავრე: უზრუნველყოფს, რომ კვლავ შეგიძლიათ გამოიყენოთ ADC კონვერტაციები, მაგampღრმა ძილის დროს.
პერიფერიული შეყვანა/გამომავალი:
- პერიფერიული ინტერფეისი DMA-ით, რომელიც მოიცავს capacitive touch-ს
- ADC-ები (ანალოგური ციფრული გადამყვანი)
- DAC (ციფრული ანალოგური გადამყვანი)
- I²C (ინტეგრირებული წრე)
- UART (უნივერსალური ასინქრონული მიმღები/გადამცემი)
- SPI (სერიული პერიფერიული ინტერფეისი)
- I²S (ინტეგრირებული ინტერჩიპის ხმა)
- RMII (შემცირებული მედია დამოუკიდებელი ინტერფეისი)
- PWM (პულსის სიგანის მოდულაცია)
უსაფრთხოება: ტექნიკის ამაჩქარებლები AES და SSL/TLS-ისთვის
ESP32 განვითარების დაფები
ESP32 ეხება შიშველ ESP32 ჩიპს. თუმცა, "ESP32" ტერმინი ასევე გამოიყენება ESP32 განვითარების დაფებისთვის. ESP32 შიშველი ჩიპების გამოყენება არ არის ადვილი ან პრაქტიკული, განსაკუთრებით სწავლის, ტესტირებისა და პროტოტიპის შექმნისას. უმეტეს შემთხვევაში, თქვენ გსურთ გამოიყენოთ ESP32 განვითარების დაფა.
ჩვენ გამოვიყენებთ ESP32 DEVKIT V1 დაფას, როგორც მითითებას. ქვემოთ მოცემულ სურათზე ნაჩვენებია ESP32 DEVKIT V1 დაფა, ვერსია 30 GPIO პინით.
სპეციფიკაციები – ESP32 DEVKIT V1
შემდეგი ცხრილი გვიჩვენებს ESP32 DEVKIT V1 DOIT დაფის მახასიათებლებისა და სპეციფიკაციების შეჯამებას:
| ბირთვების რაოდენობა | 2 (ორბირთვიანი) |
| Wi-Fi | 2.4 გჰც 150 მბიტ/წმ-მდე |
| Bluetooth | BLE (Bluetooth Low Energy) და ძველი Bluetooth |
| არქიტექტურა | 32 ბიტი |
| საათის სიხშირე | 240 MHz-მდე |
| ოპერატიული მეხსიერება | 512 კბ |
| ქინძისთავები | 30 (დამოკიდებულია მოდელზე) |
| პერიფერიული მოწყობილობები | ტევადი შეხება, ADC (ანალოგური ციფრული გადამყვანი), DAC (ციფრული ანალოგური გადამყვანი), 12C (ინტეგრირებული წრე), UART (უნივერსალური ასინქრონული მიმღები/გადამცემი), CAN 2.0 (კონტროლერის არეალის ქსელი), SPI (სერიული პერიფერიული ინტერფეისი) , 12S (ინტეგრირებული ინტერ-IC ხმა), RMII (შემცირებული მედია დამოუკიდებელი ინტერფეისი), PWM (პულსის სიგანის მოდულაცია) და სხვა. |
| ჩაშენებული ღილაკები | RESET და BOOT ღილაკები |
| ჩამონტაჟებული LED-ები | ჩაშენებული ლურჯი LED, რომელიც დაკავშირებულია GPIO2-თან; ჩაშენებული წითელი LED, რომელიც აჩვენებს, რომ დაფა იკვებება |
| USB UART-ზე ხიდი |
CP2102 |
მას გააჩნია microUSB ინტერფეისი, რომელიც შეგიძლიათ გამოიყენოთ დაფის დასაკავშირებლად თქვენს კომპიუტერთან კოდის ასატვირთად ან დენის გამოსაყენებლად.
ის იყენებს CP2102 ჩიპს (USB to UART) თქვენს კომპიუტერთან კომუნიკაციისთვის COM პორტის საშუალებით სერიული ინტერფეისის გამოყენებით. კიდევ ერთი პოპულარული ჩიპი არის CH340. შეამოწმეთ, რა არის USB-დან UART ჩიპის გადამყვანი თქვენს დაფაზე, რადგან თქვენ უნდა დააინსტალიროთ საჭირო დრაივერები, რათა კომპიუტერმა შეძლოს დაფასთან კომუნიკაცია (დამატებითი ინფორმაცია ამის შესახებ მოგვიანებით ამ სახელმძღვანელოში).
ამ დაფას ასევე მოყვება RESET ღილაკი (შეიძლება ეწოდოს EN) დაფის გადატვირთვისთვის და BOOT ღილაკი დაფის ციმციმის რეჟიმში დასაყენებლად (ხელმისაწვდომია კოდის მისაღებად). გაითვალისწინეთ, რომ ზოგიერთ დაფას შეიძლება არ ჰქონდეს BOOT ღილაკი.
მას ასევე გააჩნია ჩაშენებული ლურჯი LED, რომელიც იძულებით არის დაკავშირებული GPIO 2-თან. ეს LED გამოსადეგია გამართვისთვის, რათა გარკვეული ვიზუალური ფიზიკური გამომავალი იყოს. ასევე არის წითელი LED, რომელიც ანათებს, როდესაც თქვენ მიაწოდებთ დაფას ელექტროენერგიით.
ESP32 Pinout
ESP32 პერიფერიული მოწყობილობები მოიცავს:
- 18 ანალოგური ციფრული გადამყვანის (ADC) არხი
- 3 SPI ინტერფეისი
- 3 UART ინტერფეისი
- 2 I2C ინტერფეისი
- 16 PWM გამომავალი არხი
- 2 ციფრული ანალოგური გადამყვანი (DAC)
- 2 I2S ინტერფეისი
- 10 ტევადი სენსორული GPIO
ADC (ანალოგური ციფრული გადამყვანი) და DAC (ციფრული ანალოგური გადამყვანი) ფუნქციები ენიჭება კონკრეტულ სტატიკური ქინძისთავებს. თუმცა, თქვენ შეგიძლიათ გადაწყვიტოთ რომელი ქინძისთავებია UART, I2C, SPI, PWM და ა.შ. – თქვენ უბრალოდ უნდა მიაწეროთ ისინი კოდში. ეს შესაძლებელია ESP32 ჩიპის მულტიპლექსირების ფუნქციის გამო.
მიუხედავად იმისა, რომ თქვენ შეგიძლიათ განსაზღვროთ ქინძისთავები პროგრამულ უზრუნველყოფაზე, არსებობს ქინძისთავები, რომლებიც მინიჭებულია ნაგულისხმევად, როგორც ნაჩვენებია შემდეგ ფიგურაში
გარდა ამისა, არის ქინძისთავები სპეციფიკური მახასიათებლებით, რაც მათ შესაფერისს ან არა კონკრეტულ პროექტს ხდის. ქვემოთ მოყვანილი ცხრილი გვიჩვენებს, თუ რომელი ქინძისთავები არის საუკეთესო გამოსაყენებლად შეყვანის, გამოსავლის სახით და რომელი მათგანი უნდა იყოთ ფრთხილად.
მწვანეში მონიშნული ქინძისთავები გამოსაყენებლად კარგია. ყვითლად ხაზგასმული პირები კარგია გამოსაყენებლად, მაგრამ ყურადღება უნდა მიაქციოთ, რადგან მათ შეიძლება ჰქონდეთ მოულოდნელი ქცევა ძირითადად ჩატვირთვისას. წითლად ხაზგასმული ქინძისთავები არ არის რეკომენდირებული შეყვანის ან გამოსასვლელად გამოსაყენებლად.
| GP IO | შეყვანა | გამომავალი | შენიშვნები |
| 0 | აწია | OK | გამოსცემს PWM სიგნალს ჩატვირთვისას, უნდა იყოს LOW ციმციმის რეჟიმში შესასვლელად |
| 1 | TX პინი | OK | გამართვის გამომავალი ჩატვირთვისას |
| 2 | OK | OK | დაკავშირებულია ბორტ LED-ზე, უნდა დარჩეს მცურავი ან დაბალი, რათა შეხვიდეთ ციმციმის რეჟიმში |
| 3 | OK | RX პინი | მაღალი ჩატვირთვისას |
| 4 | OK | OK | |
| 5 | OK | OK | გამოსცემს PWM სიგნალს ჩატვირთვისას, სამაგრის ქინძისთავზე |
| 12 | OK | OK | ჩექმა მარცხდება, თუ მაღლა აწევს, სამაგრი ქინძისთავი |
| 13 | OK | OK | |
| 14 | OK | OK | გამოსცემს PWM სიგნალს ჩატვირთვისას |
| 15 | OK | OK | გამოსცემს PWM სიგნალს ჩატვირთვისას, სამაგრის ქინძისთავზე |
| 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 | მხოლოდ შეყვანა | |
| 35 | OK | მხოლოდ შეყვანა | |
| 36 | OK | მხოლოდ შეყვანა | |
| 39 | OK | მხოლოდ შეყვანა |
განაგრძეთ კითხვა ESP32 GPIO-ების და მისი ფუნქციების უფრო დეტალური და სიღრმისეული ანალიზისთვის.
შეიყვანეთ მხოლოდ ქინძისთავები
GPIO 34-დან 39-მდე არის GPI - შეიყვანეთ მხოლოდ ქინძისთავები. ამ ქინძისთავებს არ აქვთ შიდა ასაწევი ან ჩამოსაშლელი რეზისტორები. მათი გამოყენება არ შეიძლება გამოსავალებად, ამიტომ გამოიყენეთ ეს ქინძისთავები მხოლოდ შეყვანის სახით:
- GPIO 34
- GPIO 35
- GPIO 36
- GPIO 39
SPI flash ინტეგრირებული ESP-WROOM-32-ზე
GPIO 6-დან GPIO 11-მდე გამოფენილია ESP32 განვითარების ზოგიერთ დაფაზე. თუმცა, ეს ქინძისთავები უკავშირდება ინტეგრირებულ SPI ფლეშს ESP-WROOM-32 ჩიპზე და არ არის რეკომენდებული სხვა გამოყენებისთვის. ასე რომ, არ გამოიყენოთ ეს ქინძისთავები თქვენს პროექტებში:
- 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
ESP32-ს აქვს 10 შიდა ტევადი სენსორული სენსორი. მათ შეუძლიათ შეიგრძნონ ვარიაციები ნებისმიერში, რაც ელექტრულ მუხტს ფლობს, როგორიცაა ადამიანის კანი. ასე რომ, მათ შეუძლიათ აღმოაჩინონ ვარიაციები, რომლებიც გამოწვეულია GPIO-ებზე თითით შეხებისას. ეს ქინძისთავები ადვილად შეიძლება ინტეგრირებული იყოს ტევადურ ბალიშებში და შეცვალოს მექანიკური ღილაკები. ტევადი სენსორული ქინძისთავები ასევე შეიძლება გამოყენებულ იქნას ESP32-ის ღრმა ძილისგან გასაღვიძებლად. ეს შიდა სენსორული სენსორები დაკავშირებულია ამ GPIO-ებთან:
- 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)
ანალოგური ციფრული გადამყვანი (ADC)
ESP32-ს აქვს 18 x 12 ბიტიანი ADC შეყვანის არხები (მაშინ, როცა ESP8266-ს აქვს მხოლოდ 1x10 ბიტიანი ADC). ეს არის GPIO-ები, რომლებიც შეიძლება გამოყენებულ იქნას როგორც ADC და შესაბამისი არხები:
- 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)
შენიშვნა: ADC2 პინების გამოყენება შეუძლებელია Wi-Fi-ის გამოყენებისას. ასე რომ, თუ იყენებთ Wi-Fi-ს და გიჭირთ მნიშვნელობის მიღება ADC2 GPIO-დან, შეგიძლიათ გამოიყენოთ ADC1 GPIO. ამან უნდა გადაჭრას შენი პრობლემა.
ADC შეყვანის არხებს აქვს 12 ბიტიანი გარჩევადობა. ეს ნიშნავს, რომ თქვენ შეგიძლიათ მიიღოთ ანალოგური წაკითხვები 0-დან 4095-მდე, რომელშიც 0 შეესაბამება 0V-ს და 4095-დან 3.3V-მდე. თქვენ ასევე შეგიძლიათ დააყენოთ თქვენი არხების გარჩევადობა კოდზე და ADC დიაპაზონზე.
ESP32 ADC პინებს არ აქვთ ხაზოვანი ქცევა. თქვენ ალბათ ვერ შეძლებთ განასხვავოთ 0 და 0.1 ვ, ან 3.2 და 3.3 ვ. თქვენ უნდა გაითვალისწინოთ ეს ADC პინების გამოყენებისას. თქვენ მიიღებთ მსგავს ქცევას, რაც ნაჩვენებია შემდეგ ფიგურაში.
ციფრული ანალოგური გადამყვანი (DAC)
ESP2-ზე არის 8 x 32 ბიტიანი DAC არხი ციფრული სიგნალების ანალოგურ მოცულობაში გადასაყვანადtage სიგნალის გამომავალი. ეს არის DAC არხები:
- DAC1 (GPIO25)
- DAC2 (GPIO26)
RTC GPIO
ESP32-ზე არის RTC GPIO მხარდაჭერა. RTC დაბალი სიმძლავრის ქვესისტემაზე გადაყვანილი GPIO შეიძლება გამოყენებულ იქნას, როდესაც ESP32 ღრმა ძილშია. ეს RTC GPIO შეიძლება გამოყენებულ იქნას ESP32-ის ღრმა ძილისგან გამოსაფხიზლებლად, როდესაც ულტრა დაბალია
დენის (ULP) თანაპროცესორი მუშაობს. შემდეგი GPIO შეიძლება გამოყენებულ იქნას როგორც გაღვიძების გარე წყარო.
- 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
ESP32 LED PWM კონტროლერს აქვს 16 დამოუკიდებელი არხი, რომელთა კონფიგურაცია შესაძლებელია სხვადასხვა თვისებების მქონე PWM სიგნალების გენერირებისთვის. ყველა ქინძისთავები, რომლებსაც შეუძლიათ გამოსავალის როლი შეასრულონ, შეიძლება გამოყენებულ იქნას როგორც PWM პინები (GPIO 34-დან 39-მდე ვერ წარმოქმნის PWM-ს).
PWM სიგნალის დასაყენებლად, თქვენ უნდა განსაზღვროთ ეს პარამეტრები კოდში:
- სიგნალის სიხშირე;
- მოვალეობის ციკლი;
- PWM არხი;
- GPIO, სადაც გსურთ სიგნალის გამოტანა.
I2C
ESP32-ს აქვს ორი I2C არხი და ნებისმიერი პინი შეიძლება დაყენდეს როგორც SDA ან SCL. ESP32-ის Arduino IDE-ით გამოყენებისას, ნაგულისხმევი I2C პინებია:
- GPIO 21 (SDA)
- GPIO 22 (SCL)
თუ გსურთ გამოიყენოთ სხვა ქინძისთავები მავთულის ბიბლიოთეკის გამოყენებისას, უბრალოდ უნდა დარეკოთ:
Wire.begin (SDA, SCL);
SPI
ნაგულისხმევად, SPI-ის პინი არის:
| SPI | MOSI | მისო | CLK | CS |
| VSPI | GPIO 23 | GPIO 19 | GPIO 18 | GPIO 5 |
| HSPI | GPIO 13 | GPIO 12 | GPIO 14 | GPIO 15 |
წყვეტს
ყველა GPIO შეიძლება კონფიგურირებული იყოს როგორც შეფერხებები.
სამაგრი ქინძისთავები
ESP32 ჩიპს აქვს შემდეგი სამაგრი ქინძისთავები:
- GPIO 0 (ჩატვირთვის რეჟიმში შესასვლელად უნდა იყოს დაბალი)
- GPIO 2 (ჩატვირთვისას უნდა იყოს მცურავი ან დაბალი)
- GPIO 4
- GPIO 5 (ჩატვირთვისას მაღალი უნდა იყოს)
- GPIO 12 (ჩატვირთვისას დაბალი უნდა იყოს)
- GPIO 15 (ჩატვირთვისას მაღალი უნდა იყოს)
ისინი გამოიყენება ESP32-ის ჩამტვირთველში ან ციმციმის რეჟიმში დასაყენებლად. უმეტეს დეველოპერულ დაფებზე ჩაშენებული USB/სერიული, თქვენ არ გჭირდებათ ფიქრი ამ ქინძისთავების მდგომარეობის შესახებ. დაფა აყენებს ქინძისთავებს სწორ მდგომარეობაში ციმციმის ან ჩატვირთვის რეჟიმში. დამატებითი ინფორმაცია ESP32 Boot Mode Selection-ის შესახებ შეგიძლიათ იხილოთ აქ.
თუმცა, თუ თქვენ გაქვთ პერიფერიული მოწყობილობები დაკავშირებული ამ ქინძისთავებთან, შეიძლება გაგიჭირდეთ ახალი კოდის ატვირთვის მცდელობა, ESP32-ის გამორთვა ახალი firmware-ით ან დაფის გადატვირთვა. თუ თქვენ გაქვთ რამდენიმე პერიფერიული მოწყობილობა დაკავშირებული სამაგრის ქინძისთავებთან და პრობლემები გაქვთ კოდის ატვირთვისას ან ESP32-ის ციმციმის დროს, ეს შეიძლება იყოს იმიტომ, რომ ეს პერიფერიული მოწყობილობები ხელს უშლიან ESP32-ს სწორ რეჟიმში შესვლას. წაიკითხეთ ჩატვირთვის რეჟიმის შერჩევის დოკუმენტაცია, რათა გაგიწიოთ სწორი მიმართულებით. გადატვირთვის, ციმციმის ან ჩატვირთვის შემდეგ, ეს ქინძისთავები მუშაობს ისე, როგორც მოსალოდნელია.
ამაგრებს HIGH ჩატვირთვისას
ზოგიერთი GPIO ცვლის თავის მდგომარეობას HIGH-ზე ან გამოსცემს PWM სიგნალებს ჩატვირთვის ან გადატვირთვისას.
ეს ნიშნავს, რომ თუ ამ GPIO-ებთან დაკავშირებული გამომავალი გაქვთ, შეიძლება მიიღოთ მოულოდნელი შედეგები ESP32-ის გადატვირთვის ან ჩატვირთვისას.
- GPIO 1
- GPIO 3
- GPIO 5
- GPIO 6-დან GPIO 11-მდე (დაკავშირებულია ESP32 ინტეგრირებულ SPI ფლეშ მეხსიერებასთან – არ არის რეკომენდებული გამოყენება).
- GPIO 14
- GPIO 15
ჩართვა (EN)
Enable (EN) არის 3.3V რეგულატორის ჩართვის პინი. ის ამოწეულია, ამიტომ დააკავშირეთ მიწაზე 3.3 ვ რეგულატორის გამორთვისთვის. ეს ნიშნავს, რომ თქვენ შეგიძლიათ გამოიყენოთ ეს პინი, რომელიც დაკავშირებულია ღილაკთან, რომ გადატვირთოთ თქვენი ESP32, მაგალითადampლე.
GPIO დენი შედგენილია
GPIO-ზე გაყვანილი აბსოლუტური მაქსიმალური დენი არის 40 mA ESP32 მონაცემთა ფურცლის „რეკომენდებული საოპერაციო პირობების“ განყოფილების შესაბამისად.
ESP32 ჩაშენებული ჰოლის ეფექტის სენსორი
ESP32 ასევე აღჭურვილია ჰოლის ეფექტის ჩაშენებული სენსორით, რომელიც აღმოაჩენს ცვლილებებს მაგნიტურ ველში მის შემოგარენში
ESP32 Arduino IDE
არის დანამატი Arduino IDE-სთვის, რომელიც საშუალებას გაძლევთ დაპროგრამოთ ESP32 Arduino IDE-ისა და მისი პროგრამირების ენის გამოყენებით. ამ სახელმძღვანელოში ჩვენ გაჩვენებთ, თუ როგორ დააინსტალიროთ ESP32 დაფა Arduino IDE-ში, მიუხედავად იმისა, იყენებთ Windows-ს, Mac OS X-ს თუ Linux-ს.
წინაპირობები: დაინსტალირებულია Arduino IDE
ამ ინსტალაციის პროცედურის დაწყებამდე, თქვენ უნდა გქონდეთ დაინსტალირებული Arduino IDE თქვენს კომპიუტერში. არსებობს Arduino IDE-ის ორი ვერსია, რომელიც შეგიძლიათ დააინსტალიროთ: ვერსია 1 და ვერსია 2.
შეგიძლიათ ჩამოტვირთოთ და დააინსტალიროთ Arduino IDE შემდეგ ბმულზე დაწკაპუნებით: arduino.cc/en/Main/Software
რომელ Arduino IDE ვერსიას გირჩევთ? ამ დროისთვის არის რამდენიმე plugins ESP32-ისთვის (როგორც SPIFFS Fileსისტემის Uploader Plugin), რომლებიც ჯერ არ არის მხარდაჭერილი Arduino 2-ზე. ასე რომ, თუ მომავალში აპირებთ SPIFFS მოდულის გამოყენებას, გირჩევთ დააინსტალიროთ ძველი ვერსია 1.8.X. თქვენ უბრალოდ უნდა გადახვიდეთ Arduino პროგრამული უზრუნველყოფის გვერდზე, რომ იპოვოთ იგი.
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
იმისათვის, რომ დააინსტალიროთ ESP32 დაფა თქვენს Arduino IDE-ში, მიჰყევით შემდეგ ინსტრუქციებს:
- თქვენს Arduino IDE-ში გადადით File> პარამეტრები
- შეიყვანეთ შემდეგი "დამატებითი საბჭოს მენეჯერი URLs” ველი:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
შემდეგ დააჭირეთ ღილაკს "OK":
შენიშვნა: თუ უკვე გაქვთ ESP8266 დაფები URL, შეგიძლიათ გამოყოთ URLs მძიმით შემდეგნაირად:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
გახსენით დაფების მენეჯერი. გადადით ინსტრუმენტები > დაფა > დაფების მენეჯერი…
ძიება ESP32 and press install button for the “ESP32 by Espressif Systems“:
ესე იგი. ის უნდა დამონტაჟდეს რამდენიმე წამის შემდეგ.
ატვირთეთ ტესტის კოდი
შეაერთეთ ESP32 დაფა თქვენს კომპიუტერში. თუ თქვენი Arduino IDE ღიაა, მიჰყევით ამ ნაბიჯებს:
- აირჩიეთ თქვენი დაფა მენიუში Tools > Board (ჩემს შემთხვევაში ეს არის ESP32 DEV მოდული).
- აირჩიეთ პორტი (თუ არ ხედავთ COM პორტს თქვენს Arduino IDE-ში, თქვენ უნდა დააინსტალიროთ CP210x USB UART Bridge VCP დრაივერებზე):
- გახსენით შემდეგი ყოფილიampქვეშ File > მაგamples > WiFi
(ESP32) > WiFiScan
- ახალი ესკიზი იხსნება თქვენს Arduino IDE-ში:
- დააჭირეთ ატვირთვის ღილაკს Arduino IDE-ში. დაელოდეთ რამდენიმე წამს, სანამ კოდი შედგენილია და აიტვირთება თქვენს დაფაზე.
- თუ ყველაფერი ისე წავიდა, როგორც მოსალოდნელი იყო, უნდა ნახოთ „ატვირთვა დასრულებულია“. შეტყობინება.
- გახსენით Arduino IDE სერიული მონიტორი ბაუდის სიჩქარით 115200:
- დააჭირეთ ESP32-ის ჩართვის ღილაკს და დაინახავთ ქსელებს, რომლებიც ხელმისაწვდომია თქვენს ESP32-თან:
პრობლემების მოგვარება
თუ თქვენ ცდილობთ ატვირთოთ ახალი ესკიზი თქვენს ESP32-ზე და მიიღებთ ამ შეცდომის შეტყობინებას „მოხდა ფატალური შეცდომა: ESP32-თან დაკავშირება ვერ მოხერხდა: დრო ამოიწურა… დაკავშირება…“. ეს ნიშნავს, რომ თქვენი ESP32 არ არის მოციმციმე/ატვირთვის რეჟიმში.
სწორი დაფის სახელის და COM-ის არჩევის შემდეგ, მიჰყევით ამ ნაბიჯებს:
გეჭიროთ „BOOT“ ღილაკი თქვენს ESP32 დაფაზე
- დააჭირეთ ღილაკს "ატვირთვა" Arduino IDE-ში თქვენი ესკიზის ასატვირთად:
- მას შემდეგ, რაც იხილავთ "დაკავშირებას ...". გაგზავნეთ თქვენი Arduino IDE-ში, გაათავისუფლეთ თითი ღილაკიდან „BOOT“:
- ამის შემდეგ, თქვენ უნდა იხილოთ შეტყობინება "დასრულებულია ატვირთვა".
ესე იგი. თქვენს ESP32-ს უნდა ჰქონდეს ახალი ესკიზი გაშვებული. დააჭირეთ ღილაკს „ENABLE“ რათა გადატვირთოთ ESP32 და გაუშვათ ახალი ატვირთული ესკიზი.
თქვენ ასევე მოგიწევთ გაიმეოროთ ეს ღილაკების თანმიმდევრობა ყოველ ჯერზე, როდესაც გსურთ ატვირთოთ ახალი ესკიზი.
პროექტი 1 ESP32 შეყვანის შედეგები
ამ დაწყების სახელმძღვანელოში თქვენ შეისწავლით თუ როგორ წაიკითხოთ ციფრული შეყვანები, როგორიცაა ღილაკების გადამრთველი და მართოთ ციფრული გამომავალი, როგორიცაა LED, ESP32-ის გამოყენებით Arduino IDE-ით.
წინაპირობები
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ის გამოყენებით. ასე რომ, სანამ გააგრძელებთ, დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დაფების დანამატი:
- ESP32 დანამატის ინსტალაცია Arduino IDE-ში
ESP32 კონტროლის ციფრული გამომავალი
პირველ რიგში, თქვენ უნდა დააყენოთ GPIO, რომლის კონტროლიც გსურთ, როგორც OUTPUT. გამოიყენეთ pinMode() ფუნქცია შემდეგნაირად:
pinMode (GPIO, OUTPUT);
ციფრული გამომავალი გასაკონტროლებლად უბრალოდ უნდა გამოიყენოთ digitalWrite() ფუნქცია, რომელიც არგუმენტად იღებს, GPIO-ს (int ნომერი) რომელსაც თქვენ მიუთითებთ და მდგომარეობას, HIGH ან LOW.
digitalWrite (GPIO, STATE);
ყველა GPIO შეიძლება გამოვიყენოთ გამოსავლებად, გარდა GPIO 6-დან 11-მდე (დაკავშირებული ინტეგრირებულ SPI flash-თან) და GPIO 34, 35, 36 და 39 (შეიტანეთ მხოლოდ GPIO);
შეიტყვეთ მეტი ESP32 GPIO-ების შესახებ: ESP32 GPIO საცნობარო სახელმძღვანელო
ESP32 წაკითხული ციფრული შეყვანები
პირველ რიგში, დააყენეთ GPIO, რომლის წაკითხვაც გსურთ, როგორც INPUT, pinMode() ფუნქციის გამოყენებით შემდეგნაირად:
pinMode (GPIO, INPUT);
ციფრული შეყვანის წასაკითხად, ღილაკის მსგავსად, იყენებთ digitalRead() ფუნქციას, რომელიც არგუმენტად იღებს GPIO-ს (int ნომერი), რომელსაც თქვენ მიუთითებთ.
digitalRead (GPIO);
ყველა ESP32 GPIO შეიძლება გამოყენებულ იქნას შეყვანის სახით, გარდა GPIO 6-დან 11-მდე (დაკავშირებული ინტეგრირებულ SPI flash-თან).
შეიტყვეთ მეტი ESP32 GPIO-ების შესახებ: ESP32 GPIO საცნობარო სახელმძღვანელო
პროექტი მაგample
იმისათვის, რომ გაჩვენოთ, თუ როგორ გამოიყენოთ ციფრული შეყვანა და ციფრული გამომავალი, ჩვენ ავაშენებთ მარტივ პროექტსampღილაკით და LED-ით. ჩვენ წავიკითხავთ ღილაკის მდგომარეობას და ავანთებთ LED-ს შესაბამისად, როგორც ეს ნაჩვენებია შემდეგ ფიგურაში.
საჭირო ნაწილები
აქ მოცემულია იმ ნაწილების სია, რომლებიც გჭირდებათ მიკროსქემის შესაქმნელად:
- ESP32 DEVKIT V1
- 5 მმ LED
- 220 Ohm რეზისტორი
- ღილაკი
- 10k Ohm რეზისტორი
- პურის დაფა
- ჯუმპერის მავთულები
სქემატური დიაგრამა
სანამ გააგრძელებთ, თქვენ უნდა ააწყოთ წრე LED-ით და ღილაკით.
ჩვენ დავუკავშირებთ LED-ს GPIO 5-ს და ღილაკს GPIO-ს 4.
კოდი
გახსენით კოდი Project_1_ESP32_Inputs_Outputs.ino arduino IDE-ში
როგორ მუშაობს კოდი
შემდეგ ორ სტრიქონში, თქვენ ქმნით ცვლადებს ქინძისთავების მინიჭებისთვის:
ღილაკი დაკავშირებულია GPIO 4-თან და LED უკავშირდება GPIO 5-ს. Arduino IDE-ს ESP32-თან გამოყენებისას 4 შეესაბამება GPIO 4-ს და 5 შეესაბამება GPIO 5-ს.
შემდეგი, თქვენ შექმნით ცვლადს ღილაკის მდგომარეობის შესანარჩუნებლად. ნაგულისხმევად, ეს არის 0 (დაჭერილი არ არის).
int buttonState = 0;
setup()-ში თქვენ ინიციალიზებთ ღილაკს როგორც INPUT და LED-ს როგორც OUTPUT.
ამისთვის იყენებთ pinMode() ფუნქციას, რომელიც იღებს თქვენს მიერ მითითებულ პინს და რეჟიმს: INPUT ან OUTPUT.
pinMode (ღილაკიPin, INPUT);
pinMode (ledPin, OUTPUT);
მარყუჟში() არის სადაც წაიკითხავთ ღილაკის მდგომარეობას და შესაბამისად აყენებთ LED-ს.
შემდეგ სტრიქონში წაიკითხავთ ღილაკის მდგომარეობას და შეინახავთ მას buttonState ცვლადში.
როგორც ადრე ვნახეთ, თქვენ იყენებთ digitalRead() ფუნქციას.
buttonState = digitalRead(buttonPin);
შემდეგი if განცხადება ამოწმებს არის თუ არა ღილაკის მდგომარეობა HIGH. თუ ეს ასეა, ის ჩართავს LED-ს digitalWrite() ფუნქციის გამოყენებით, რომელიც არგუმენტად იღებს ledPin-ს და მდგომარეობას HIGH.
თუ (buttonState == HIGH)
თუ ღილაკის მდგომარეობა არ არის მაღალი, გამორთეთ LED. უბრალოდ დააყენეთ LOW, როგორც მეორე არგუმენტი digitalWrite() ფუნქციაში.
კოდის ატვირთვა
ატვირთვის ღილაკზე დაწკაპუნებამდე გადადით Tools > Board და აირჩიეთ დაფა :DOIT ESP32 DEVKIT V1.
გადადით Tools > Port და აირჩიეთ COM პორტი, რომელზეც დაკავშირებულია ESP32. შემდეგ, დააჭირეთ ატვირთვის ღილაკს და დაელოდეთ შეტყობინებას „დასრულებულია ატვირთვა“.
შენიშვნა: თუ ხედავთ უამრავ წერტილს (დაკავშირება…__…__) გამართვის ფანჯარაში და შეტყობინებას „ვერ მოხდა ESP32-თან დაკავშირება: პაკეტის სათაურის მოლოდინის დრო ამოიწურა“, ეს ნიშნავს, რომ თქვენ უნდა დააჭიროთ ESP32-ის ბორტ BOOT-ს. ღილაკი წერტილების შემდეგ
დაიწყოს გამოჩენა.პრობლემების მოგვარება
დემონსტრაცია
კოდის ატვირთვის შემდეგ შეამოწმეთ თქვენი წრე. თქვენი LED უნდა აანთოს, როდესაც დააჭირეთ ღილაკს:
და გამორთეთ, როცა გაათავისუფლებთ:
პროექტი 2 ESP32 ანალოგური შეყვანა
ეს პროექტი გვიჩვენებს, თუ როგორ უნდა წაიკითხოთ ანალოგური შეყვანა ESP32-ით Arduino IDE-ის გამოყენებით.
ანალოგური კითხვა სასარგებლოა ცვლადი რეზისტორების მნიშვნელობების წასაკითხად, როგორიცაა პოტენციომეტრები ან ანალოგური სენსორები.
ანალოგური შეყვანა (ADC)
ESP32-ით ანალოგური მნიშვნელობის წაკითხვა ნიშნავს, რომ შეგიძლიათ გაზომოთ ცვალებად მოცულობაtage დონეები 0 ვ-დან 3.3 ვ-მდე.
ტომიtagგაზომილი e ენიჭება მნიშვნელობას 0-დან 4095-მდე, რომელშიც 0 ვ შეესაბამება 0-ს, ხოლო 3.3 ვ შეესაბამება 4095-ს. ნებისმიერი მოც.tage 0 V-სა და 3.3 V-ს შორის მიენიჭება შესაბამისი მნიშვნელობა მათ შორის.
ADC არის არაწრფივი
იდეალურ შემთხვევაში, თქვენ მოელით წრფივ ქცევას ESP32 ADC ქინძისთავების გამოყენებისას.
თუმცა, ეს არ ხდება. რასაც თქვენ მიიღებთ არის ქცევა, როგორც ნაჩვენებია შემდეგ დიაგრამაში:
ეს ქცევა ნიშნავს, რომ თქვენს ESP32-ს არ შეუძლია განასხვავოს 3.3 ვ 3.2 ვ-დან.
თქვენ მიიღებთ იგივე მნიშვნელობას ორივე ტომისთვისtagეს: 4095.
იგივე ხდება ძალიან დაბალი მოცულობის შემთხვევაშიtage მნიშვნელობები: 0 V და 0.1 V-სთვის თქვენ მიიღებთ იგივე მნიშვნელობას: 0. ეს უნდა გახსოვდეთ ESP32 ADC პინების გამოყენებისას.
analogRead() ფუნქცია
ანალოგური შეყვანის კითხვა ESP32-ით Arduino IDE-ის გამოყენებით ისეთივე მარტივია, როგორც analogRead() ფუნქციის გამოყენება. ის არგუმენტად იღებს GPIO-ს, რომლის წაკითხვაც გსურთ:
analogRead (GPIO);
მხოლოდ 15 არის ხელმისაწვდომი DEVKIT V1 დაფაზე (ვერსია 30 GPIO-ით).
აიღეთ თქვენი ESP32 დაფის პინი და იპოვნეთ ADC ქინძისთავები. ისინი ხაზგასმულია წითელი საზღვრით ქვემოთ მოცემულ ფიგურაში.
ამ ანალოგური შეყვანის პინებს აქვს 12-ბიტიანი გარჩევადობა. ეს ნიშნავს, რომ ანალოგური შეყვანის წაკითხვისას, მისი დიაპაზონი შეიძლება განსხვავდებოდეს 0-დან 4095-მდე.
შენიშვნა: ADC2 პინების გამოყენება შეუძლებელია Wi-Fi გამოყენებისას. ასე რომ, თუ იყენებთ Wi-Fi-ს და გიჭირთ მნიშვნელობის მიღება ADC2 GPIO-დან, შეგიძლიათ განიხილოთ ADC1 GPIO-ის გამოყენება, რაც თქვენს პრობლემას გადაჭრის.
იმის სანახავად, თუ როგორ უკავშირდება ყველაფერი ერთმანეთს, ჩვენ გავაკეთებთ მარტივ ყოფილსampანალოგური მნიშვნელობის წაკითხვა პოტენციომეტრიდან.
საჭირო ნაწილები
ამისთვის ყოფილიampთქვენ გჭირდებათ შემდეგი ნაწილები:
- ESP32 DEVKIT V1 დაფა
- Potentiometer
- პურის დაფა
- ჯუმპერის მავთულები
სქემატური
შეაერთეთ პოტენციომეტრი თქვენს ESP32-ზე. პოტენციომეტრის შუა პინი უნდა იყოს დაკავშირებული GPIO 4-თან. შეგიძლიათ გამოიყენოთ შემდეგი სქემატური დიაგრამა, როგორც მითითება.
კოდი
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
გახსენით კოდი Project_2_ESP32_Inputs_Outputs.ino arduino IDE-ში
ეს კოდი უბრალოდ კითხულობს მნიშვნელობებს პოტენციომეტრიდან და ბეჭდავს ამ მნიშვნელობებს სერიულ მონიტორში.
კოდში, თქვენ იწყებთ GPIO-ს განსაზღვრით, რომელსაც უკავშირდება პოტენციომეტრი. ამ ყოფილშიample, GPIO 4.
setup()-ში მოაწყეთ სერიული კომუნიკაცია ბაუდის სიჩქარით 115200.
loop()-ში გამოიყენეთ analogRead() ფუნქცია potPin-დან ანალოგური შეყვანის წასაკითხად.
ბოლოს დაბეჭდეთ პოტენციომეტრიდან წაკითხული მნიშვნელობები სერიულ მონიტორზე.
ატვირთეთ კოდი მოწოდებული თქვენს ESP32-ზე. დარწმუნდით, რომ არჩეული გაქვთ სწორი დაფა და COM პორტი Tools მენიუში.
ტესტირება ყოფილიample
კოდის ატვირთვისა და ESP32 გადატვირთვის ღილაკის დაჭერის შემდეგ გახსენით სერიული მონიტორი ბაუდის სიჩქარით 115200. დაატრიალეთ პოტენციომეტრი და ნახეთ მნიშვნელობების ცვლილება.
მაქსიმალური მნიშვნელობა, რომელსაც მიიღებთ არის 4095, ხოლო მინიმალური მნიშვნელობა არის 0.
შეფუთვა
ამ სტატიაში თქვენ ისწავლეთ როგორ წაიკითხოთ ანალოგური შეყვანები ESP32-ის გამოყენებით Arduino IDE-ით. მოკლედ:
- ESP32 DEVKIT V1 DOIT დაფას (ვერსია 30 ქინძისთავით) აქვს 15 ADC პინი, რომელიც შეგიძლიათ გამოიყენოთ ანალოგური შეყვანების წასაკითხად.
- ამ პინებს აქვს 12 ბიტიანი გარჩევადობა, რაც ნიშნავს, რომ შეგიძლიათ მიიღოთ მნიშვნელობები 0-დან 4095-მდე.
- Arduino IDE-ში მნიშვნელობის წასაკითხად, თქვენ უბრალოდ იყენებთ analogRead() ფუნქციას.
- ESP32 ADC პინებს არ აქვთ ხაზოვანი ქცევა. თქვენ ალბათ ვერ შეძლებთ განასხვავოთ 0 და 0.1 ვ, ან 3.2 და 3.3 ვ. თქვენ უნდა გაითვალისწინოთ ეს ADC პინების გამოყენებისას.
Project 3 ESP32 PWM (ანალოგური გამომავალი)
ამ სახელმძღვანელოში ჩვენ გაჩვენებთ, თუ როგორ უნდა გენერირება PWM სიგნალები ESP32-ით Arduino IDE-ის გამოყენებით. როგორც ყოფილიampჩვენ ავაშენებთ მარტივ წრეს, რომელიც აქრობს LED-ს ESP32-ის LED PWM კონტროლერის გამოყენებით.
ESP32 LED PWM კონტროლერი
ESP32-ს აქვს LED PWM კონტროლერი 16 დამოუკიდებელი არხით, რომელიც შეიძლება კონფიგურირებული იყოს სხვადასხვა თვისებების მქონე PWM სიგნალების გენერირებისთვის.
აქ არის ნაბიჯები, რომლებიც უნდა მიჰყვეთ LED-ის გასანათებლად PWM-ით Arduino IDE-ის გამოყენებით:
- პირველ რიგში, თქვენ უნდა აირჩიოთ PWM არხი. არის 16 არხი 0-დან 15-მდე.
- შემდეგ, თქვენ უნდა დააყენოთ PWM სიგნალის სიხშირე. LED-ისთვის კარგი გამოსაყენებელია 5000 ჰც სიხშირე.
- თქვენ ასევე უნდა დააყენოთ სიგნალის მუშაობის ციკლის გარჩევადობა: გაქვთ გარჩევადობა 1-დან 16 ბიტამდე. ჩვენ გამოვიყენებთ 8-ბიტიან გარჩევადობას, რაც ნიშნავს, რომ თქვენ შეგიძლიათ აკონტროლოთ LED სიკაშკაშე 0-დან 255-მდე მნიშვნელობის გამოყენებით.
- შემდეგი, თქვენ უნდა მიუთითოთ რომელ GPIO ან GPIO-ებზე გამოჩნდება სიგნალი. ამისთვის გამოიყენებთ შემდეგ ფუნქციას:
ledcAttachPin (GPIO, არხი)
ეს ფუნქცია იღებს ორ არგუმენტს. პირველი არის GPIO, რომელიც გამოსცემს სიგნალს, ხოლო მეორე არის არხი, რომელიც გამოიმუშავებს სიგნალს. - და ბოლოს, LED სიკაშკაშის გასაკონტროლებლად PWM გამოყენებით, იყენებთ შემდეგ ფუნქციას:
ledcWrite (არხი, სამუშაო ციკლი)
ეს ფუნქცია არგუმენტად იღებს არხს, რომელიც აწარმოებს PWM სიგნალს და სამუშაო ციკლს.
საჭირო ნაწილები
ამ გაკვეთილის შესასრულებლად გჭირდებათ ეს ნაწილები:
- ESP32 DEVKIT V1 დაფა
- 5 მმ LED
- 220 Ohm რეზისტორი
- პურის დაფა
- ჯუმპერის მავთულები
სქემატური
მიამაგრეთ LED თქვენს ESP32-ს, როგორც ქვემოთ მოცემულ სქემატურ დიაგრამაში. LED უნდა იყოს დაკავშირებული GPIO-სთან 4.
შენიშვნა: თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი პინი, რომელიც გსურთ, თუ მას შეუძლია იმოქმედოს როგორც გამომავალი. ყველა ქინძისთავები, რომლებსაც შეუძლიათ გამოსავალის როლი შეასრულონ, შეიძლება გამოყენებულ იქნას როგორც PWM. დამატებითი ინფორმაციისთვის ESP32 GPIO-ების შესახებ წაიკითხეთ: ESP32 Pinout მითითება: რომელი GPIO პინები უნდა გამოიყენოთ?
კოდი
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
გახსენით კოდი Project_3_ESP32_PWM.ino arduino IDE-ში
თქვენ იწყებთ პინის განსაზღვრით, რომელზეც LED არის მიმაგრებული. ამ შემთხვევაში LED არის მიმაგრებული GPIO 4-ზე.
შემდეგ, თქვენ დააყენეთ PWM სიგნალის თვისებები. თქვენ განსაზღვრავთ 5000 ჰც სიხშირეს, ირჩევთ 0 არხს სიგნალის გენერირებისთვის და ადგენთ გარჩევადობას 8 ბიტი. თქვენ შეგიძლიათ აირჩიოთ სხვა თვისებები, მათგან განსხვავებული, სხვადასხვა PWM სიგნალების გენერირებისთვის.
setup()-ში თქვენ უნდა დააკონფიგურიროთ LED PWM იმ თვისებებით, რომლებიც ადრე განსაზღვრეთ ledcSetup() ფუნქციის გამოყენებით, რომელიც იღებს არგუმენტებად, ledChannel-ს, სიხშირეს და გარჩევადობას შემდეგნაირად:
შემდეგი, თქვენ უნდა აირჩიოთ GPIO, საიდანაც მიიღებთ სიგნალს. ამისათვის გამოიყენეთ ledcAttachPin() ფუნქცია, რომელიც არგუმენტად იღებს GPIO-ს, სადაც გსურთ მიიღოთ სიგნალი, და არხს, რომელიც აწარმოებს სიგნალს. ამ ყოფილშიampჩვენ მივიღებთ სიგნალს ledPin GPIO-ში, რომელიც შეესაბამება GPIO 4-ს. არხი, რომელიც წარმოქმნის სიგნალს, არის ledChannel, რომელიც შეესაბამება არხს 0.
ციკლში, თქვენ შეცვლით სამუშაო ციკლს 0-დან 255-მდე, რათა გაზარდოთ LED სიკაშკაშე.
და შემდეგ, 255-დან 0-მდე სიკაშკაშის შესამცირებლად.
LED-ის სიკაშკაშის დასაყენებლად, თქვენ უბრალოდ უნდა გამოიყენოთ ledcWrite() ფუნქცია, რომელიც არგუმენტად იღებს არხს, რომელიც აწარმოებს სიგნალს და სამუშაო ციკლს.
ვინაიდან ჩვენ ვიყენებთ 8-ბიტიან გარჩევადობას, სამუშაო ციკლი გაკონტროლდება 0-დან 255-მდე მნიშვნელობის გამოყენებით. გაითვალისწინეთ, რომ ledcWrite() ფუნქციაში ვიყენებთ არხს, რომელიც აგენერირებს სიგნალს და არა GPIO.
ტესტირება ყოფილიample
ატვირთეთ კოდი თქვენს ESP32-ზე. დარწმუნდით, რომ არჩეული გაქვთ სწორი დაფა და COM პორტი. შეხედე შენს წრეს. თქვენ უნდა გქონდეთ dimmer LED, რომელიც ზრდის და ამცირებს სიკაშკაშეს.
პროექტი 4 ESP32 PIR მოძრაობის სენსორი
ეს პროექტი გვიჩვენებს, თუ როგორ ამოვიცნოთ მოძრაობა ESP32-ით PIR მოძრაობის სენსორის გამოყენებით. ზუმერი გამოსცემს მაღვიძარას მოძრაობის აღმოჩენისას და აჩერებს მაღვიძარას, როცა მოძრაობა არ არის გამოვლენილი წინასწარ განსაზღვრული დროით (როგორიცაა 4 წამი).
როგორ მუშაობს HC-SR501 მოძრაობის სენსორი
.
HC-SR501 სენსორის მუშაობის პრინციპი ეფუძნება მოძრავ ობიექტზე ინფრაწითელი გამოსხივების ცვლილებას. HC-SR501 სენსორის მიერ აღმოჩენისთვის ობიექტი უნდა აკმაყოფილებდეს ორ მოთხოვნას:
- ობიექტი ასხივებს ინფრაწითელ გზას.
- ობიექტი მოძრაობს ან კანკალებს
ასე რომ:
თუ ობიექტი ასხივებს ინფრაწითელ სხივს, მაგრამ არ მოძრაობს (მაგ., ადამიანი უძრავად დგას მოძრაობის გარეშე), ის არ არის გამოვლენილი სენსორის მიერ.
თუ ობიექტი მოძრაობს, მაგრამ არ ასხივებს ინფრაწითელ სხივებს (მაგ., რობოტი ან მანქანა), ის არ არის გამოვლენილი სენსორის მიერ.
წარმოგიდგენთ ტაიმერებს
ამ ყოფილშიampასევე შემოგთავაზებთ ტაიმერებს. ჩვენ გვინდა, რომ LED დარჩეს წინასწარ განსაზღვრული წამის განმავლობაში მოძრაობის გამოვლენის შემდეგ. იმის ნაცვლად, რომ გამოვიყენოთ delay() ფუნქცია, რომელიც ბლოკავს თქვენს კოდს და არ გაძლევთ სხვა რამის გაკეთების საშუალებას წამების განსაზღვრული რაოდენობის განმავლობაში, ჩვენ უნდა გამოვიყენოთ ტაიმერი.
delay() ფუნქცია
თქვენ უნდა გაეცნოთ delay() ფუნქციას, რადგან ის ფართოდ გამოიყენება. ამ ფუნქციის გამოყენება საკმაოდ მარტივია. ის არგუმენტად იღებს ერთ int რიცხვს.
ეს რიცხვი წარმოადგენს დროს მილიწამებში, რომელსაც პროგრამა უნდა დაელოდოს კოდის შემდეგ ხაზზე გადასვლამდე.
როდესაც თქვენ დააყოვნებთ (1000), თქვენი პროგრამა ჩერდება ამ ხაზზე 1 წამით.
delay() არის ბლოკირების ფუნქცია. დაბლოკვის ფუნქციები ხელს უშლის პროგრამას სხვა რამის გაკეთებაში, სანამ ეს კონკრეტული დავალება არ დასრულდება. თუ თქვენ გჭირდებათ რამდენიმე ამოცანის შესრულება ერთდროულად, თქვენ არ შეგიძლიათ გამოიყენოთ delay().
პროექტების უმეტესობისთვის თქვენ უნდა მოერიდოთ შეფერხებების გამოყენებას და ნაცვლად გამოიყენოთ ტაიმერი.
millis() ფუნქცია
ფუნქციის გამოყენებით, სახელად millis() შეგიძლიათ დააბრუნოთ მილიწამების რაოდენობა, რომელიც გავიდა პროგრამის პირველი დაწყებიდან.
რატომ არის ეს ფუნქცია სასარგებლო? იმის გამო, რომ მათემატიკის გამოყენებით, შეგიძლიათ მარტივად გადაამოწმოთ რამდენი დრო გავიდა თქვენი კოდის დაბლოკვის გარეშე.
საჭირო ნაწილები
ამ გაკვეთილის შესასრულებლად გჭირდებათ შემდეგი ნაწილები
- ESP32 DEVKIT V1 დაფა
- PIR მოძრაობის სენსორი (HC-SR501)
- აქტიური ბუზერი
- ჯუმპერის მავთულები
- პურის დაფა
სქემატური
შენიშვნა: სამუშაო ტომიtagHC-SR501-ის e არის 5V. გამოიყენეთ Vin პინი მის გასააქტიურებლად.
კოდი
სანამ ამ სახელმძღვანელოს გააგრძელებთ, თქვენ უნდა გქონდეთ ESP32 დანამატი დაინსტალირებული თქვენს Arduino IDE-ში. მიჰყევით ერთ-ერთ შემდეგ ინსტრუქციას, რათა დააინსტალიროთ ESP32 Arduino IDE-ზე, თუ ჯერ არ გაგიკეთებიათ. (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
გახსენით კოდი Project_4_ESP32_PIR_Motion_Sensor.ino arduino IDE-ში.
დემონსტრაცია
ატვირთეთ კოდი თქვენს ESP32 დაფაზე. დარწმუნდით, რომ არჩეული გაქვთ სწორი დაფა და COM პორტი. ატვირთეთ კოდის მითითების ნაბიჯები.
გახსენით სერიული მონიტორი ბაუდის სიხშირით 115200.
გადაიტანეთ ხელი PIR სენსორის წინ. ზუმერი უნდა ჩართოს და შეტყობინება იბეჭდება სერიულ მონიტორზე, რომელშიც ნათქვამია: „მოძრაობა აღმოჩენილია! ზუმერის სიგნალიზაცია“.
4 წამის შემდეგ ზუმერი უნდა გამორთოთ.
პროექტი 5 ESP32 გადამრთველი Web სერვერი
ამ პროექტში თქვენ შექმნით დამოუკიდებელ web სერვერი ESP32-ით, რომელიც აკონტროლებს გამოსავალს (ორი LED) Arduino IDE პროგრამირების გარემოს გამოყენებით. The web სერვერი რეაგირებს მობილურზე და მისი წვდომა შესაძლებელია ნებისმიერი მოწყობილობით, როგორც ბრაუზერი ლოკალურ ქსელში. ჩვენ გაჩვენებთ როგორ შექმნათ web სერვერზე და როგორ მუშაობს კოდი ეტაპობრივად.
პროექტი დასრულდაview
სანამ პირდაპირ პროექტზე გადავიდოდეთ, მნიშვნელოვანია გამოვყოთ ჩვენი web სერვერი გააკეთებს, ასე რომ შემდგომში უფრო ადვილი იქნება ნაბიჯების შესრულება.
- The web სერვერი, რომელსაც თქვენ ააშენებთ საკონტროლო ორ LED- სთან, რომლებიც დაკავშირებულია ESP32 GPIO 26 და GPIO 27;
- თქვენ შეგიძლიათ შეხვიდეთ ESP32-ზე web სერვერი ლოკალურ ქსელში ბრაუზერზე ESP32 IP მისამართის აკრეფით;
- თქვენს ღილაკებზე დაწკაპუნებით web სერვერზე შეგიძლიათ მყისიერად შეცვალოთ თითოეული LED-ის მდგომარეობა.
საჭირო ნაწილები
ამ გაკვეთილისთვის დაგჭირდებათ შემდეგი ნაწილები:
- ESP32 DEVKIT V1 დაფა
- 2 x 5 მმ LED
- 2 x 200 Ohm რეზისტორი
- პურის დაფა
- ჯუმპერის მავთულები
სქემატური
დაიწყეთ მიკროსქემის აგებით. შეაერთეთ ორი LED ESP32-ზე, როგორც ეს ნაჩვენებია შემდეგ სქემატურ დიაგრამაში - ერთი LED დაკავშირებულია GPIO 26-თან, მეორე კი GPIO 27-თან.
შენიშვნა: ჩვენ ვიყენებთ ESP32 DEVKIT DOIT დაფას 36 ქინძისთავთან ერთად. მიკროსქემის აწყობამდე, დარწმუნდით, რომ შეამოწმეთ პინი დაფისთვის, რომელსაც იყენებთ.
კოდი
აქ ჩვენ გთავაზობთ კოდს, რომელიც ქმნის ESP32-ს web სერვერი. გახსენით კოდი Project_5_ESP32_Switch _Web_Server.ino arduino IDE-ში, მაგრამ ჯერ არ ატვირთოთ. თქვენ უნდა შეიტანოთ გარკვეული ცვლილებები, რომ ის თქვენთვის სასარგებლო იყოს.
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
თქვენი ქსელის რწმუნებათა სიგელების დაყენება
თქვენ უნდა შეცვალოთ შემდეგი ხაზები თქვენი ქსელის რწმუნებით: SSID და პაროლი. კოდი კარგად არის კომენტირებული, თუ სად უნდა შეიტანოთ ცვლილებები.
კოდის ატვირთვა
ახლა თქვენ შეგიძლიათ ატვირთოთ კოდი და და web სერვერი დაუყოვნებლივ იმუშავებს.
მიჰყევით შემდეგ ნაბიჯებს ESP32-ზე კოდის ასატვირთად:
- შეაერთეთ თქვენი ESP32 დაფა თქვენს კომპიუტერში;
- Arduino IDE-ში აირჩიეთ თქვენი დაფა Tools > Board (ჩვენს შემთხვევაში ვიყენებთ ESP32 DEVKIT DOIT დაფას);
- აირჩიეთ COM პორტი ინსტრუმენტებში > პორტში.
- დააჭირეთ ღილაკს ატვირთვა Arduino IDE-ში და დაელოდეთ რამდენიმე წამს, სანამ კოდი შედგენილია და აიტვირთება თქვენს დაფაზე.
- დაელოდეთ შეტყობინებას "დასრულებულია ატვირთვა".
იპოვეთ ESP IP მისამართი
კოდის ატვირთვის შემდეგ გახსენით სერიული მონიტორი ბაუდის სიჩქარით 115200.
დააჭირეთ ESP32 EN ღილაკს (გადატვირთვა). ESP32 უკავშირდება Wi-Fi-ს და გამოსცემს ESP IP მისამართს სერიულ მონიტორზე. დააკოპირეთ ეს IP მისამართი, რადგან ის გჭირდებათ ESP32-ზე წვდომისთვის web სერვერი.
წვდომა Web სერვერი
წვდომისათვის web სერვერზე, გახსენით თქვენი ბრაუზერი, ჩასვით ESP32 IP მისამართი და დაინახავთ შემდეგ გვერდს.
შენიშვნა: თქვენი ბრაუზერი და ESP32 უნდა იყოს დაკავშირებული იმავე LAN-თან.
თუ გადახედავთ სერიულ მონიტორს, ხედავთ რა ხდება ფონზე. ESP იღებს HTTP მოთხოვნას ახალი კლიენტისგან (ამ შემთხვევაში, თქვენი ბრაუზერი).
თქვენ ასევე შეგიძლიათ ნახოთ სხვა ინფორმაცია HTTP მოთხოვნის შესახებ.
დემონსტრაცია
ახლა შეგიძლიათ შეამოწმოთ თუ თქვენი web სერვერი მუშაობს გამართულად. დააჭირეთ ღილაკებს LED-ების გასაკონტროლებლად.
ამავდროულად, შეგიძლიათ გადახედოთ სერიულ მონიტორს, რომ ნახოთ რა ხდება ფონზე. მაგampროდესაც დააჭირეთ ღილაკს GPIO 26-ის ჩართვისთვის, ESP32 იღებს მოთხოვნას /26/on URL.
როდესაც ESP32 მიიღებს ამ მოთხოვნას, ის ჩართავს GPIO 26-ზე დამაგრებულ LED-ს და განაახლებს მის მდგომარეობას web გვერდი.
GPIO 27-ის ღილაკი ანალოგიურად მუშაობს. შეამოწმეთ, რომ ის გამართულად მუშაობს.
როგორ მუშაობს კოდი
ამ განყოფილებაში უფრო დეტალურად განვიხილავთ კოდს, რომ ნახოთ როგორ მუშაობს.
პირველი რაც უნდა გააკეთოთ არის WiFi ბიბლიოთეკის ჩართვა.
როგორც უკვე აღვნიშნეთ, თქვენ უნდა ჩაწეროთ თქვენი ssid და პაროლი შემდეგ სტრიქონებში ორმაგი ბრჭყალების შიგნით.
შემდეგ, თქვენ დააყენეთ თქვენი web სერვერი 80 პორტზე.
შემდეგი ხაზი ქმნის ცვლადს HTTP მოთხოვნის სათაურის შესანახად:
შემდეგი, თქვენ ქმნით დამხმარე ცვლადებს თქვენი შედეგების მიმდინარე მდგომარეობის შესანახად. თუ გსურთ დაამატოთ მეტი გამოსავალი და შეინახოთ მისი მდგომარეობა, თქვენ უნდა შექმნათ მეტი ცვლადი.
თქვენ ასევე უნდა მიანიჭოთ GPIO თქვენს თითოეულ გამომავალს. აქ ჩვენ ვიყენებთ GPIO 26 და GPIO 27. შეგიძლიათ გამოიყენოთ ნებისმიერი სხვა შესაფერისი GPIO.
დაყენება ()
ახლა მოდით გადავიდეთ setup(). პირველი, ჩვენ ვიწყებთ სერიულ კომუნიკაციას ბაუდის სიჩქარით 115200 გამართვის მიზნით.
თქვენ ასევე განსაზღვრავთ თქვენს GPIO-ებს, როგორც OUTPUT-ებს და დააყენებთ მათ LOW-ზე.
შემდეგი ხაზები იწყებს Wi-Fi კავშირს WiFi.begin-ით (ssid, პაროლი), დაელოდეთ წარმატებულ კავშირს და დაბეჭდეთ ESP IP მისამართი სერიულ მონიტორში.
loop ()
loop()-ში ვაპროგრამებთ რა ხდება, როდესაც ახალი კლიენტი ამყარებს კავშირს web სერვერი.
ESP32 ყოველთვის უსმენს შემომავალ კლიენტებს შემდეგი ხაზით:
როდესაც მოთხოვნა მიიღება კლიენტისგან, ჩვენ შევინახავთ შემოსულ მონაცემებს. ხოლო შემდეგ ციკლი იმუშავებს მანამ, სანამ კლიენტი დაკავშირებულია. ჩვენ არ გირჩევთ შეცვალოთ კოდის შემდეგი ნაწილი, თუ ზუსტად არ იცით რას აკეთებთ.
if და else განცხადებების შემდეგი განყოფილება ამოწმებს, რომელ ღილაკზე იყო დაჭერილი web გვერდზე და შესაბამისად აკონტროლებს გამომავალს. როგორც ადრე ვნახეთ, ჩვენ ვთხოვთ განსხვავებულს URLs დამოკიდებულია დაჭერილ ღილაკზე.
მაგampთუ დააჭირეთ ღილაკს GPIO 26 ON, ESP32 მიიღებს მოთხოვნას /26/ON URL (ჩვენ ვხედავთ, რომ ეს ინფორმაცია HTTP სათაურზე სერიულ მონიტორზე). ამრიგად, ჩვენ შეგვიძლია შევამოწმოთ, შეიცავს თუ არა სათაური გამოხატულებას GET /26/on. თუ ის შეიცავს, ჩვენ ვცვლით output26state ცვლადს ON-ზე და ESP32 ჩართავს LED-ს.
ეს მუშაობს ანალოგიურად სხვა ღილაკებისთვის. ასე რომ, თუ გსურთ დაამატოთ მეტი გამომავალი, თქვენ უნდა შეცვალოთ კოდის ეს ნაწილი, რომ შეიცავდეს მათ.
HTML-ის ჩვენება web გვერდი
შემდეგი, რაც უნდა გააკეთოთ, არის შექმნა web გვერდი. ESP32 გამოგიგზავნით პასუხს თქვენს ბრაუზერს გარკვეული HTML კოდით, რომ შექმნათ web გვერდი.
The web გვერდი ეგზავნება კლიენტს ამ გამოხატვის კლიენტს.println(). არგუმენტად უნდა შეიყვანოთ ის, რისი გაგზავნა გსურთ კლიენტისთვის.
პირველი, რაც უნდა გავაგზავნოთ, ყოველთვის არის შემდეგი ხაზი, რომელიც მიუთითებს, რომ ჩვენ ვაგზავნით HTML-ს.
შემდეგ, შემდეგი ხაზი ქმნის web გვერდი რეაგირებს ნებისმიერში web ბრაუზერი.
და შემდეგი გამოიყენება ფავიკონზე მოთხოვნების თავიდან ასაცილებლად. – თქვენ არ გჭირდებათ ამ ხაზის ფიქრი.
სტილისტიკა Web გვერდი
შემდეგი, ჩვენ გვაქვს რამდენიმე CSS ტექსტი ღილაკების და სტილისთვის web გვერდის გამოჩენა.
ჩვენ ვირჩევთ Helvetica შრიფტს, განვსაზღვრავთ შიგთავსს, რომელიც უნდა იყოს ნაჩვენები ბლოკად და გავასწოროთ ცენტრში.
ჩვენ ღილაკებს ვაწყობთ #4CAF50 ფერით, საზღვრების გარეშე, ტექსტით თეთრი ფერით და ამ ბალიშით: 16px 40px. ჩვენ ასევე ვაყენებთ ტექსტის დეკორაციას None-ზე, განვსაზღვრავთ შრიფტის ზომას, ზღვარს და კურსორს მაჩვენებელზე.
ჩვენ ასევე განვსაზღვრავთ მეორე ღილაკის სტილს, ღილაკის ყველა თვისებით, რომელიც ადრე განვსაზღვრეთ, მაგრამ განსხვავებული ფერით. ეს იქნება გამორთვის ღილაკის სტილი.
დაყენება Web გვერდის პირველი სათაური
შემდეგ სტრიქონში შეგიძლიათ დააყენოთ თქვენი პირველი სათაური web გვერდი. აქ ჩვენ გვაქვს "ESP32 Web სერვერი", მაგრამ თქვენ შეგიძლიათ შეცვალოთ ეს ტექსტი რაც მოგწონთ.
ღილაკების და შესაბამისი მდგომარეობის ჩვენება
შემდეგ, თქვენ წერთ აბზაცს GPIO 26-ის მიმდინარე მდგომარეობის საჩვენებლად. როგორც ხედავთ, ჩვენ ვიყენებთ output26State ცვლადს, რათა მდგომარეობა მყისიერად განახლდეს, როდესაც ეს ცვლადი იცვლება.
შემდეგ, ჩვენ ვაჩვენებთ ჩართვის ან გამორთვის ღილაკს, რაც დამოკიდებულია GPIO-ს ამჟამინდელ მდგომარეობაზე. თუ GPIO-ის ამჟამინდელი მდგომარეობა გამორთულია, ჩვენ ვაჩვენებთ ON ღილაკს, თუ არა, ჩვენ ვაჩვენებთ OFF ღილაკს.
ჩვენ ვიყენებთ იგივე პროცედურას GPIO 27-ისთვის.
კავშირის დახურვა
ბოლოს, როდესაც პასუხი დასრულდება, ჩვენ ვასუფთავებთ სათაურის ცვლადს და ვწყვეტთ კლიენტთან კავშირს client.stop().
შეფუთვა
ამ გაკვეთილში ჩვენ გაჩვენეთ, თუ როგორ უნდა ააწყოთ ა web სერვერი ESP32-ით. ჩვენ გაჩვენეთ უბრალო ყოფილიample, რომელიც აკონტროლებს ორ LED-ს, მაგრამ იდეა არის შეცვალოს ეს LED-ები რელეთი, ან ნებისმიერი სხვა გამოსავალი, რომლის კონტროლიც გსურთ.
პროექტი 6 RGB LED Web სერვერი
ამ პროექტში ჩვენ გაჩვენებთ, თუ როგორ დისტანციურად მართოთ RGB LED ESP32 დაფით. web სერვერი ფერის ამომრჩეველით.
პროექტი დასრულდაview
სანამ დავიწყებთ, ვნახოთ, როგორ მუშაობს ეს პროექტი:
- ESP32 web სერვერი აჩვენებს ფერის ამომრჩეველს.
- როდესაც თქვენ აირჩევთ ფერს, თქვენი ბრაუზერი აკეთებს მოთხოვნას a URL რომელიც შეიცავს არჩეული ფერის R, G და B პარამეტრებს.
- თქვენი ESP32 იღებს მოთხოვნას და ყოფს მნიშვნელობას თითოეული ფერის პარამეტრისთვის.
- შემდეგ, ის აგზავნის PWM სიგნალს შესაბამისი მნიშვნელობით GPIO-ებზე, რომლებიც აკონტროლებენ RGB LED-ს.
როგორ მუშაობს RGB LED-ები?
საერთო კათოდური RGB LED-ში სამივე LED იზიარებს ნეგატიურ კავშირს (კათოდი). ყველა კომპლექტში შედის საერთო კათოდური RGB.
როგორ შევქმნათ სხვადასხვა ფერები?
RGB LED-ით, რა თქმა უნდა, შეგიძლიათ აწარმოოთ წითელი, მწვანე და ლურჯი შუქი და თითოეული LED-ის ინტენსივობის კონფიგურაციით, შეგიძლიათ სხვა ფერების წარმოებაც.
მაგampწმინდა ლურჯი შუქის წარმოებისთვის, თქვენ დააყენეთ ლურჯი LED უმაღლეს ინტენსივობაზე და მწვანე და წითელი LED-ები ყველაზე დაბალ ინტენსივობაზე. თეთრი განათებისთვის, თქვენ დააყენეთ სამივე LED უმაღლეს ინტენსივობაზე.
ფერების შერევა
სხვა ფერების შესაქმნელად, შეგიძლიათ დააკავშიროთ სამი ფერი სხვადასხვა ინტენსივობით. თითოეული LED-ის ინტენსივობის დასარეგულირებლად შეგიძლიათ გამოიყენოთ PWM სიგნალი.
იმის გამო, რომ LED-ები ძალიან ახლოს არიან ერთმანეთთან, ჩვენი თვალები ხედავს ფერების შერწყმის შედეგს და არა ცალ-ცალკე სამ ფერს.
იმისათვის, რომ გქონდეთ იდეა, თუ როგორ დააკავშიროთ ფერები, შეხედეთ შემდეგ სქემას.
ეს არის უმარტივესი ფერების შერევის სქემა, მაგრამ გაძლევთ წარმოდგენას, თუ როგორ მუშაობს იგი და როგორ აწარმოოთ სხვადასხვა ფერები.
საჭირო ნაწილები
ამ პროექტისთვის გჭირდებათ შემდეგი ნაწილები:
- ESP32 DEVKIT V1 დაფა
- RGB LED
- 3 x 220 ohm რეზისტორები
- ჯუმპერის მავთულები
- პურის დაფა
სქემატური
კოდი
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
- ESP32 დანამატის ინსტალაცია Arduino IDE-ში
მიკროსქემის აწყობის შემდეგ გახსენით კოდი
პროექტი_6_RGB_LED_Web_Server.ino arduino IDE-ში.
კოდის ატვირთვამდე არ დაგავიწყდეთ თქვენი ქსელის რწმუნებათა სიგელების ჩასმა, რათა ESP-მ შეძლოს თქვენს ლოკალურ ქსელთან დაკავშირება.
როგორ მუშაობს კოდი
ESP32 ესკიზი იყენებს WiFi.h ბიბლიოთეკას.
შემდეგი ხაზები განსაზღვრავს სტრიქონების ცვლადებს R, G და B პარამეტრების შესანახად მოთხოვნიდან.
შემდეგი ოთხი ცვლადი გამოიყენება მოგვიანებით HTTP მოთხოვნის გაშიფვრისთვის.
შექმენით სამი ცვლადი GPIO-სთვის, რომლებიც გააკონტროლებენ ზოლებს R, G და B პარამეტრებს. ამ შემთხვევაში ჩვენ ვიყენებთ GPIO 13, GPIO 12 და GPIO 14.
ამ GPIO-ებს PWM სიგნალების გამოშვება სჭირდება, ამიტომ ჯერ PWM თვისებების კონფიგურაცია გვჭირდება. დააყენეთ PWM სიგნალის სიხშირე 5000 ჰც. შემდეგ, დააკავშირეთ PWM არხი თითოეული ფერისთვის
და ბოლოს, დააყენეთ PWM არხების გარჩევადობა 8 ბიტიანზე
setup()-ში მიანიჭეთ PWM თვისებები PWM არხებს
მიამაგრეთ PWM არხები შესაბამის GPIO-ებზე
კოდის შემდეგი განყოფილება აჩვენებს ფერის ამომრჩეველს თქვენსში web გვერდზე და აკეთებს მოთხოვნას თქვენს მიერ არჩეული ფერის მიხედვით.
როდესაც ირჩევთ ფერს, იღებთ მოთხოვნას შემდეგი ფორმატით.
ასე რომ, ჩვენ უნდა გავყოთ ეს სტრიქონი, რომ მივიღოთ R, G და B პარამეტრები. პარამეტრები ინახება redString, greenString და blueString ცვლადებში და შეიძლება ჰქონდეს მნიშვნელობები 0-დან 255-მდე.
ზოლის ESP32-ით გასაკონტროლებლად გამოიყენეთ ledcWrite() ფუნქცია PWM სიგნალების გენერირებისთვის HTTP-დან დეკოდირებული მნიშვნელობებით. მოთხოვნა.
შენიშვნა: შეიტყვეთ მეტი PWM-ის შესახებ ESP32-ით: პროექტი 3 ESP32 PWM (ანალოგური გამომავალი)
ზოლის გასაკონტროლებლად ESP8266, ჩვენ უბრალოდ უნდა გამოვიყენოთ
analogWrite() ფუნქცია PWM სიგნალების გენერირებისთვის HTPP მოთხოვნიდან დეკოდირებული მნიშვნელობებით.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
იმის გამო, რომ ჩვენ ვიღებთ მნიშვნელობებს string ცვლადში, ჩვენ უნდა გადავიყვანოთ ისინი მთელ რიცხვებად toInt() მეთოდის გამოყენებით.
დემონსტრაცია
თქვენი ქსელის რწმუნებათა სიგელების ჩასმის შემდეგ, აირჩიეთ მარჯვენა დაფა და COM პორტი და ატვირთეთ კოდი თქვენს ESP32-ზე. ატვირთვის კოდის მითითების ნაბიჯები.
ატვირთვის შემდეგ გახსენით სერიული მონიტორი ბაუდის სიჩქარით 115200 და დააჭირეთ ღილაკს ESP Enable/Reset. თქვენ უნდა მიიღოთ დაფის IP მისამართი.
გახსენით თქვენი ბრაუზერი და ჩადეთ ESP IP მისამართი. ახლა გამოიყენეთ ფერის ამომრჩევი RGB LED-ისთვის ფერის ასარჩევად.
შემდეგ, თქვენ უნდა დააჭიროთ ღილაკს "ფერის შეცვლა", რომ ფერი ამოქმედდეს.
RGB LED-ის გამორთვისთვის აირჩიეთ შავი ფერი.
ყველაზე ძლიერი ფერები (ფერების ამომრჩევის ზედა ნაწილში) არის ის, რაც უკეთეს შედეგს გამოიღებს.
პროექტი 7 ESP32 რელე Web სერვერი
ESP32-ით რელეს გამოყენება შესანიშნავი გზაა AC საყოფაცხოვრებო ტექნიკის დისტანციურად მართვისთვის. ეს სახელმძღვანელო განმარტავს, თუ როგორ უნდა მართოთ სარელეო მოდული ESP32-ით.
ჩვენ გადავხედავთ, თუ როგორ მუშაობს სარელეო მოდული, როგორ დავაკავშიროთ რელე ESP32-თან და ავაშენოთ web სერვერი რელეს დისტანციურად გასაკონტროლებლად.
რელეების გაცნობა
რელე არის ელექტრომომარაგებული გადამრთველი და როგორც ნებისმიერი სხვა გადამრთველი, ის შეიძლება ჩართოთ ან გამორთოთ, დენი გაუშვას თუ არა. მისი კონტროლი შესაძლებელია დაბალი მოცულობითtages, ისევე როგორც ESP3.3 GPIO-ების მიერ მოწოდებული 32 ვ და გვაძლევს საშუალებას ვაკონტროლოთ მაღალი მოცულობისtagროგორიცაა 12V, 24V ან ქსელის მოცtage (230V ევროპაში და 120V აშშ-ში).
მარცხენა მხარეს არის სამი სოკეტის ორი კომპლექტი მაღალი მოცულობის დასაკავშირებლადtages და ქინძისთავები მარჯვენა მხარეს (დაბალი მოცულობითtagე) დაუკავშირდით ESP32 GPIO-ს.
Mains Voltage კავშირები
წინა ფოტოზე ნაჩვენები სარელეო მოდულს აქვს ორი კონექტორი, თითოეულს აქვს სამი სოკეტი: საერთო (COM), ნორმალურად დახურული (NC) და ნორმალურად ღია (NO).
- COM: შეაერთეთ დენი, რომლის კონტროლიც გსურთ (ქსელის ტtagდა).
- NC (ნორმალურად დახურულია): ჩვეულებრივ დახურული კონფიგურაცია გამოიყენება, როდესაც გსურთ რელე დახურული იყოს ნაგულისხმევად. NC არის COM ქინძისთავები დაკავშირებულია, რაც ნიშნავს, რომ დენი მიედინება, თუ არ გაუგზავნით სიგნალს ESP32-დან სარელეო მოდულზე, რომ გაიხსნას წრე და შეაჩეროს დენის ნაკადი.
- NO (ნორმალურად ღია): ჩვეულებრივ ღია კონფიგურაცია მუშაობს პირიქით: არ არის კავშირი NO და COM ქინძისთავებს შორის, ამიტომ წრე წყდება, თუ არ გამოგიგზავნით სიგნალს ESP32-დან წრედის დახურვისთვის.
საკონტროლო ქინძისთავები
დაბალი მოცულობისtage მხარეს აქვს ოთხი ქინძისთავის ნაკრები და სამი ქინძისთავის ნაკრები. პირველი ნაკრები შედგება VCC და GND-ისგან მოდულის გასააქტიურებლად და შეყვანის 1 (IN1) და შეყვანის 2 (IN2) ქვედა და ზედა რელეების გასაკონტროლებლად, შესაბამისად.
თუ თქვენს სარელეო მოდულს აქვს მხოლოდ ერთი არხი, გექნებათ მხოლოდ ერთი IN პინი. თუ თქვენ გაქვთ ოთხი არხი, გექნებათ ოთხი IN პინი და ა.შ.
სიგნალი, რომელსაც თქვენ უგზავნით IN ქინძისთავებს, განსაზღვრავს რელე აქტიურია თუ არა. რელე ამოქმედდება, როდესაც შემავალი ჩადის დაახლოებით 2 ვ-ზე დაბლა. ეს ნიშნავს, რომ თქვენ გექნებათ შემდეგი სცენარები:
- ჩვეულებრივ დახურული კონფიგურაცია (NC):
- მაღალი სიგნალი - დენი მიედინება
- დაბალი სიგნალი - დენი არ მიედინება
- ჩვეულებრივ ღია კონფიგურაცია (NO):
- მაღალი სიგნალი - დენი არ მიედინება
- დაბალი სიგნალი - დენი მიედინება
თქვენ უნდა გამოიყენოთ ჩვეულებრივ დახურული კონფიგურაცია, როდესაც დენი უნდა მიედინება უმეტეს დროს და მხოლოდ ზოგჯერ გსურთ მისი შეჩერება.
გამოიყენეთ ჩვეულებრივ ღია კონფიგურაცია, როდესაც გსურთ დენი დროდადრო შემოვიდეს (მაგampლე, ჩართეთ ალamp ხანდახან).
კვების წყაროს შერჩევა
ქინძისთავების მეორე ნაკრები შედგება GND, VCC და JD-VCC ქინძისთავებისაგან.
JD-VCC პინი კვებავს რელეს ელექტრომაგნიტს. გაითვალისწინეთ, რომ მოდულს აქვს ჯუმპერის თავსახური, რომელიც აკავშირებს VCC და JD-VCC ქინძისთავებს; აქ ნაჩვენები არის ყვითელი, მაგრამ თქვენი შეიძლება იყოს განსხვავებული ფერი.
ჯუმპერის თავსახურით, VCC და JD-VCC ქინძისთავები დაკავშირებულია. ეს ნიშნავს, რომ სარელეო ელექტრომაგნიტი იკვებება პირდაპირ ESP32 დენის პინიდან, ამიტომ რელეს მოდული და ESP32 სქემები ფიზიკურად არ არიან ერთმანეთისგან იზოლირებული.
ჯუმპერის თავსახურის გარეშე, თქვენ უნდა მიაწოდოთ დამოუკიდებელი დენის წყარო რელეს ელექტრომაგნიტის გასააქტიურებლად JD-VCC პინის მეშვეობით. ეს კონფიგურაცია ფიზიკურად იზოლირებს რელეებს ESP32-დან მოდულის ჩაშენებული ოპტოკუპლერით, რომელიც ხელს უშლის ESP32-ის დაზიანებას ელექტრული მწვერვალების შემთხვევაში.
სქემატური
გაფრთხილება: მაღალი მოცულობის გამოყენებაtagელექტრომომარაგებამ შეიძლება გამოიწვიოს სერიოზული დაზიანება.
ამიტომ, 5 მმ LED-ები გამოიყენება მაღალი მიწოდების მოცულობის ნაცვლადtagე ნათურები ექსპერიმენტში. თუ არ იცნობთ ქსელის ტომსtagსთხოვეთ ვინმეს, ვინც დაგეხმარებათ. ESP-ის დაპროგრამების ან თქვენი მიკროსქემის გაყვანილობისას დარწმუნდით, რომ ყველაფერი გათიშულია ქსელიდანtage.
ბიბლიოთეკის ინსტალაცია ESP32-ისთვის
ამის ასაშენებლად web სერვერზე, ჩვენ ვიყენებთ ESPAsync-სWebსერვერის ბიბლიოთეკა და AsyncTCP ბიბლიოთეკა.
ESPAsync-ის ინსტალაციაWebსერვერის ბიბლიოთეკა
მიჰყევით შემდეგ ნაბიჯებს ინსტალაციისთვის ESPAsyncWebსერვერი ბიბლიოთეკა:
- დააწკაპუნეთ აქ ESPAsync-ის ჩამოსატვირთადWebსერვერის ბიბლიოთეკა. უნდა გქონდეს
.zip საქაღალდე თქვენს ჩამოტვირთვების საქაღალდეში - გახსენით .zip საქაღალდე და თქვენ უნდა მიიღოთ ESPAsyncWebServer-Master საქაღალდე
- თქვენი საქაღალდის გადარქმევა ESPAsync-დანWebსერვერის ოსტატი ESPAsync-ზეWebსერვერი
- გადაიტანეთ ESPAsyncWebსერვერის საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
ალტერნატიულად, თქვენს Arduino IDE-ში შეგიძლიათ გადახვიდეთ Sketch > Include
ბიბლიოთეკა > დაამატეთ .ZIP ბიბლიოთეკა… და აირჩიეთ ბიბლიოთეკა, რომელიც ახლახან გადმოწერეთ.
AsyncTCP ბიბლიოთეკის ინსტალაცია ESP32-ისთვის
The ESPAsyncWebსერვერი ბიბლიოთეკა მოითხოვს AsyncTCP ბიბლიოთეკა სამუშაოდ. მიჰყევით
შემდეგი ნაბიჯები ამ ბიბლიოთეკის ინსტალაციისთვის:
- დააწკაპუნეთ აქ AsyncTCP ბიბლიოთეკის ჩამოსატვირთად. ჩამოტვირთვების საქაღალდეში უნდა გქონდეთ .zip საქაღალდე
- გახსენით .zip საქაღალდე და თქვენ უნდა მიიღოთ AsyncTCP-master საქაღალდე
1. თქვენი საქაღალდის გადარქმევა AsyncTCP-master-დან AsyncTCP
3. გადაიტანეთ AsyncTCP საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
4. და ბოლოს, ხელახლა გახსენით თქვენი Arduino IDE
ალტერნატიულად, თქვენს Arduino IDE-ში შეგიძლიათ გადახვიდეთ Sketch > Include
ბიბლიოთეკა > დაამატეთ .ZIP ბიბლიოთეკა… და აირჩიეთ ბიბლიოთეკა, რომელიც ახლახან გადმოწერეთ.
კოდი
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
საჭირო ბიბლიოთეკების დაყენების შემდეგ გახსენით კოდი Project_7_ESP32_Relay_Web_Server.ino arduino IDE-ში.
კოდის ატვირთვამდე არ დაგავიწყდეთ თქვენი ქსელის რწმუნებათა სიგელების ჩასმა, რათა ESP-მ შეძლოს თქვენს ლოკალურ ქსელთან დაკავშირება.
დემონსტრაცია
საჭირო ცვლილებების განხორციელების შემდეგ, ატვირთეთ კოდი თქვენს ESP32-ზე. ატვირთვის კოდის მითითების ნაბიჯები.
გახსენით სერიული მონიტორი ბაუდის სიჩქარით 115200 და დააჭირეთ ESP32 EN ღილაკს მისი IP მისამართის მისაღებად. შემდეგ გახსენით ბრაუზერი თქვენს ლოკალურ ქსელში და აკრიფეთ ESP32 IP მისამართი, რომ მიიღოთ წვდომა web სერვერი.
გახსენით სერიული მონიტორი ბაუდის სიჩქარით 115200 და დააჭირეთ ESP32 EN ღილაკს მისი IP მისამართის მისაღებად. შემდეგ გახსენით ბრაუზერი თქვენს ლოკალურ ქსელში და აკრიფეთ ESP32 IP მისამართი, რომ მიიღოთ წვდომა web სერვერი.
შენიშვნა: თქვენი ბრაუზერი და ESP32 უნდა იყოს დაკავშირებული იმავე LAN-თან.
თქვენ უნდა მიიღოთ ისეთი რამ, როგორიცაა ორი ღილაკი, როგორც თქვენს კოდში განსაზღვრული რელეების რაოდენობა.
ახლა თქვენ შეგიძლიათ გამოიყენოთ ღილაკები თქვენი სმარტფონის გამოყენებით რელეების გასაკონტროლებლად.
Project_8_Output_State_Synchronization_ Web_ სერვერი
ეს პროექტი გვიჩვენებს, თუ როგორ უნდა აკონტროლოთ ESP32 ან ESP8266 გამომავალი ა web სერვერი და ფიზიკური ღილაკი ერთდროულად. გამომავალი მდგომარეობა განახლებულია web გვერდის შეცვლა ფიზიკური ღილაკით თუ web სერვერი.
პროექტი დასრულდაview
მოდით შევხედოთ როგორ მუშაობს პროექტი.
ESP32 ან ESP8266 მასპინძლებს ა web სერვერი, რომელიც საშუალებას გაძლევთ აკონტროლოთ გამომავალი მდგომარეობა;
- მიმდინარე გამომავალი მდგომარეობა ნაჩვენებია web სერვერი;
- ESP ასევე დაკავშირებულია ფიზიკურ ღილაკთან, რომელიც აკონტროლებს იმავე გამომავალს;
- თუ თქვენ შეცვლით გამომავალ მდგომარეობას ფიზიკური ღილაკის გამოყენებით, მისი ამჟამინდელი მდგომარეობა ასევე განახლდება web სერვერი.
მოკლედ, ეს პროექტი საშუალებას გაძლევთ აკონტროლოთ იგივე გამომავალი ა web სერვერი და ღილაკი ერთდროულად. როდესაც გამომავალი მდგომარეობა იცვლება, web სერვერი განახლებულია.
საჭირო ნაწილები
აქ მოცემულია იმ ნაწილების სია, რომლებიც გჭირდებათ მიკროსქემის შესაქმნელად:
- ESP32 DEVKIT V1 დაფა
- 5 მმ LED
- 220 Ohm რეზისტორი
- ღილაკი
- 10k Ohm რეზისტორი
- პურის დაფა
- ჯუმპერის მავთულები
სქემატური
ბიბლიოთეკის ინსტალაცია ESP32-ისთვის
ამის ასაშენებლად web სერვერზე, ჩვენ ვიყენებთ ESPAsync-სWebსერვერის ბიბლიოთეკა და AsyncTCP ბიბლიოთეკა. (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESPAsync-ის ინსტალაციაWebსერვერის ბიბლიოთეკა
მიჰყევით შემდეგ ნაბიჯებს ESPAsync-ის ინსტალაციისთვისWebსერვერის ბიბლიოთეკა:
- დააწკაპუნეთ აქ ESPAsync-ის ჩამოსატვირთადWebსერვერის ბიბლიოთეკა. უნდა გქონდეს
.zip საქაღალდე თქვენს ჩამოტვირთვების საქაღალდეში - გახსენით .zip საქაღალდე და თქვენ უნდა მიიღოთ ESPAsyncWebServer-Master საქაღალდე
- თქვენი საქაღალდის გადარქმევა ESPAsync-დანWebსერვერის ოსტატი ESPAsync-ზეWebსერვერი
- გადაიტანეთ ESPAsyncWebსერვერის საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
ალტერნატიულად, თქვენს Arduino IDE-ში შეგიძლიათ გადახვიდეთ Sketch > Include
ბიბლიოთეკა > დაამატეთ .ZIP ბიბლიოთეკა… და აირჩიეთ ბიბლიოთეკა, რომელიც ახლახან გადმოწერეთ.
AsyncTCP ბიბლიოთეკის ინსტალაცია ESP32-ისთვის
ESPAsyncWebსერვერის ბიბლიოთეკა მოითხოვს AsyncTCP ბიბლიოთეკის მუშაობას. მიჰყევით შემდეგ ნაბიჯებს ამ ბიბლიოთეკის ინსტალაციისთვის:
- დააწკაპუნეთ აქ AsyncTCP ბიბლიოთეკის ჩამოსატვირთად. ჩამოტვირთვების საქაღალდეში უნდა გქონდეთ .zip საქაღალდე
- გახსენით .zip საქაღალდე და თქვენ უნდა მიიღოთ AsyncTCP-master საქაღალდე
- თქვენი საქაღალდის გადარქმევა AsyncTCP-master-დან AsyncTCP
- გადაიტანეთ AsyncTCP საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
- და ბოლოს, ხელახლა გახსენით თქვენი Arduino IDE
ალტერნატიულად, თქვენს Arduino IDE-ში შეგიძლიათ გადახვიდეთ Sketch > Include
ბიბლიოთეკა > დაამატეთ .ZIP ბიბლიოთეკა… და აირჩიეთ ბიბლიოთეკა, რომელიც ახლახან გადმოწერეთ.
კოდი
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
საჭირო ბიბლიოთეკების დაყენების შემდეგ გახსენით კოდი
Project_8_Output_State_Synchronization_Web_Server.ino arduino IDE-ში.
კოდის ატვირთვამდე არ დაგავიწყდეთ თქვენი ქსელის რწმუნებათა სიგელების ჩასმა, რათა ESP-მ შეძლოს თქვენს ლოკალურ ქსელთან დაკავშირება.
როგორ მუშაობს კოდი
ღილაკის მდგომარეობა და გამომავალი მდგომარეობა
ledState ცვლადი ინახავს LED გამომავალი მდგომარეობას. ნაგულისხმევად, როდესაც web სერვერი იწყება, ის დაბალია.
ღილაკსState და lastButtonState გამოიყენება იმის დასადგენად, დაჭერილი იყო თუ არა ღილაკი.
ღილაკი (web სერვერი)
ჩვენ არ ჩავურთეთ HTML ღილაკის შესაქმნელად index_html ცვლადზე.
ეს იმიტომ ხდება, რომ ჩვენ გვსურს მისი შეცვლა არსებული LED მდგომარეობიდან გამომდინარე, რომელიც ასევე შეიძლება შეიცვალოს ღილაკით.
ასე რომ, ჩვენ შევქმენით ჩანაცვლების ველი ღილაკისთვის %BUTTONPLACEHOLDER%, რომელიც შეიცვლება HTML ტექსტით, რათა შეიქმნას ღილაკი მოგვიანებით კოდზე (ეს კეთდება პროცესორის() ფუნქციაში).
პროცესორი ()
პროცესორი() ფუნქცია ცვლის HTML ტექსტის ნებისმიერ ადგილსამყოფელს რეალური მნიშვნელობებით. პირველ რიგში, ის ამოწმებს შეიცავს თუ არა HTML ტექსტებს რაიმე
ჩანაცვლების ადგილი %BUTTONPLACEHOLDER%.
შემდეგ გამოიძახეთ theoutputState() ფუნქცია, რომელიც აბრუნებს მიმდინარე გამომავალ მდგომარეობას. ჩვენ ვინახავთ მას outputStateValue ცვლადში.
ამის შემდეგ, გამოიყენეთ ეს მნიშვნელობა HTML ტექსტის შესაქმნელად, რათა აჩვენოთ ღილაკი სწორი მდგომარეობით:
HTTP GET მოთხოვნა გამომავალი მდგომარეობის შესაცვლელად (JavaScript)
ღილაკზე დაჭერისას გამოიძახება ფუნქცია thetoggleCheckbox(). ეს ფუნქცია დააყენებს მოთხოვნას სხვადასხვაზე URLs ჩართოთ ან გამორთოთ LED.
LED-ის ჩასართავად ის ითხოვს /update?state=1-ს URL:
წინააღმდეგ შემთხვევაში, ის აკეთებს მოთხოვნას /update?state=0-ზე URL.
HTTP GET სტატუსის განახლების მოთხოვნა (JavaScript)
გამომავალი მდგომარეობის განახლების მიზნით web სერვერზე, ჩვენ ვუწოდებთ შემდეგ ფუნქციას, რომელიც აკეთებს ახალ მოთხოვნას /state-ზე URL ყოველ წამს.
მოთხოვნების დამუშავება
შემდეგ, ჩვენ უნდა მოვაგვაროთ რა მოხდება, როდესაც ESP32 ან ESP8266 მიიღებს მოთხოვნებს მათზე URLs.
როდესაც მოთხოვნა მიიღება root-ზე /URL, ვაგზავნით როგორც HTML გვერდს, ასევე პროცესორს.
შემდეგი სტრიქონები ამოწმებს, მიიღეთ თუ არა მოთხოვნა /update?state=1 ან /update?state=0-ზე URL და შესაბამისად ცვლის ledState-ს.
როდესაც მოთხოვნა მიიღება /state-ზე URL, ჩვენ ვაგზავნით მიმდინარე გამომავალ მდგომარეობას:
loop ()
მარყუჟში(), ჩვენ ვახდენთ ღილაკს და ჩართავთ ან გამორთავთ LED-ს ledState-ის მნიშვნელობიდან გამომდინარე. ცვლადი.
დემონსტრაცია
ატვირთეთ კოდი თქვენს ESP32 დაფაზე. ატვირთეთ კოდის მითითების ნაბიჯები.
შემდეგ გახსენით სერიული მონიტორი ბაუდის სიჩქარით 115200. დააჭირეთ ბორტზე EN/RST ღილაკს IP მისამართის მისაღებად.
გახსენით ბრაუზერი თქვენს ლოკალურ ქსელში და ჩაწერეთ ESP IP მისამართი. თქვენ უნდა გქონდეთ წვდომა web სერვერი, როგორც ნაჩვენებია ქვემოთ.
შენიშვნა: თქვენი ბრაუზერი და ESP32 უნდა იყოს დაკავშირებული იმავე LAN-თან.
თქვენ შეგიძლიათ გადართოთ ღილაკი web სერვერი LED-ის ჩართვისთვის.
თქვენ ასევე შეგიძლიათ მართოთ იგივე LED ფიზიკური ღილაკით. მისი მდგომარეობა ყოველთვის ავტომატურად განახლდება web სერვერი.
პროექტი 9 ESP32 DHT11 Web სერვერი
ამ პროექტში თქვენ შეისწავლით თუ როგორ უნდა შექმნათ ასინქრონული ESP32 web სერვერი DHT11-ით, რომელიც აჩვენებს ტემპერატურასა და ტენიანობას Arduino IDE-ის გამოყენებით.
წინაპირობები
The web სერვერი ჩვენ ავაშენებთ განახლებებს კითხვას ავტომატურად, განახლების საჭიროების გარეშე web გვერდი.
ამ პროექტით თქვენ შეისწავლით:
- როგორ წავიკითხოთ ტემპერატურა და ტენიანობა DHT სენსორებიდან;
- ასინქრონულის აშენება web სერვერის გამოყენებით ESPAsyncWebსერვერის ბიბლიოთეკა;
- განაახლეთ სენსორის წაკითხვები ავტომატურად, განახლების საჭიროების გარეშე web გვერდი.
ასინქრონული Web სერვერი
ასაშენებლად web სერვერი, რომელსაც ჩვენ გამოვიყენებთ ESPAsyncWebსერვერის ბიბლიოთეკა რომელიც უზრუნველყოფს მარტივ გზას ასინქრონული სისტემის შესაქმნელად web სერვერი. ასინქრონულის აგება web სერვერს აქვს რამდენიმე ადვანსიtages როგორც აღნიშნულია ბიბლიოთეკის GitHub გვერდზე, როგორიცაა:
- "ერთზე მეტი კავშირის დამუშავება ერთდროულად";
- „როდესაც პასუხს აგზავნით, მაშინვე მზად ხართ სხვა კავშირების დასამუშავებლად, სანამ სერვერი ზრუნავს პასუხის ფონზე გაგზავნაზე“;
- „მარტივი შაბლონის დამუშავების ძრავა შაბლონების დასამუშავებლად“;
საჭირო ნაწილები
ამ გაკვეთილის დასასრულებლად გჭირდებათ შემდეგი ნაწილები:
- ESP32 განვითარების დაფა
- DHT11 მოდული
- პურის დაფა
- ჯუმპერის მავთულები
სქემატური
ბიბლიოთეკების ინსტალაცია
თქვენ უნდა დააინსტალიროთ რამდენიმე ბიბლიოთეკა ამ პროექტისთვის:
- The DHT და Adafruit ერთიანი სენსორი დრაივერის ბიბლიოთეკები DHT სენსორიდან წასაკითხად.
- ESPAsyncWebსერვერი და ასინქრონული TCP ბიბლიოთეკები ასინქრონულის შესაქმნელად web სერვერი.
მიჰყევით შემდეგ ინსტრუქციას ამ ბიბლიოთეკების დასაყენებლად:
DHT სენსორის ბიბლიოთეკის ინსტალაცია
DHT სენსორიდან Arduino IDE-ს გამოყენებით წასაკითხად, თქვენ უნდა დააინსტალიროთ DHT სენსორის ბიბლიოთეკა. მიჰყევით შემდეგ ნაბიჯებს ბიბლიოთეკის ინსტალაციისთვის.
- დააწკაპუნეთ აქ DHT სენსორის ბიბლიოთეკის ჩამოსატვირთად. ჩამოტვირთვების საქაღალდეში უნდა გქონდეთ .zip საქაღალდე
- გახსენით .zip საქაღალდე და თქვენ უნდა მიიღოთ DHT-sensor-library-master საქაღალდე
- დაარქვით თქვენი საქაღალდე DHT-sensor-library-master-დან DHT_sensor
- გადაიტანეთ DHT_sensor საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
- და ბოლოს, ხელახლა გახსენით თქვენი Arduino IDE
Adafruit Unified Sensor Driver-ის დაყენება
თქვენ ასევე უნდა დააინსტალიროთ Adafruit Unified Sensor Driver ბიბლიოთეკა DHT სენსორთან მუშაობისთვის. მიჰყევით შემდეგ ნაბიჯებს ბიბლიოთეკის ინსტალაციისთვის.
- დააწკაპუნეთ აქ, რომ ჩამოტვირთოთ Adafruit Unified Sensor ბიბლიოთეკა. ჩამოტვირთვების საქაღალდეში უნდა გქონდეთ .zip საქაღალდე
- გახსენით .zip საქაღალდე და თქვენ უნდა მიიღოთ Adafruit_sensor-master საქაღალდე
- დაარქვით თქვენი საქაღალდე Adafruit_sensor-master-ით Adafruit_sensor
- გადაიტანეთ Adafruit_sensor საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
- და ბოლოს, ხელახლა გახსენით თქვენი Arduino IDE
ESPAsync-ის ინსტალაციაWebსერვერის ბიბლიოთეკა
მიჰყევით შემდეგ ნაბიჯებს ინსტალაციისთვის ESPAsyncWebსერვერი ბიბლიოთეკა:
- დააწკაპუნეთ აქ ESPAsync-ის ჩამოსატვირთადWebსერვერის ბიბლიოთეკა. უნდა გქონდეს
.zip საქაღალდე თქვენს ჩამოტვირთვების საქაღალდეში - გახსენით .zip საქაღალდე და თქვენ უნდა
მიიღეთ ESPAsyncWebServer-Master საქაღალდე - თქვენი საქაღალდის გადარქმევა ESPAsync-დანWebსერვერის ოსტატი ESPAsync-ზეWebსერვერი
- გადაიტანეთ ESPAsyncWebსერვერის საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
Async TCP ბიბლიოთეკის ინსტალაცია ESP32-ისთვის
The ESPAsyncWebსერვერი ბიბლიოთეკა მოითხოვს AsyncTCP ბიბლიოთეკა სამუშაოდ. მიჰყევით შემდეგ ნაბიჯებს ამ ბიბლიოთეკის ინსტალაციისთვის:
- დააწკაპუნეთ აქ AsyncTCP ბიბლიოთეკის ჩამოსატვირთად. ჩამოტვირთვების საქაღალდეში უნდა გქონდეთ .zip საქაღალდე
- გახსენით .zip საქაღალდე და თქვენ უნდა მიიღოთ AsyncTCP-master საქაღალდე
- თქვენი საქაღალდის გადარქმევა AsyncTCP-master-დან AsyncTCP
- გადაიტანეთ AsyncTCP საქაღალდე თქვენს Arduino IDE ინსტალაციის ბიბლიოთეკების საქაღალდეში
- და ბოლოს, ხელახლა გახსენით თქვენი Arduino IDE
კოდი
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
საჭირო ბიბლიოთეკების დაყენების შემდეგ გახსენით კოდი
პროექტი_9_ESP32_DHT11_Web_Server.ino arduino IDE-ში.
კოდის ატვირთვამდე არ დაგავიწყდეთ თქვენი ქსელის რწმუნებათა სიგელების ჩასმა, რათა ESP-მ შეძლოს თქვენს ლოკალურ ქსელთან დაკავშირება.
როგორ მუშაობს კოდი
შემდეგ აბზაცებში ჩვენ აგიხსნით როგორ მუშაობს კოდი. განაგრძეთ კითხვა, თუ გსურთ გაიგოთ მეტი ან გადადით დემონსტრაციის განყოფილებაში, რომ ნახოთ საბოლოო შედეგი.
ბიბლიოთეკების იმპორტი
პირველი, შემოიტანეთ საჭირო ბიბლიოთეკები. WiFi, ESPAsyncWebსერვერი და ESPAsyncTCP საჭიროა ასაშენებლად web სერვერი. Adafruit_Sensor და DHT ბიბლიოთეკები საჭიროა DHT11 ან DHT22 სენსორებიდან წასაკითხად.
ცვლადების განმარტება
განსაზღვრეთ GPIO, რომელსაც DHT მონაცემთა პინი უკავშირდება. ამ შემთხვევაში, ის დაკავშირებულია GPIO 4-თან.
შემდეგ აირჩიეთ DHT სენსორის ტიპი, რომელსაც იყენებთ. ჩვენს ყოფილშიampჩვენ ვიყენებთ DHT22-ს. თუ თქვენ იყენებთ სხვა ტიპს, თქვენ უბრალოდ უნდა გააუქმოთ თქვენი სენსორი და კომენტარი გააკეთოთ ყველა დანარჩენზე.
შექმენით DHT ობიექტის ტიპი და პინი, რომელიც ადრე განვსაზღვრეთ.
შექმენით ასინქრონულიWebსერვერის ობიექტი 80 პორტზე.
წაიკითხეთ ტემპერატურისა და ტენიანობის ფუნქციები
ჩვენ შევქმენით ორი ფუნქცია: ერთი ტემპერატურის წასაკითხად ჩვენ შევქმენით ორი ფუნქცია: ერთი ტემპერატურის წასაკითხად (readDHTTemperature()) და მეორე ტენიანობის წასაკითხად (readDHTHumidity()).
სენსორის წაკითხვის მიღება ისეთივე მარტივია, როგორც გამოყენება სენსორის წაკითხვის მიღება ისეთივე მარტივია, როგორც readTemperature() და readHumidity() მეთოდების გამოყენება dht ობიექტზე.
ჩვენ ასევე გვაქვს პირობა, რომელიც აბრუნებს ორ ტირეს (–) იმ შემთხვევაში, თუ სენსორი ვერ მიიღებს კითხვებს.
წაკითხვები ბრუნდება სტრიქონის ტიპად. float სტრინგად გადასაყვანად გამოიყენეთ String() ფუნქცია
ნაგულისხმევად, ჩვენ ვკითხულობთ ტემპერატურას ცელსიუს გრადუსებში. იმისათვის, რომ მიიღოთ ტემპერატურა ფარენჰეიტის გრადუსებში, დააკომენტარეთ ტემპერატურა ცელსიუსში და გააუქმეთ ტემპერატურა ფარენჰეიტში, ასე რომ თქვენ გაქვთ შემდეგი:
ატვირთეთ კოდი
ახლა ატვირთეთ კოდი თქვენს ESP32-ზე. დარწმუნდით, რომ არჩეული გაქვთ სწორი დაფა და COM პორტი. ატვირთეთ კოდის მითითების ნაბიჯები.
ატვირთვის შემდეგ გახსენით სერიული მონიტორი ბაუდის სიხშირით 115200. დააჭირეთ ESP32 გადატვირთვის ღილაკს. ESP32 IP მისამართი უნდა იყოს დაბეჭდილი სერიულად მონიტორი.
დემონსტრაცია
გახსენით ბრაუზერი და ჩაწერეთ ESP32 IP მისამართი. შენი web სერვერმა უნდა აჩვენოს უახლესი სენსორის წაკითხვები.
შენიშვნა: თქვენი ბრაუზერი და ESP32 უნდა იყოს დაკავშირებული იმავე LAN-თან.
გაითვალისწინეთ, რომ ტემპერატურისა და ტენიანობის ჩვენებები განახლდება ავტომატურად, განახლების საჭიროების გარეშე web გვერდი.
Project_10_ESP32_OLED_Display
ეს პროექტი გვიჩვენებს, თუ როგორ გამოიყენოთ 0.96 დიუმიანი SSD1306 OLED დისპლეი ESP32-ით Arduino IDE-ის გამოყენებით.
წარმოგიდგენთ 0.96 დიუმიანი OLED ეკრანი
The OLED დისპლეი რომელსაც ამ სახელმძღვანელოში გამოვიყენებთ არის SSD1306 მოდელი: მონოკოლური, 0.96 დიუმიანი დისპლეი 128×64 პიქსელით, როგორც ნაჩვენებია შემდეგ სურათზე.
OLED დისპლეი არ საჭიროებს უკანა განათებას, რაც იწვევს ძალიან კარგ კონტრასტს ბნელ გარემოში. გარდა ამისა, მისი პიქსელები ენერგიას მოიხმარენ მხოლოდ ჩართულის დროს, ამიტომ OLED დისპლეი მოიხმარს ნაკლებ ენერგიას სხვა ეკრანებთან შედარებით.
იმის გამო, რომ OLED დისპლეი იყენებს I2C საკომუნიკაციო პროტოკოლს, გაყვანილობა ძალიან მარტივია. თქვენ შეგიძლიათ გამოიყენოთ შემდეგი ცხრილი, როგორც მითითება.
| OLED პინი | ESP32 |
| ვინ | 3.3 ვ |
| GND | GND |
| SCL | GPIO 22 |
| SDA | GPIO 21 |
სქემატური
SSD1306 OLED ბიბლიოთეკის ინსტალაცია – ESP32
არსებობს რამდენიმე ბიბლიოთეკა OLED დისპლეის გასაკონტროლებლად ESP32-ით.
ამ სახელმძღვანელოში ჩვენ გამოვიყენებთ Adafruit-ის ორ ბიბლიოთეკას: Adafruit_SSD1306 ბიბლიოთეკა და Adafruit_GFX ბიბლიოთეკა.
მიჰყევით შემდეგ ნაბიჯებს ამ ბიბლიოთეკების დასაყენებლად.
- გახსენით თქვენი Arduino IDE და გადადით Sketch > Include Library > Manage Library. ბიბლიოთეკის მენეჯერი უნდა გაიხსნას.
- ჩაწერეთ „SSD1306“ საძიებო ველში და დააინსტალირეთ SSD1306 ბიბლიოთეკა Adafruit-დან.
- Adafruit-ისგან SSD1306 ბიბლიოთეკის დაყენების შემდეგ საძიებო ველში ჩაწერეთ „GFX“ და დააინსტალირეთ ბიბლიოთეკა.
- ბიბლიოთეკების დაყენების შემდეგ, გადატვირთეთ თქვენი Arduino IDE.
კოდი
საჭირო ბიბლიოთეკების დაყენების შემდეგ გახსენით Project_10_ESP32_OLED_Display.ino arduino IDE-ში. კოდი
ჩვენ დავაპროგრამებთ ESP32-ს Arduino IDE-ს გამოყენებით, ამიტომ დარწმუნდით, რომ დაინსტალირებული გაქვთ ESP32 დანამატი სანამ გააგრძელებთ: (თუ ეს ნაბიჯი უკვე გააკეთეთ, შეგიძლიათ გადახვიდეთ შემდეგ ეტაპზე.)
ESP32 დანამატის ინსტალაცია Arduino IDE-ში
როგორ მუშაობს კოდი
ბიბლიოთეკების იმპორტი
პირველ რიგში, თქვენ უნდა შემოიტანოთ საჭირო ბიბლიოთეკები. Wire ბიბლიოთეკა I2C-ის გამოსაყენებლად და Adafruit ბიბლიოთეკები ეკრანზე დასაწერად: Adafruit_GFX და Adafruit_SSD1306.
OLED დისპლეის ინიციალიზაცია
შემდეგ, თქვენ განსაზღვრავთ თქვენს OLED სიგანეს და სიმაღლეს. ამ ყოფილშიampჩვენ ვიყენებთ 128×64 OLED ეკრანს. თუ თქვენ იყენებთ სხვა ზომებს, შეგიძლიათ შეცვალოთ ეს SCREEN_WIDTH და SCREEN_HEIGHT ცვლადებში.
შემდეგ, ინიციალიზაცია მოახდინეთ დისპლეის ობიექტის სიგანე და სიმაღლე, რომელიც ადრე იყო განსაზღვრული I2C საკომუნიკაციო პროტოკოლით (&Wire).
(-1) პარამეტრი ნიშნავს, რომ თქვენს OLED ეკრანს არ აქვს RESET pin. თუ თქვენს OLED ეკრანს აქვს RESET pin, ის უნდა იყოს დაკავშირებული GPIO-სთან. ამ შემთხვევაში, პარამეტრად უნდა გადასცეთ GPIO ნომერი.
setup()-ში მოაწყეთ სერიული მონიტორი 115200 ბაუდის სიჩქარით გამართვის მიზნით.
OLED დისპლეის ინიცირება დაიწყეთ () მეთოდით შემდეგნაირად:
ეს ფრაგმენტი ასევე ბეჭდავს შეტყობინებას სერიულ მონიტორზე, იმ შემთხვევაში, თუ ჩვენ ვერ შევძლებთ ეკრანთან დაკავშირებას.
თუ თქვენ იყენებთ სხვა OLED ეკრანს, შეიძლება დაგჭირდეთ OLED მისამართის შეცვლა. ჩვენს შემთხვევაში, მისამართი არის 0x3C.
ეკრანის ინიციალიზაციის შემდეგ დაამატეთ ორი წამის შეფერხება, რათა OLED-ს ჰქონდეს საკმარისი დრო ინიციალიზაციისთვის ტექსტის დაწერამდე:
ეკრანის გასუფთავება, შრიფტის ზომის, ფერის დაყენება და ტექსტის დაწერა
ეკრანის ინიციალიზაციის შემდეგ გაასუფთავეთ ეკრანის ბუფერი clearDisplay() მეთოდით:
ტექსტის დაწერამდე, თქვენ უნდა დააყენოთ ტექსტის ზომა, ფერი და ადგილი, სადაც ტექსტი იქნება ნაჩვენები OLED-ში.
დააყენეთ შრიფტის ზომა setTextSize() მეთოდის გამოყენებით:
დააყენეთ შრიფტის ფერი setTextColor() მეთოდით:
WHITE ადგენს თეთრ შრიფტს და შავ ფონს.
განსაზღვრეთ პოზიცია, სადაც ტექსტი იწყება setCursor(x,y) მეთოდის გამოყენებით. ამ შემთხვევაში, ჩვენ ვაყენებთ ტექსტის დაწყებას (0,0) კოორდინატებიდან - ზედა მარცხენა კუთხეში.
და ბოლოს, თქვენ შეგიძლიათ გაგზავნოთ ტექსტი ეკრანზე println() მეთოდის გამოყენებით, შემდეგნაირად
შემდეგ, თქვენ უნდა გამოიძახოთ display() მეთოდი, რათა რეალურად გამოჩნდეს ტექსტი ეკრანზე.
Adafruit OLED ბიბლიოთეკა გთავაზობთ სასარგებლო მეთოდებს ტექსტის მარტივად გადახვევისთვის.
- startscrollright (0x00, 0x0F): გადაახვიეთ ტექსტი მარცხნიდან მარჯვნივ
- startscrollleft (0x00, 0x0F): გადაახვიეთ ტექსტი მარჯვნიდან მარცხნივ
- startscrolldiagright(0x00, 0x07): გადაახვიეთ ტექსტი მარცხენა ქვედა კუთხიდან მარჯვენა ზედა კუთხეში startscrolldiagleft(0x00, 0x07): გადაახვიეთ ტექსტი ქვედა მარჯვენა კუთხიდან მარცხენა ზედა კუთხეში
ატვირთეთ კოდი
ახლა, ატვირთეთ კოდი თქვენს ESP32-ზე. ატვირთეთ კოდის მითითების ნაბიჯები.
კოდის ატვირთვის შემდეგ, OLED აჩვენებს გადახვევის ტექსტს.
დოკუმენტები / რესურსები
 |
LAFVIN ESP32 საბაზისო სასტარტო ნაკრები [pdf] ინსტრუქციის სახელმძღვანელო ESP32 საბაზისო სასტარტო ნაკრები, ESP32, საბაზისო სასტარტო ნაკრები, სასტარტო ნაკრები |