ESP32 Основен стартер
Комплект
Опаковъчен лист
ESP32 Въведение
Нови за ESP32? Започнете тук! ESP32 е серия от евтини и нискоенергийни микроконтролери System on a Chip (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 (за съхранение на данни и основен процесор по време на 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 преобразувания, напрample, по време на дълбок сън.
Периферен вход/изход:
- периферен интерфейс с DMA, който включва капацитивен сензор
- ADC (аналогово-цифров преобразувател)
- ЦАП (цифрово-аналогов преобразувател)
- 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 GHz до 150 Mbits/s |
| Bluetooth | BLE (Bluetooth Low Energy) и наследен Bluetooth |
| Архитектура | 32 бита |
| Тактова честота | До 240 MHz |
| RAM | 512 KB |
| Карфици | 30 (в зависимост от модела) |
| Периферни устройства | Капацитивен сензорен, ADC (аналогово-цифров преобразувател), DAC (цифрово-аналогов преобразувател), 12C (междуинтегрална схема), UART (универсален асинхронен приемник/предавател), CAN 2.0 (мрежа на зоната на контролера), SPI (сериен периферен интерфейс) , 12S (Интегриран Inter-IC Звук), RMII (намален независим от медиите интерфейс), PWM (модулация на ширината на импулса) и др. |
| Вградени бутони | Бутони RESET и BOOT |
| Вградени светодиоди | вграден син светодиод, свързан към GPIO2; вграден червен светодиод, който показва, че платката се захранва |
| USB към UART мост |
CP2102 |
Предлага се с microUSB интерфейс, който можете да използвате, за да свържете платката към вашия компютър, за да качите код или да подадете захранване.
Той използва чипа CP2102 (USB към UART), за да комуникира с вашия компютър чрез COM порт, използвайки сериен интерфейс. Друг популярен чип е CH340. Проверете какъв е преобразувателят на USB към UART чип на вашата платка, защото ще трябва да инсталирате необходимите драйвери, за да може компютърът ви да комуникира с платката (повече информация за това по-късно в това ръководство).
Тази платка също така идва с бутон RESET (може да бъде обозначен с EN) за рестартиране на платката и бутон BOOT за поставяне на платката в мигащ режим (достъпен за получаване на код). Имайте предвид, че някои платки може да нямат бутон BOOT.
Той също така идва с вграден син светодиод, който е вътрешно свързан към GPIO 2. Този светодиод е полезен за отстраняване на грешки, за да даде някакъв вид визуален физически изход. Има и червен светодиод, който светва, когато подадете захранване към платката.
ESP32 Pinout
Периферните устройства ESP32 включват:
- 18 канала за аналогово-цифров преобразувател (ADC).
- 3 SPI интерфейса
- 3 UART интерфейса
- 2 I2C интерфейса
- 16 ШИМ изходни канала
- 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 | свързан към бордовия светодиод, трябва да бъде оставен да свети или НИСКО, за да влезе в мигащ режим |
| 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 светкавица, интегрирана в 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)
Капацитивни сензорни GPIO
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 има само 1 x 10 бита 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 V или между 3.2 и 3.3 V. Трябва да имате това предвид, когато използвате ADC щифтовете. Ще получите поведение, подобно на показаното на следващата фигура.
Цифрово-аналогов преобразувател (DAC)
Има 2 x 8 бита DAC канала на ESP32 за преобразуване на цифрови сигнали в аналогови обемиtage сигнални изходи. Това са DAC каналите:
- DAC1 (GPIO25)
- DAC2 (GPIO26)
RTC GPIO
Има поддръжка на RTC GPIO на ESP32. GPIO, насочени към RTC подсистемата с ниска мощност, могат да се използват, когато ESP32 е в дълбок сън. Тези RTC GPIO могат да се използват за събуждане на ESP32 от дълбок сън, когато Ultra Low
Мощният (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)
ШИМ
Контролерът ESP32 LED PWM има 16 независими канала, които могат да бъдат конфигурирани да генерират PWM сигнали с различни свойства. Всички щифтове, които могат да действат като изходи, могат да се използват като щифтове за ШИМ (GPIO 34 до 39 не могат да генерират ШИМ).
За да зададете PWM сигнал, трябва да дефинирате тези параметри в кода:
- Честота на сигнала;
- Работен цикъл;
- ШИМ канал;
- GPIO, където искате да изведете сигнала.
I2C
ESP32 има два I2C канала и всеки щифт може да бъде зададен като SDA или SCL. Когато използвате ESP32 с Arduino IDE, I2C щифтовете по подразбиране са:
- GPIO 21 (SDA)
- GPIO 22 (SCL)
Ако искате да използвате други пинове, когато използвате библиотеката с кабели, просто трябва да се обадите:
Wire.begin(SDA, SCL);
SPI
По подразбиране картографирането на пиновете за SPI е:
| SPI | МОСИ | Мишо | CLK | CS |
| VSPI | GPIO 23 | GPIO 19 | GPIO 18 | GPIO 5 |
| HSPI | GPIO 13 | GPIO 12 | GPIO 14 | GPIO 15 |
прекъсвания
Всички GPIO могат да бъдат конфигурирани като прекъсвания.
Щифтове за ремъци
Чипът ESP32 има следните закрепващи щифтове:
- GPIO 0 (трябва да е LOW за влизане в режим на зареждане)
- GPIO 2 (трябва да е плаващ или LOW по време на зареждане)
- GPIO 4
- GPIO 5 (трябва да е HIGH по време на зареждане)
- GPIO 12 (трябва да е НИСКО по време на зареждане)
- GPIO 15 (трябва да е HIGH по време на зареждане)
Те се използват за поставяне на ESP32 в режим на зареждане или мигане. При повечето платки за разработка с вграден USB/сериен порт не е нужно да се притеснявате за състоянието на тези щифтове. Платката поставя щифтовете в правилното състояние за режим на мигане или зареждане. Повече информация относно избора на режим на стартиране на ESP32 можете да намерите тук.
Въпреки това, ако имате периферни устройства, свързани към тези щифтове, може да имате проблеми с опитите за качване на нов код, флашване на ESP32 с нов фърмуер или нулиране на платката. Ако имате някои периферни устройства, свързани към щифтовете за свързване и имате проблеми с качването на код или мигането на ESP32, това може да се дължи на това, че тези периферни устройства пречат на ESP32 да влезе в правилния режим. Прочетете документацията за избор на режим на зареждане, за да ви насочи в правилната посока. След нулиране, мигане или зареждане тези щифтове работят според очакванията.
Пинове ВИСОКО при зареждане
Някои 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.3 V. Той е издърпан нагоре, така че свържете към земята, за да деактивирате регулатора на 3.3 V. Това означава, че можете да използвате този щифт, свързан към бутон, за да рестартирате вашия 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 Filesystem Uploader Plugin), които все още не се поддържат от Arduino 2. Така че, ако възнамерявате да използвате SPIFFS плъгина в бъдеще, препоръчваме да инсталирате наследената версия 1.8.X. Просто трябва да превъртите надолу в страницата на софтуера Arduino, за да го намерите.
Инсталиране на добавка ESP32 в Arduino IDE
За да инсталирате платката ESP32 във вашето Arduino IDE, следвайте следните инструкции:
- Във вашата Arduino IDE отидете на File> Предпочитания
- Въведете следното в „Additional Board Manager 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 следвайте тези стъпки:
- Изберете вашата платка в менюто Инструменти > Платка (в моя случай това е 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 por, изпълнете следните стъпки:
Задръжте бутона „BOOT“ на вашата ESP32 платка
- Натиснете бутона „Качване“ в Arduino IDE, за да качите вашата скица:
- След като видите „Свързване...“ съобщение във вашата Arduino IDE, пуснете пръста от бутона „BOOT“:
- След това трябва да видите съобщението „Готово на качването“.
Това е. Вашият ESP32 трябва да стартира новата скица. Натиснете бутона “ENABLE”, за да рестартирате ESP32 и стартирате новата качена скица.
Също така ще трябва да повтаряте тази последователност от бутони всеки път, когато искате да качите нова скица.
Проект 1 ESP32 Входове Изходи
В това начално ръководство ще научите как да четете цифрови входове като бутонен превключвател и да управлявате цифрови изходи като светодиод с помощта на ESP32 с Arduino IDE.
Предпоставки
Ще програмираме ESP32 с помощта на Arduino IDE. Така че, уверете се, че имате инсталирана добавка за платки ESP32, преди да продължите:
- Инсталиране на добавка ESP32 в Arduino IDE
ESP32 Контролни цифрови изходи
Първо, трябва да зададете GPIO, който искате да контролирате като ИЗХОД. Използвайте функцията pinMode(), както следва:
pinMode(GPIO, ИЗХОД);
За да контролирате цифров изход, просто трябва да използвате функцията digitalWrite(), която приема като аргументи GPIO (int номер), към който се отнасяте, и състоянието, или HIGH, или LOW.
digitalWrite(GPIO, STATE);
Всички GPIO могат да се използват като изходи с изключение на GPIO 6 до 11 (свързани към интегрираната SPI флаш памет) и GPIO 34, 35, 36 и 39 (само входни GPIO);
Научете повече за ESP32 GPIO: Справочно ръководство за ESP32 GPIO
ESP32 Четене на цифрови входове
Първо задайте GPIO, който искате да прочетете като INPUT, като използвате функцията pinMode(), както следва:
pinMode(GPIO, INPUT);
За да прочетете цифров вход, като бутон, вие използвате функцията digitalRead(), която приема като аргумент GPIO (int номер), към който се отнасяте.
цифрово четене (GPIO);
Всички ESP32 GPIO могат да се използват като входове, с изключение на GPIO от 6 до 11 (свързани към интегрираната SPI флаш).
Научете повече за ESP32 GPIO: Справочно ръководство за ESP32 GPIO
Проект Прample
За да ви покажем как да използвате цифрови входове и цифрови изходи, ще изградим прост проект напрample с бутон и светодиод. Ще прочетем състоянието на бутона и ще светнем съответно светодиода, както е показано на следващата фигура.
Необходими части
Ето списък на частите, от които се нуждаете, за да изградите веригата:
- ESP32 DEVKIT V1
- 5 mm LED
- Резистор 220 ома
- Натисни бутона
- Резистор 10k Ohm
- Бредборд
- Джъмперни проводници
Схематична диаграма
Преди да продължите, трябва да сглобите верига със светодиод и бутон.
Ще свържем светодиода към GPIO 5 и бутона към GPIO 4.
Код
Отворете кода Project_1_ESP32_Inputs_Outputs.ino в arduino IDE
Как работи кодът
В следващите два реда създавате променливи за присвояване на щифтове:
Бутонът е свързан към GPIO 4, а светодиодът е свързан към GPIO 5. Когато използвате Arduino IDE с ESP32, 4 съответства на GPIO 4, а 5 съответства на GPIO 5.
След това създавате променлива за задържане на състоянието на бутона. По подразбиране е 0 (не е натиснат).
int buttonState = 0;
В setup() инициализирате бутона като INPUT, а светодиода като OUTPUT.
За това използвате функцията pinMode(), която приема щифта, за който се отнасяте, и режима: INPUT или OUTPUT.
pinMode(бутонPin, INPUT);
pinMode(ledPin, ИЗХОД);
В loop() е мястото, където четете състоянието на бутона и съответно настройвате светодиода.
В следващия ред четете състоянието на бутона и го записвате в променливата buttonState.
Както видяхме по-рано, вие използвате функцията digitalRead().
buttonState = digitalRead(buttonPin);
Следният оператор if проверява дали състоянието на бутона е HIGH. Ако е така, той включва светодиода с помощта на функцията digitalWrite(), която приема като аргумент ledPin и състоянието HIGH.
ако (buttonState == HIGH)
Ако състоянието на бутона не е HIGH, изключвате светодиода. Просто задайте LOW като втори аргумент във функцията digitalWrite().
Качване на кода
Преди да щракнете върху бутона за качване, отидете на Инструменти > Дъска и изберете дъската :DOIT ESP32 DEVKIT V1.
Отидете на Инструменти > Порт и изберете COM порта, към който е свързан ESP32. След това натиснете бутона за качване и изчакайте съобщението „Готово на качването“.
Забележка: Ако видите много точки (свързване…__…__) в прозореца за отстраняване на грешки и съобщението „Неуспешно свързване с ESP32: Времето за чакане за заглавката на пакета изтече“, това означава, че трябва да натиснете ESP32 вградения BOOT бутон след точките
започват да се появяват. Отстраняване на неизправности
Демонстрация
След като качите кода, тествайте вашата верига. Вашият светодиод трябва да светне, когато натиснете бутона:
И изключете, когато го пуснете:
Проект 2 ESP32 Аналогови входове
Този проект показва как да четете аналогови входове с ESP32 с помощта на Arduino IDE.
Аналоговото четене е полезно за четене на стойности от променливи резистори като потенциометри или аналогови сензори.
Аналогови входове (ADC)
Четенето на аналогова стойност с ESP32 означава, че можете да измервате различни обемиtage нива между 0 V и 3.3 V.
ТомътtagСлед това измереното e се присвоява на стойност между 0 и 4095, в която 0 V съответства на 0, а 3.3 V съответства на 4095. Всеки об.tage между 0 V и 3.3 V ще бъде дадена съответната стойност между тях.
ADC е нелинеен
В идеалния случай бихте очаквали линейно поведение, когато използвате щифтовете ESP32 ADC.
Това обаче не се случва. Това, което ще получите, е поведение, както е показано в следната диаграма:
Това поведение означава, че вашият ESP32 не може да различи 3.3 V от 3.2 V.
Ще получите една и съща стойност и за двата voltages: 4095.
Същото се случва и при много нисък обемtage стойности: за 0 V и 0.1 V ще получите една и съща стойност: 0. Трябва да имате това предвид, когато използвате щифтовете ESP32 ADC.
Функция analogRead().
Четенето на аналогов вход с ESP32 с помощта на Arduino IDE е толкова просто, колкото използването на функцията analogRead(). Той приема като аргумент GPIO, който искате да прочетете:
analogRead(GPIO);
Само 15 са налични в DEVKIT V1board (версия с 30 GPIO).
Вземете разводката на вашата платка ESP32 и намерете щифтовете на ADC. Те са подчертани с червена рамка на фигурата по-долу.
Тези аналогови входни щифтове имат 12-битова резолюция. Това означава, че когато четете аналогов вход, неговият диапазон може да варира от 0 до 4095.
Забележка: ADC2 пинове не могат да се използват, когато се използва Wi-Fi. Така че, ако използвате Wi-Fi и имате проблеми с получаването на стойността от ADC2 GPIO, можете да обмислите използването на ADC1 GPIO вместо това, което трябва да реши проблема ви.
За да видим как всичко се свързва, ще направим прост примерample за четене на аналогова стойност от потенциометър.
Необходими части
За този бившample, имате нужда от следните части:
- Платка ESP32 DEVKIT V1
- Потенциометър
- Бредборд
- Джъмперни проводници
Схематичен
Свържете потенциометър към вашия ESP32. Средният щифт на потенциометъра трябва да бъде свързан към GPIO 4. Можете да използвате следната схематична диаграма като справка.
Код
Ние ще програмираме ESP32 с помощта на Arduino IDE, така че се уверете, че имате инсталирана добавка ESP32, преди да продължите: (Ако вече сте направили тази стъпка, можете да преминете към следващата стъпка.)
Инсталиране на добавка ESP32 в Arduino IDE
Отворете кода Project_2_ESP32_Inputs_Outputs.ino в arduino IDE
Този код просто чете стойностите от потенциометъра и отпечатва тези стойности в серийния монитор.
В кода започвате с дефиниране на GPIO, към който е свързан потенциометърът. В този бившample, GPIO 4.
В setup() инициализирайте серийна комуникация при скорост на предаване от 115200 бода.
В цикъла () използвайте функцията analogRead(), за да прочетете аналоговия вход от potPin.
Накрая отпечатайте стойностите, отчетени от потенциометъра в серийния монитор.
Качете предоставения код на вашия ESP32. Уверете се, че сте избрали правилната платка и COM порт в менюто Инструменти.
Тестване на Example
След като качите кода и натиснете бутона за нулиране на 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 V или между 3.2 и 3.3 V. Трябва да имате това предвид, когато използвате ADC щифтовете.
Проект 3 ESP32 PWM (аналогов изход)
В този урок ще ви покажем как да генерирате PWM сигнали с ESP32 с помощта на Arduino IDE. Като бившampще изградим проста схема, която затъмнява светодиод с помощта на LED PWM контролера на ESP32.
ESP32 LED PWM контролер
ESP32 има LED PWM контролер с 16 независими канала, които могат да бъдат конфигурирани да генерират PWM сигнали с различни свойства.
Ето стъпките, които трябва да следвате, за да затъмните светодиод с PWM с помощта на Arduino IDE:
- Първо, трябва да изберете ШИМ канал. Има 16 канала от 0 до 15.
- След това трябва да зададете честотата на PWM сигнала. За светодиод е добре да се използва честота от 5000 Hz.
- Трябва също така да зададете резолюцията на работния цикъл на сигнала: имате резолюции от 1 до 16 бита. Ще използваме 8-битова разделителна способност, което означава, че можете да контролирате яркостта на LED с помощта на стойност от 0 до 255.
- След това трябва да посочите към кои GPIO или GPIO ще се появи сигналът. За целта ще използвате следната функция:
ledcAttachPin(GPIO, канал)
Тази функция приема два аргумента. Първият е GPIO, който ще изведе сигнала, а вторият е каналът, който ще генерира сигнала. - И накрая, за да контролирате яркостта на светодиода с помощта на ШИМ, използвате следната функция:
ledcWrite(канал, работен цикъл)
Тази функция приема като аргументи канала, който генерира ШИМ сигнала, и работния цикъл.
Необходими части
За да следвате този урок, имате нужда от следните части:
- Платка ESP32 DEVKIT V1
- 5mm LED
- Резистор 220 ома
- Бредборд
- Джъмперни проводници
Схематичен
Свържете светодиод към вашия ESP32, както е показано на следната схематична диаграма. Светодиодът трябва да бъде свързан към GPIO 4.
Забележка: можете да използвате всеки щифт, който искате, стига да може да действа като изход. Всички щифтове, които могат да действат като изходи, могат да се използват като щифтове за PWM. За повече информация относно ESP32 GPIO, прочетете: ESP32 Pinout Reference: Кои GPIO пинове трябва да използвате?
Код
Ние ще програмираме ESP32 с помощта на Arduino IDE, така че се уверете, че имате инсталирана добавка ESP32, преди да продължите: (Ако вече сте направили тази стъпка, можете да преминете към следващата стъпка.)
Инсталиране на добавка ESP32 в Arduino IDE
Отворете кода Project_3_ESP32_PWM.ino в arduino IDE
Започвате с определяне на щифта, към който е прикрепен светодиодът. В този случай светодиодът е свързан към GPIO 4.
След това задавате свойствата на PWM сигнала. Определяте честота от 5000 Hz, избирате канал 0 за генериране на сигнала и задавате разделителна способност от 8 бита. Можете да изберете други свойства, различни от тези, за генериране на различни PWM сигнали.
В setup() трябва да конфигурирате LED PWM със свойствата, които сте дефинирали по-рано, като използвате функцията ledcSetup(), която приема като аргументи ledChannel, честотата и разделителната способност, както следва:
След това трябва да изберете GPIO, от който ще получите сигнала. За това използвайте функцията ledcAttachPin(), която приема като аргументи GPIO, където искате да получите сигнала, и канала, който генерира сигнала. В този бившample, ще получим сигнала в ledPin GPIO, който съответства на GPIO 4. Каналът, който генерира сигнала, е ledChannel, който съответства на канал 0.
В цикъла ще променяте работния цикъл между 0 и 255, за да увеличите яркостта на светодиода.
И след това между 255 и 0, за да намалите яркостта.
За да зададете яркостта на светодиода, просто трябва да използвате функцията ledcWrite(), която приема като аргументи канала, който генерира сигнала, и работния цикъл.
Тъй като използваме 8-битова разделителна способност, работният цикъл ще се контролира чрез стойност от 0 до 255. Имайте предвид, че във функцията ledcWrite() използваме канала, който генерира сигнала, а не GPIO.
Тестване на Example
Качете кода на вашия ESP32. Уверете се, че сте избрали правилната платка и COM порт. Погледнете веригата си. Трябва да имате по-слаб светодиод, който увеличава и намалява яркостта.
Проект 4 ESP32 PIR сензор за движение
Този проект показва как да откриете движение с ESP32 с помощта на PIR сензор за движение. Зумерът ще издаде аларма, когато бъде открито движение, и ще спре алармата, когато не бъде открито движение за предварително зададено време (като 4 секунди)
Как работи сензорът за движение HC-SR501
.
Принципът на работа на сензора HC-SR501 се основава на промяната на инфрачервеното лъчение върху движещия се обект. За да бъде открит от сензора HC-SR501, обектът трябва да отговаря на две изисквания:
- Обектът излъчва инфрачервени лъчи.
- Обектът се движи или трепери
Така че:
Ако обект излъчва инфрачервени лъчи, но не се движи (напр. човек стои неподвижно, без да се движи), той не се открива от сензора.
Ако обект се движи, но не излъчва инфрачервени лъчи (напр. робот или превозно средство), той НЕ се открива от сензора.
Представяме ви таймери
В този бившampще въведем и таймери. Искаме светодиодът да остане включен за предварително определен брой секунди след засичане на движение. Вместо да използваме функция delay(), която блокира вашия код и не ви позволява да правите нищо друго за определен брой секунди, трябва да използваме таймер.
Функцията delay().
Трябва да сте запознати с функцията delay(), тъй като тя се използва широко. Тази функция е доста лесна за използване. Той приема едно цяло число като аргумент.
Това число представлява времето в милисекунди, което програмата трябва да изчака, докато премине към следващия ред код.
Когато направите delay(1000), вашата програма спира на този ред за 1 секунда.
delay() е блокираща функция. Блокиращите функции не позволяват на програмата да прави каквото и да е друго, докато тази конкретна задача не бъде завършена. Ако имате нужда от няколко задачи, които да се изпълняват едновременно, не можете да използвате delay().
За повечето проекти трябва да избягвате използването на забавяния и вместо това да използвате таймери.
Функцията millis().
С помощта на функция, наречена millis(), можете да върнете броя милисекунди, изминали от първото стартиране на програмата.
Защо тази функция е полезна? Тъй като с помощта на някаква математика можете лесно да проверите колко време е минало, без да блокирате кода си.
Необходими части
За да следвате този урок, имате нужда от следните части
- Платка ESP32 DEVKIT V1
- PIR сензор за движение (HC-SR501)
- Активен зумер
- Джъмперни проводници
- Бредборд
Схематичен
Забележка: Работният обtage на HC-SR501 е 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 секунди зумерът трябва да се изключи.
Превключвател Project 5 ESP32 Web сървър
В този проект ще създадете самостоятелен web сървър с ESP32, който контролира изходите (два светодиода), използвайки средата за програмиране Arduino IDE. The web сървърът отговаря на мобилни устройства и може да бъде достъпен с всяко устройство, което е като браузър в локалната мрежа. Ще ви покажем как да създадете web сървър и как кодът работи стъпка по стъпка.
Проектът приключиview
Преди да преминем направо към проекта, е важно да очертаем какво е нашето web сървърът ще свърши работа, така че да е по-лесно да следвате стъпките по-късно.
- The web сървърът, който ще изградите, управлява два светодиода, свързани към ESP32 GPIO 26 и GPIO 27;
- Можете да получите достъп до ESP32 web сървър, като въведете IP адреса на ESP32 в браузър в локалната мрежа;
- Като щракнете върху бутоните на вашия web сървър можете незабавно да промените състоянието на всеки светодиод.
Необходими части
За този урок ще ви трябват следните части:
- Платка ESP32 DEVKIT V1
- 2x 5mm LED
- 2x 200 Ohm резистор
- Бредборд
- Джъмперни проводници
Схематичен
Започнете с изграждането на веригата. Свържете два светодиода към ESP32, както е показано на следната схематична диаграма – единият светодиод е свързан към 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 изберете вашата платка в Инструменти > Платка (в нашия случай използваме платката ESP32 DEVKIT DOIT);
- Изберете COM порта в Инструменти > Порт.
- Натиснете бутона за качване в Arduino IDE и изчакайте няколко секунди, докато кодът се компилира и качи на вашата дъска.
- Изчакайте съобщението „Готово на качването“.
Намиране на ESP IP адрес
След като качите кода, отворете серийния монитор при скорост на предаване от 115200 бода.
Натиснете бутона ESP32 EN (нулиране). ESP32 се свързва с Wi-Fi и извежда IP адреса на ESP на серийния монитор. Копирайте този IP адрес, защото ви е необходим за достъп до ESP32 web сървър.
Достъп до Web сървър
За достъп до web сървър, отворете браузъра си, поставете IP адреса на ESP32 и ще видите следната страница.
Забележка: Вашият браузър и ESP32 трябва да са свързани към една и съща локална мрежа.
Ако погледнете серийния монитор, можете да видите какво се случва на заден план. ESP получава HTTP заявка от нов клиент (в този случай вашият браузър).
Можете също да видите друга информация за HTTP заявката.
Демонстрация
Сега можете да тествате дали вашият web сървърът работи правилно. Щракнете върху бутоните, за да управлявате светодиодите.
В същото време можете да погледнете серийния монитор, за да видите какво се случва на заден план. Напримерample, когато щракнете върху бутона, за да включите GPIO 26, ESP32 получава заявка на /26/on URL.
Когато ESP32 получи тази заявка, той включва светодиода, свързан към GPIO 26, и актуализира състоянието си на 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() програмираме какво се случва, когато нов клиент установи връзка с web сървър.
ESP32 винаги слуша за входящи клиенти със следния ред:
Когато се получи заявка от клиент, ние ще запазим входящите данни. Цикълът while, който следва, ще работи, докато клиентът остане свързан. Не препоръчваме да променяте следната част от кода, освен ако не знаете точно какво правите.
Следващият раздел от изразите if и else проверява кой бутон е бил натиснат във вашия web страница и съответно контролира изходите. Както видяхме по-рано, ние правим заявка за различни URLs в зависимост от натиснатия бутон.
Напримерample, ако сте натиснали бутона GPIO 26 ON, ESP32 получава заявка на /26/ON URL (можем да видим тази информация в HTTP заглавката на серийния монитор). Така че можем да проверим дали заглавката съдържа израза GET /26/on. Ако съдържа, променяме променливата output26state на ON и ESP32 включва светодиода.
Това работи по подобен начин за другите бутони. Така че, ако искате да добавите още изходи, трябва да промените тази част от кода, за да ги включите.
Показване на HTML web страница
Следващото нещо, което трябва да направите, е да създадете web страница. ESP32 ще изпрати отговор до вашия браузър с някакъв HTML код за изграждане на web страница.
The web страницата се изпраща на клиента с помощта на този израз client.println(). Трябва да въведете това, което искате да изпратите на клиента като аргумент.
Първото нещо, което трябва да изпратим, винаги е следният ред, който показва, че изпращаме HTML.
След това следващият ред прави web страница, отзивчива във всеки web браузър.
И следното се използва за предотвратяване на заявки на favicon. – Не е нужно да се тревожите за тази линия.
Оформяне на Web Страница
След това имаме CSS текст за стилизиране на бутоните и web външен вид на страницата.
Избираме шрифта Helvetica, определяме съдържанието, което да се показва като блок и подравнено в центъра.
Ние стилизираме нашите бутони с цвят #4CAF50, без рамка, текст в бял цвят и с тази подложка: 16px 40px. Ние също така задаваме текстова декорация на none, определяме размера на шрифта, полето и курсора към показалеца.
Също така дефинираме стила за втори бутон, с всички свойства на бутона, които сме дефинирали по-рано, но с различен цвят. Това ще бъде стилът за бутона за изключване.
Настройка на Web Първо заглавие на страницата
В следващия ред можете да зададете първото заглавие на вашия web страница. Тук имаме „ESP32 Web Сървър“, но можете да промените този текст на какъвто искате.
Показване на бутоните и съответното състояние
След това пишете параграф, за да покажете текущото състояние на GPIO 26. Както можете да видите, ние използваме променливата output26State, така че състоянието да се актуализира незабавно, когато тази променлива се промени.
След това показваме бутона за включване или изключване, в зависимост от текущото състояние на GPIO. Ако текущото състояние на GPIO е изключено, показваме бутона ON, ако не, показваме бутона OFF.
Използваме същата процедура за GPIO 27.
Затваряне на връзката
Накрая, когато отговорът приключи, изчистваме заглавната променлива и спираме връзката с клиента с client.stop().
Завършване
В този урок ви показахме как да изградите a web сървър с ESP32. Показахме ви един прост бившample, който управлява два светодиода, но идеята е да замените тези светодиоди с реле или друг изход, който искате да контролирате.
Проект 6 RGB LED Web сървър
В този проект ще ви покажем как да управлявате дистанционно RGB LED с ESP32 платка с помощта на a web сървър с инструмент за избор на цвят.
Проектът приключиview
Преди да започнем, нека видим как работи този проект:
- ESP32 web сървърът показва инструмент за избор на цвят.
- Когато изберете цвят, вашият браузър прави заявка за a URL който съдържа R, G и B параметрите на избрания цвят.
- Вашият ESP32 получава заявката и разделя стойността за всеки цветен параметър.
- След това изпраща PWM сигнал със съответната стойност към GPIO, които управляват RGB светодиода.
Как работят RGB светодиодите?
В RGB светодиод с общ катод и трите светодиода споделят отрицателна връзка (катод). Всички включени в комплекта са RGB с общ катод.
Как да създадете различни цветове?
С RGB светодиод можете, разбира се, да произвеждате червена, зелена и синя светлина и чрез конфигуриране на интензитета на всеки светодиод можете да произвеждате и други цветове.
Напримерampнапример, за да произведете чисто синя светлина, трябва да настроите синия светодиод на най-високия интензитет, а зеления и червения светодиод на най-ниския интензитет. За бяла светлина трябва да зададете и трите светодиода на най-високия интензитет.
Смесване на цветове
За да произведете други цветове, можете да комбинирате трите цвята в различни интензитети. За да регулирате интензитета на всеки светодиод, можете да използвате PWM сигнал.
Тъй като светодиодите са много близо един до друг, очите ни виждат резултата от комбинацията от цветове, а не трите цвята поотделно.
За да имате идея как да комбинирате цветовете, разгледайте следната таблица.
Това е най-простата диаграма за смесване на цветове, но ви дава представа как работи и как да произвеждате различни цветове.
Необходими части
За този проект са ви необходими следните части:
- Платка ESP32 DEVKIT V1
- RGB LED
- 3x 220 ома резистори
- Джъмперни проводници
- Бредборд
Схематичен
Код
Ние ще програмираме 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 Hz. След това асоциирайте ШИМ канал за всеки цвят
И накрая, задайте разделителната способност на 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 сигнали със стойностите, декодирани от заявката за HTTPP.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
Тъй като получаваме стойностите в низова променлива, трябва да ги преобразуваме в цели числа с помощта на метода toInt().
Демонстрация
След като поставите вашите мрежови идентификационни данни, изберете правилната платка и COM порт и качете кода във вашия ESP32. Стъпки за справка на кода за качване.
След качване отворете Серийния монитор при скорост на предаване 115200 и натиснете бутона ESP Enable/Reset. Трябва да получите IP адреса на платката.
Отворете браузъра си и въведете IP адреса на ESP. Сега използвайте инструмента за избор на цвят, за да изберете цвят за RGB LED.
След това трябва да натиснете бутона „Промяна на цвета“, за да влезе в сила цветът.
За да изключите RGB LED, изберете черния цвят.
Най-силните цветове (в горната част на инструмента за избор на цвят) са тези, които ще дадат по-добри резултати.
Проект 7 ESP32 реле Web сървър
Използването на реле с ESP32 е чудесен начин за дистанционно управление на AC домакински уреди. Този урок обяснява как да управлявате релеен модул с ESP32.
Ще разгледаме как работи релеен модул, как да свържете релето към ESP32 и да изградим web сървър за дистанционно управление на реле.
Представяме ви релета
Релето е електрически задвижван превключвател и като всеки друг превключвател, той може да се включва или изключва, пропускайки тока или не. Може да се контролира с ниска сила на звукаtages, подобно на 3.3 V, осигурени от ESP32 GPIO, и ни позволява да контролираме висока сила на звукаtages като 12V, 24V или мрежово напрежениеtage (230V в Европа и 120V в САЩ).
От лявата страна има два комплекта от три гнезда за свързване на висок обемtages, и щифтовете от дясната страна (ниска сила на звукаtagд) свържете се към ESP32 GPIO.
Мрежа Voltage Връзки
Релейният модул, показан на предишната снимка, има два конектора, всеки с три гнезда: общ (COM), нормално затворен (NC) и нормално отворен (NO).
- COM: свържете тока, който искате да контролирате (мрежово напрежение).tagд).
- NC (нормално затворено): нормално затворената конфигурация се използва, когато искате релето да бъде затворено по подразбиране. NC са COM щифтовете са свързани, което означава, че токът тече, освен ако не изпратите сигнал от ESP32 към релейния модул за отваряне на веригата и спиране на текущия поток.
- NO (нормално отворен): нормално отворената конфигурация работи по обратния начин: няма връзка между NO и COM щифтовете, така че веригата е прекъсната, освен ако не изпратите сигнал от ESP32 за затваряне на веригата.
Контролни щифтове
Ниският обемtagСтраната има набор от четири щифта и комплект от три щифта. Първият комплект се състои от VCC и GND за захранване на модула и вход 1 (IN1) и вход 2 (IN2) за управление съответно на долното и горното релета.
Ако вашият релеен модул има само един канал, ще имате само един IN щифт. Ако имате четири канала, ще имате четири IN пина и т.н.
Сигналът, който изпращате към IN щифтовете, определя дали релето е активно или не. Релето се задейства, когато входното напрежение падне под около 2V. Това означава, че ще имате следните сценарии:
- Нормално затворена конфигурация (NC):
- ВИСОК сигнал – тече ток
- Сигнал LOW – не тече ток
- Нормално отворена конфигурация (НЕ):
- HIGH сигнал – не тече ток
- Сигнал LOW – тече ток
Трябва да използвате нормално затворена конфигурация, когато токът трябва да тече през повечето време и искате да го спрете само от време на време.
Използвайте нормално отворена конфигурация, когато искате токът да тече от време на време (напрample, включете алamp понякога).
Избор на захранване
Вторият комплект щифтове се състои от щифтове GND, VCC и JD-VCC.
Щифтът JD-VCC захранва електромагнита на релето. Забележете, че модулът има джъмперна капачка, свързваща щифтовете VCC и JD-VCC; показаното тук е жълто, но вашето може да е с различен цвят.
С поставена капачка на джъмпера, щифтовете VCC и JD-VCC са свързани. Това означава, че релейният електромагнит се захранва директно от захранващия щифт на ESP32, така че релейният модул и веригите на ESP32 не са физически изолирани един от друг.
Без капачката на джъмпера трябва да осигурите независим източник на захранване за захранване на електромагнита на релето през щифта JD-VCC. Тази конфигурация физически изолира релетата от ESP32 с вградения в модула оптрон, който предотвратява повреда на ESP32 в случай на електрически пикове.
Схематичен
Предупреждение: Използване на висок обtagЗахранващите устройства могат да причинят сериозни наранявания.
Поради това се използват 5 мм светодиоди вместо високо захранванеtage крушки в експеримента. Ако не сте запознати с mains voltagпомолете някой, който трябва да ви помогне. Докато програмирате ESP или свързвате вашата верига, уверете се, че всичко е изключено от електрическата мрежаtage.
Инсталиране на библиотеката за ESP32
За да изградите това web сървър, използваме ESPAsyncWebСървърна библиотека и AsyncTCP библиотека.
Инсталиране на ESPAsyncWebСървърна библиотека
Следвайте следващите стъпки, за да инсталирате ESPAsyncWebсървър библиотека:
- Щракнете тук, за да изтеглите ESPAsyncWebСървърна библиотека. Трябваше да имаш
папка .zip във вашата папка за изтегляния - Разархивирайте папката .zip и трябва да получите ESPAsyncWebСървър-главна папка
- Преименувайте папката си от ESPAsyncWebГлавен сървър към ESPAsyncWebсървър
- Преместете 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 адрес. След това отворете браузър във вашата локална мрежа и въведете IP адреса на ESP32, за да получите достъп до web сървър.
Отворете серийния монитор при скорост на предаване от 115200 бода и натиснете бутона ESP32 EN, за да получите неговия IP адрес. След това отворете браузър във вашата локална мрежа и въведете IP адреса на ESP32, за да получите достъп до web сървър.
Забележка: Вашият браузър и ESP32 трябва да са свързани към една и съща локална мрежа.
Трябва да получите нещо както следва с два бутона като броя на релетата, които сте дефинирали във вашия код.
Сега можете да използвате бутоните, за да управлявате вашите релета с помощта на вашия смартфон.
Project_8_Output_State_Synchronization_ Web_Сървър
Този проект показва как да контролирате изходите ESP32 или ESP8266 с помощта на a web сървър и физически бутон едновременно. Изходното състояние се актуализира на web страница дали се променя чрез физически бутон или web сървър.
Проектът приключиview
Нека да разгледаме набързо как работи проектът.
ESP32 или ESP8266 хоства a web сървър, който ви позволява да контролирате състоянието на изход;
- Текущото състояние на изхода се показва на web сървър;
- ESP също е свързан към физически бутон, който управлява същия изход;
- Ако промените изходното състояние с помощта на физическия бутон, текущото му състояние също се актуализира на web сървър.
В обобщение, този проект ви позволява да контролирате същия изход с помощта на a web сървър и бутон едновременно. Всеки път, когато изходното състояние се промени, web сървърът е актуализиран.
Необходими части
Ето списък на частите, от които се нуждаете, за да изградите веригата:
- Платка ESP32 DEVKIT V1
- 5 mm LED
- резистор 220 ома
- Натисни бутона
- Резистор 10k Ohm
- Бредборд
- Джъмперни проводници
Схематичен
Инсталиране на библиотеката за ESP32
За да изградите това web сървър, използваме ESPAsyncWebСървърна библиотека и AsyncTCP библиотека. (Ако вече сте направили тази стъпка, можете да преминете към следващата стъпка.)
Инсталиране на ESPAsyncWebСървърна библиотека
Следвайте следващите стъпки, за да инсталирате ESPAsyncWebСървърна библиотека:
- Щракнете тук, за да изтеглите ESPAsyncWebСървърна библиотека. Трябваше да имаш
папка .zip във вашата папка за изтегляния - Разархивирайте папката .zip и трябва да получите ESPAsyncWebСървър-главна папка
- Преименувайте папката си от ESPAsyncWebГлавен сървър към ESPAsyncWebсървър
- Преместете 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 сървърът стартира, той е НИСКО.
ButtonState и lastButtonState се използват за откриване дали бутонът е бил натиснат или не.
бутон (web сървър)
Не включихме HTML, за да създадем бутона в променливата index_html.
Това е така, защото искаме да можем да го променим в зависимост от текущото състояние на светодиода, което също може да се промени с бутона.
И така, създадохме контейнер за бутона %BUTTONPLACEHOLDER%, който ще бъде заменен с HTML текст, за да създадем бутона по-късно в кода (това се прави във функцията processor()).
процесор ()
Функцията processor() замества всички запазени места в HTML текста с действителни стойности. Първо, той проверява дали HTML текстовете съдържат такива
заместители %BUTTONPLACEHOLDER%.
След това извикайте функцията theoutputState(), която връща текущото изходно състояние. Записваме го в променливата outputStateValue.
След това използвайте тази стойност, за да създадете HTML текста, за да покажете бутона с правилното състояние:
HTTP GET заявка за промяна на изходното състояние (JavaScript)
Когато натиснете бутона, се извиква функцията thetoggleCheckbox(). Тази функция ще направи заявка за различни URLs за включване или изключване на светодиода.
За да включи светодиода, той прави заявка на /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(), ние премахваме отскока на бутона и включваме или изключваме светодиода в зависимост от стойността на ledState променлива.
Демонстрация
Качете кода на вашата платка ESP32. Качете стъпките за справка на кода.
След това отворете серийния монитор при скорост на предаване от 115200 бода. Натиснете вградения бутон EN/RST, за да получите IP адреса.
Отворете браузър във вашата локална мрежа и въведете IP адреса на ESP. Трябва да имате достъп до web сървър, както е показано по-долу.
Забележка: Вашият браузър и ESP32 трябва да са свързани към една и съща локална мрежа.
Можете да превключите бутона на web сървър, за да включите светодиода.
Можете също да управлявате същия светодиод с физическия бутон. Състоянието му винаги ще се актуализира автоматично на web сървър.
Проект 9 ESP32 DHT11 Web сървър
В този проект ще научите как да изградите асинхронен ESP32 web сървър с DHT11, който показва температурата и влажността с помощта на Arduino IDE.
Предпоставки
The web сървърът, който ще изградим, актуализира показанията автоматично, без да е необходимо да опреснявате web страница.
С този проект ще научите:
- Как да четем температура и влажност от DHT сензори;
- Изградете асинхронен web сървър, използващ ESPAsyncWebСървърна библиотека;
- Актуализирайте показанията на сензора автоматично, без да е необходимо да опреснявате web страница.
Асинхронен Web сървър
За изграждане на web сървър, който ще използваме ESPAsyncWebСървърна библиотека който предоставя лесен начин за изграждане на асинхронен web сървър. Изграждане на асинхронен web сървърът има няколко advantages, както е споменато на страницата на библиотеката GitHub, като например:
- „Обработване на повече от една връзка едновременно“;
- „Когато изпратите отговора, веднага сте готови да обработите други връзки, докато сървърът се грижи за изпращането на отговора във фонов режим“;
- „Прост механизъм за обработка на шаблони за обработка на шаблони“;
Необходими части
За да завършите този урок, имате нужда от следните части:
- Платка за разработка ESP32
- DHT11 модул
- Бредборд
- Джъмперни проводници
Схематичен
Инсталиране на библиотеки
Трябва да инсталирате няколко библиотеки за този проект:
- The DHT и на Adafruit Unified Sensor Библиотеки на драйвери за четене от 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
Инсталиране на ESPAsyncWebСървърна библиотека
Следвайте следващите стъпки, за да инсталирате ESPAsyncWebсървър библиотека:
- Щракнете тук, за да изтеглите ESPAsyncWebСървърна библиотека. Трябваше да имаш
папка .zip във вашата папка за изтегляния - Разархивирайте папката .zip и трябва
вземете ESPAsyncWebСървър-главна папка - Преименувайте папката си от ESPAsyncWebГлавен сървър към ESPAsyncWebсървър
- Преместете 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 сензор, който използвате. В нашия бившample, ние използваме DHT22. Ако използвате друг тип, просто трябва да откоментирате своя сензор и да коментирате всички останали.
Създайте екземпляр на DHT обект с типа и щифта, които дефинирахме по-рано.
Създайте AsyncWebСървърен обект на порт 80.
Прочетете функциите за температура и влажност
Създадохме две функции: едната за четене на температурата Създадохме две функции: едната за четене на температурата (readDHTTemperature()), а другата за четене на влажността (readDHTHumidity()).
Получаването на показания от сензори е толкова просто, колкото използването Получаването на показания от сензори е толкова просто, колкото използването на методите readTemperature() и readHumidity() на обекта dht.
Имаме и условие, което връща две тирета (–), в случай че сензорът не успее да получи показанията.
Показанията се връщат като тип низ. За да конвертирате float в низ, използвайте функцията String().
По подразбиране четем температурата в градуси по Целзий. За да получите температурата в градуси по Фаренхайт, коментирайте температурата в Целзий и разкоментирайте температурата във Фаренхайт, така че да имате следното:
Качете кода
Сега качете кода във вашия ESP32. Уверете се, че сте избрали правилната платка и COM порт. Качете стъпките за референтен код.
След качване отворете Серийния монитор при скорост на предаване 115200. Натиснете бутона за нулиране ESP32. IP адресът на ESP32 трябва да бъде отпечатан в серийния номер монитор.
Демонстрация
Отворете браузър и въведете IP адреса на ESP32. Вашият web сървърът трябва да показва последните показания на сензора.
Забележка: Вашият браузър и ESP32 трябва да са свързани към една и съща локална мрежа.
Забележете, че показанията за температура и влажност се актуализират автоматично, без да е необходимо да опреснявате web страница.
Проект_10_ESP32_OLED_Дисплей
Този проект показва как да използвате 0.96-инчовия SSD1306 OLED дисплей с ESP32 с помощта на Arduino IDE.
Представяме ви 0.96-инчов OLED дисплей
The OLED дисплей който ще използваме в този урок, е моделът SSD1306: едноцветен 0.96-инчов дисплей с 128×64 пиксела, както е показано на следващата фигура.
OLED дисплеят не изисква подсветка, което води до много приятен контраст в тъмна среда. Освен това неговите пиксели консумират енергия само когато са включени, така че OLED дисплеят консумира по-малко енергия в сравнение с други дисплеи.
Тъй като OLED дисплеят използва комуникационен протокол I2C, окабеляването е много просто. Можете да използвате следната таблица като справка.
| OLED щифт | ESP32 |
| Вин | 3.3V |
| GND | GND |
| SCL | GPIO 22 |
| SDA | GPIO 21 |
Схематичен
Инсталиране на SSD1306 OLED библиотека – ESP32
Има няколко налични библиотеки за управление на OLED дисплея с ESP32.
В този урок ще използваме две библиотеки на Adafruit: Библиотека Adafruit_SSD1306 и Библиотека Adafruit_GFX.
Следвайте следващите стъпки, за да инсталирате тези библиотеки.
- Отворете вашата Arduino IDE и отидете на Sketch > Include Library > Manage Libraries. Мениджърът на библиотеката трябва да се отвори.
- Въведете „SSD1306“ в полето за търсене и инсталирайте библиотеката SSD1306 от Adafruit.
- След като инсталирате библиотеката SSD1306 от Adafruit, въведете „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. В този бившample, ние използваме 128×64 OLED дисплей. Ако използвате други размери, можете да промените това в променливите SCREEN_WIDTH и SCREEN_HEIGHT.
След това инициализирайте дисплейен обект с ширината и височината, дефинирани по-рано с I2C комуникационен протокол (&Wire).
Параметърът (-1) означава, че вашият OLED дисплей няма щифт RESET. Ако вашият OLED дисплей има щифт RESET, той трябва да бъде свързан към GPIO. В такъв случай трябва да подадете GPIO номера като параметър.
В setup() инициализирайте серийния монитор при скорост на предаване от 115200 за целите на отстраняване на грешки.
Инициализирайте OLED дисплея с метода begin(), както следва:
Този фрагмент също отпечатва съобщение на серийния монитор, в случай че не можем да се свържем с дисплея.
В случай, че използвате различен OLED дисплей, може да се наложи да промените OLED адреса. В нашия случай адресът е 0x3C.
След инициализиране на дисплея добавете две секунди забавяне, така че OLED да има достатъчно време за инициализиране, преди да напише текст:
Изчистете дисплея, задайте размер на шрифта, цвят и напишете текст
След като инициализирате дисплея, изчистете буфера на дисплея с метода clearDisplay():
Преди да пишете текст, трябва да зададете размера на текста, цвета и къде ще се показва текстът в OLED.
Задайте размера на шрифта с помощта на метода setTextSize():
Задайте цвета на шрифта с метода setTextColor():
WHITE задава бял шрифт и черен фон.
Дефинирайте позицията, в която започва текстът, като използвате метода setCursor(x,y). В този случай задаваме текста да започва от (0,0) координатите – в горния ляв ъгъл.
И накрая, можете да изпратите текста на дисплея с помощта на метода println(), както следва
След това трябва да извикате метода display(), за да покажете действително текста на екрана.
OLED библиотеката Adafruit предоставя полезни методи за лесно превъртане на текст.
- startscrollright(0x00, 0x0F): превъртане на текст отляво надясно
- startscrollleft(0x00, 0x0F): превъртане на текст отдясно наляво
- startscrolldiagright(0x00, 0x07): превъртане на текст от левия долен ъгъл до десния горен ъгъл startscrolldiagleft(0x00, 0x07): превъртане на текст от десния долен ъгъл до левия горен ъгъл
Качете кода
Сега качете кода във вашия ESP32. Качете стъпките за справка на кода.
След качване на кода OLED ще покаже превъртащ се текст.
Документи / Ресурси
 |
LAFVIN ESP32 Основен стартов комплект [pdf] Ръководство за употреба ESP32 Основен стартов комплект, ESP32, Основен стартов комплект, Стартов комплект |