ESP32 Basic Starter
Kit
Lista de embalaxe
ESP32 Introdución
Novo en ESP32? Comeza aquí! O ESP32 é unha serie de microcontroladores System on a Chip (SoC) de baixo custo e baixo consumo desenvolvidos por Espressif que inclúen capacidades sen fíos Wi-Fi e Bluetooth e un procesador de dobre núcleo. Se estás familiarizado co ESP8266, o ESP32 é o seu sucesor, cargado de moitas funcións novas.
Especificacións de ESP32
Se queres ser un pouco máis técnico e específico, podes botar unha ollada ás seguintes especificacións detalladas do ESP32 (fonte: http://esp32.net/)—para máis detalles, verifique a folla de datos):
- Conectividade sen fíos WiFi: velocidade de datos de 150.0 Mbps con HT40
- Bluetooth: BLE (Bluetooth Low Energy) e Bluetooth Classic
- Procesador: Tensilica Xtensa Dual-Core 32-bit LX6 microprocessor, running at 160 or 240 MHz
- Memoria:
- ROM: 448 KB (para o arranque e as funcións básicas)
- SRAM: 520 KB (para datos e instrucións)
- RTC fas SRAM: 8 KB (para almacenamento de datos e CPU principal durante o arranque RTC desde o modo de suspensión profunda)
- SRAM lenta RTC: 8KB (para acceso co-procesador durante o modo de suspensión profunda) eFuse: 1 Kbit (dos cales 256 bits se utilizan para o sistema (enderezo MAC e configuración do chip) e os 768 bits restantes resérvanse para aplicacións do cliente, incluíndo Cifrado Flash e ID de chip)
Flash integrado: flash conectado internamente mediante IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 e SD_DATA_1 en ESP32-D2WD e ESP32-PICO-D4.
- 0 MiB (chips ESP32-D0WDQ6, ESP32-D0WD e ESP32-S0WD)
- 2 MiB (chip ESP32-D2WD)
- 4 MiB (módulo ESP32-PICO-D4 SiP)
Baixa potencia: garante que aínda podes usar conversións ADC, por exemploample, durante o sono profundo.
Entrada/Saída periférica:
- interface periférica con DMA que inclúe táctil capacitivo
- ADC (conversor analóxico a dixital)
- DAC (conversor de dixital a analóxico)
- I²C (circuíto interintegrado)
- UART (receptor/transmisor asíncrono universal)
- SPI (Interfaz Periférica Serial)
- I²S (sonido entre chips integrado)
- RMII (Interfaz independente dos medios reducidos)
- PWM (modulación de ancho de pulso)
Seguridade: aceleradores de hardware para AES e SSL/TLS
Placas de desenvolvemento ESP32
ESP32 refírese ao chip ESP32 espido. Non obstante, o termo "ESP32" tamén se usa para referirse ás placas de desenvolvemento ESP32. Usar chips espidos ESP32 non é sinxelo nin práctico, especialmente cando se aprende, se proba e se crea prototipos. Na maioría das veces, quererá usar unha tarxeta de desenvolvemento ESP32.
Usaremos a placa ESP32 DEVKIT V1 como referencia. A imaxe de abaixo mostra a tarxeta ESP32 DEVKIT V1, versión con 30 pinos GPIO.
Especificacións – ESP32 DEVKIT V1
A seguinte táboa mostra un resumo das características e especificacións da placa ESP32 DEVKIT V1 DOIT:
| Número de núcleos | 2 (dobre núcleo) |
| Wi-Fi | 2.4 GHz ata 150 Mbits/s |
| Bluetooth | BLE (Bluetooth Low Energy) e Bluetooth heredado |
| Arquitectura | 32 bits |
| Frecuencia de reloxo | Ata 240 MHz |
| RAM | 512 KB |
| Pinos | 30 (dependendo do modelo) |
| Periféricos | Táctil capacitivo, ADC (conversor de analóxico a dixital), DAC (conversor de dixital a analóxico), 12C (circuíto interintegrado), UART (receptor/transmisor asíncrono universal), CAN 2.0 (área de control de rede), SPI (interfaz periférica serie) , 12S (Inter-IC integrado Son), RMII (Reduced Media-Independent Interface), PWM (modulación de ancho de pulso) e moito máis. |
| Botóns incorporados | Botóns RESET e BOOT |
| LEDs incorporados | LED azul incorporado conectado a GPIO2; LED vermello incorporado que indica que a placa está a ser alimentada |
| USB a UART ponte |
CP2102 |
Vén cunha interface microUSB que podes usar para conectar a placa ao teu ordenador para cargar código ou aplicar enerxía.
Usa o chip CP2102 (USB a UART) para comunicarse co seu ordenador a través dun porto COM mediante unha interface serie. Outro chip popular é o CH340. Comproba cal é o conversor de chips USB a UART na túa placa porque terás que instalar os controladores necesarios para que o teu ordenador poida comunicarse coa placa (máis información sobre isto máis adiante nesta guía).
Este taboleiro tamén vén cun botón RESET (pode estar etiquetado EN) para reiniciar o taboleiro e un botón BOOT para pór o taboleiro en modo intermitente (dispoñible para recibir código). Teña en conta que algúns taboleiros poden non ter un botón BOOT.
Tamén vén cun LED azul incorporado que está conectado internamente a GPIO 2. Este LED é útil para a depuración para dar algún tipo de saída física visual. Tamén hai un LED vermello que se ilumina cando proporcionas enerxía á placa.
Pinout ESP32
Os periféricos ESP32 inclúen:
- 18 canles de convertidor analóxico a dixital (ADC).
- 3 interfaces SPI
- 3 interfaces UART
- 2 interfaces I2C
- 16 canles de saída PWM
- 2 Conversores de dixital a analóxico (DAC)
- 2 interfaces I2S
- 10 GPIO de detección capacitiva
As funcións ADC (conversor analóxico a dixital) e DAC (conversor dixital a analóxico) están asignadas a pinos estáticos específicos. Non obstante, podes decidir cales son os pinos UART, I2C, SPI, PWM, etc; só tes que asignalos no código. Isto é posible debido á función de multiplexación do chip ESP32.
Aínda que pode definir as propiedades dos pinos no software, hai pinos asignados por defecto como se mostra na seguinte figura
Ademais, hai pinos con características específicas que os fan axeitados ou non para un proxecto en particular. A seguinte táboa mostra cales son os mellores pinos para usar como entradas, saídas e cales cómpre ter coidado.
Os pinos resaltados en verde poden usarse. Os resaltados en amarelo están ben de usar, pero cómpre prestar atención porque poden ter un comportamento inesperado principalmente no arranque. Non se recomenda usar os pinos resaltados en vermello como entradas ou saídas.
| GP IO | Entrada | Saída | Notas |
| 0 | arrincou | OK | emite o sinal PWM ao arrancar, debe estar BAIXO para entrar no modo de parpadeo |
| 1 | Pin TX | OK | saída de depuración no arranque |
| 2 | OK | OK | conectado ao LED incorporado, debe deixarse flotante ou BAIXO para entrar en modo intermitente |
| 3 | OK | Pin RX | ALTO no arranque |
| 4 | OK | OK | |
| 5 | OK | OK | emite sinal PWM no arranque, pin de correa |
| 12 | OK | OK | o arranque falla se se tira alto, alfinete |
| 13 | OK | OK | |
| 14 | OK | OK | emite o sinal PWM no arranque |
| 15 | OK | OK | emite sinal PWM no arranque, pin de correa |
| 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 | só entrada | |
| 35 | OK | só entrada | |
| 36 | OK | só entrada | |
| 39 | OK | só entrada |
Continúa lendo para obter unha análise máis detallada e en profundidade dos GPIO ESP32 e as súas funcións.
Introduza só pinos
Os GPIO 34 a 39 son GPI: só pins de entrada. Estes pinos non teñen resistencias internas de pull-up ou pull-down. Non se poden usar como saídas, polo que utiliza estes pinos só como entradas:
- GPIO 34
- GPIO 35
- GPIO 36
- GPIO 39
Flash SPI integrado no ESP-WROOM-32
GPIO 6 a GPIO 11 están expostos nalgunhas placas de desenvolvemento ESP32. Non obstante, estes pinos están conectados ao flash SPI integrado no chip ESP-WROOM-32 e non se recomendan para outros usos. Polo tanto, non uses estes pinos nos teus proxectos:
- GPIO 6 (SCK/CLK)
- GPIO 7 (SDO/SD0)
- GPIO 8 (SDI/SD1)
- GPIO 9 (SHD/SD2)
- GPIO 10 (SWP/SD3)
- GPIO 11 (CSC/CMD)
GPIOs táctiles capacitivos
O ESP32 ten 10 sensores táctiles capacitivos internos. Estes poden detectar variacións en calquera cousa que teña carga eléctrica, como a pel humana. Así poden detectar variacións inducidas ao tocar os GPIO cun dedo. Estes pinos pódense integrar facilmente en almofadas capacitivas e substituír os botóns mecánicos. Os pinos táctiles capacitivos tamén se poden usar para espertar o ESP32 do sono profundo. Eses sensores táctiles internos están conectados a estes 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)
Conversor analóxico a dixital (ADC)
O ESP32 ten 18 canles de entrada ADC de 12 bits (mentres que o ESP8266 só ten 1 ADC de 10 bits). Estes son os GPIO que se poden usar como ADC e canles respectivas:
- ADC1_CH0 (GPIO 36)
- ADC1_CH1 (GPIO 37)
- ADC1_CH2 (GPIO 38)
- ADC1_CH3 (GPIO 39)
- ADC1_CH4 (GPIO 32)
- ADC1_CH5 (GPIO 33)
- ADC1_CH6 (GPIO 34)
- ADC1_CH7 (GPIO 35)
- ADC2_CH0 (GPIO 4)
- ADC2_CH1 (GPIO 0)
- ADC2_CH2 (GPIO 2)
- ADC2_CH3 (GPIO 15)
- ADC2_CH4 (GPIO 13)
- ADC2_CH5 (GPIO 12)
- ADC2_CH6 (GPIO 14)
- ADC2_CH7 (GPIO 27)
- ADC2_CH8 (GPIO 25)
- ADC2_CH9 (GPIO 26)
Nota: Os pinos ADC2 non se poden usar cando se usa wifi. Polo tanto, se estás a usar wifi e tes problemas para obter o valor dun GPIO ADC2, podes considerar usar un GPIO ADC1. Iso debería resolver o teu problema.
As canles de entrada ADC teñen unha resolución de 12 bits. Isto significa que pode obter lecturas analóxicas que van de 0 a 4095, nas que 0 corresponde a 0 V e 4095 a 3.3 V. Tamén podes configurar a resolución das túas canles no código e no rango ADC.
Os pinos ADC ESP32 non teñen un comportamento lineal. Probablemente non poderás distinguir entre 0 e 0.1 V ou entre 3.2 e 3.3 V. Debe telo en conta cando use os pinos ADC. Terá un comportamento similar ao que se mostra na seguinte figura.
Conversor dixital a analóxico (DAC)
Hai canles DAC de 2 x 8 bits no ESP32 para converter sinais dixitais en voltage saídas de sinal. Estas son as canles DAC:
- DAC1 (GPIO25)
- DAC2 (GPIO26)
RTC GPIO
Hai soporte RTC GPIO no ESP32. Os GPIO encamiñados ao subsistema de baixa potencia RTC pódense usar cando o ESP32 está en suspensión profunda. Estes GPIO RTC pódense usar para espertar o ESP32 do soño profundo cando o Ultra Low
O coprocesador de enerxía (ULP) está en execución. Os seguintes GPIO pódense usar como fonte de activación externa.
- 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
O controlador PWM LED ESP32 ten 16 canles independentes que se poden configurar para xerar sinais PWM con diferentes propiedades. Todos os pinos que poden actuar como saídas pódense usar como pinos PWM (os GPIO 34 a 39 non poden xerar PWM).
Para configurar un sinal PWM, cómpre definir estes parámetros no código:
- Frecuencia do sinal;
- Ciclo de traballo;
- canle PWM;
- GPIO onde quere emitir o sinal.
I2C
O ESP32 ten dúas canles I2C e calquera pin pódese configurar como SDA ou SCL. Cando se usa o ESP32 co IDE de Arduino, os pinos I2C predeterminados son:
- GPIO 21 (SDA)
- GPIO 22 (SCL)
Se queres usar outros pinos cando utilizas a biblioteca de cables, só tes que chamar a:
Wire.begin(SDA, SCL);
SPI
Por defecto, a asignación de pins para SPI é:
| SPI | MOSI | MISO | CLK | CS |
| VSPI | GPIO 23 | GPIO 19 | GPIO 18 | GPIO 5 |
| HSPI | GPIO 13 | GPIO 12 | GPIO 14 | GPIO 15 |
Interrupcións
Todos os GPIO pódense configurar como interrupcións.
Pasadores de correa
O chip ESP32 ten os seguintes pinos de cinta:
- GPIO 0 (debe ser BAIXO para entrar no modo de arranque)
- GPIO 2 (debe estar flotante ou BAIXO durante o arranque)
- GPIO 4
- GPIO 5 (debe estar ALTO durante o arranque)
- GPIO 12 (debe estar BAIXO durante o arranque)
- GPIO 15 (debe estar ALTO durante o arranque)
Estes utilízanse para poñer o ESP32 en modo cargador de arranque ou parpadeo. Na maioría das placas de desenvolvemento con USB/Serial incorporado, non tes que preocuparte polo estado destes pinos. O taboleiro pon os pinos no estado correcto para o modo intermitente ou de inicio. Podes atopar máis información sobre a selección do modo de arranque de ESP32 aquí.
Non obstante, se tes periféricos conectados a eses pinos, é posible que teñas problemas para tentar cargar un novo código, para flashear o ESP32 cun novo firmware ou para restablecer a placa. Se tes algúns periféricos conectados aos pinos de correa e tes problemas para cargar o código ou para flashear o ESP32, pode ser que eses periféricos impidan que o ESP32 entre no modo correcto. Lea a documentación de selección do modo de arranque para guialo na dirección correcta. Despois de restablecer, parpadear ou iniciar, eses pinos funcionan como se esperaba.
Pins ALTO no arranque
Algúns GPIO cambian o seu estado a ALTO ou emiten sinais PWM ao iniciar ou reiniciar.
Isto significa que se tes saídas conectadas a estes GPIO, podes obter resultados inesperados cando o ESP32 se reinicie ou se arranque.
- GPIO 1
- GPIO 3
- GPIO 5
- GPIO 6 a GPIO 11 (conectado á memoria flash SPI integrada ESP32; non se recomenda o seu uso).
- GPIO 14
- GPIO 15
Activar (EN)
Enable (EN) é o pin de habilitación do regulador de 3.3 V. Está levantado, así que conéctate a terra para desactivar o regulador de 3.3 V. Isto significa que podes usar este pin conectado a un botón para reiniciar o teu ESP32, por exemploample.
GPIO extraída de corrente
A corrente máxima absoluta absorbida por GPIO é de 40 mA segundo a sección "Condicións de funcionamento recomendadas" da folla de datos ESP32.
Sensor de efecto Hall integrado ESP32
O ESP32 tamén conta cun sensor de efecto hall incorporado que detecta os cambios no campo magnético no seu contorno
ESP32 Arduino IDE
Hai un complemento para o Arduino IDE que che permite programar o ESP32 usando o Arduino IDE e a súa linguaxe de programación. Neste tutorial mostrarémosche como instalar a placa ESP32 en Arduino IDE tanto se estás usando Windows, Mac OS X ou Linux.
Requisitos previos: Arduino IDE instalado
Antes de iniciar este procedemento de instalación, cómpre ter Arduino IDE instalado no seu ordenador. Hai dúas versións do IDE de Arduino que podes instalar: versión 1 e versión 2.
Podes descargar e instalar Arduino IDE facendo clic na seguinte ligazón: arduino.cc/en/Main/Software
Que versión de Arduino IDE recomendamos? Polo momento, hai algúns plugins para o ESP32 (como o SPIFFS FileSystem Uploader Plugin) que aínda non son compatibles con Arduino 2. Polo tanto, se pretende usar o complemento SPIFFS no futuro, recomendámosche instalar a versión herdada 1.8.X. Só tes que desprazarte cara abaixo na páxina do software Arduino para atopalo.
Instalación do complemento ESP32 no IDE de Arduino
Para instalar a placa ESP32 no teu IDE de Arduino, siga estas seguintes instrucións:
- No teu IDE de Arduino, vai a File> Preferencias
- Introduza o seguinte no "Xestor do Consello Adicional URLcampo s”:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
A continuación, faga clic no botón "Aceptar":
Nota: se xa tes as placas ESP8266 URL, pode separar o URLs cunha coma como segue:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Abre o Xestor de Boards. Vaia a Ferramentas > Taboleiro > Xestor de taboleiros...
Busca ESP32 and press install button for the “ESP32 by Espressif Systems“:
Iso é. Debe instalarse despois duns segundos.
Cargar o código de proba
Conecte a placa ESP32 ao seu ordenador. Co IDE de Arduino aberto, siga estes pasos:
- Seleccione o seu taboleiro en Ferramentas > menú Taboleiro (no meu caso é o módulo ESP32 DEV)
- Seleccione o porto (se non ves o porto COM no teu IDE de Arduino, debes instalar os controladores CP210x USB to UART Bridge VCP):
- Abre o seguinte example debaixo File > Examples > WiFi
(ESP32) > WiFiScan
- Ábrese un novo esbozo no teu IDE de Arduino:
- Preme o botón Cargar no IDE de Arduino. Agarda uns segundos mentres o código se compila e se carga no teu taboleiro.
- Se todo saíu como se esperaba, deberías ver un "Carga finalizada". mensaxe.
- Abra o monitor serie Arduino IDE a unha velocidade de transmisión de 115200:
- Preme o botón Activar a bordo do ESP32 e deberías ver as redes dispoñibles preto do teu ESP32:
Resolución de problemas
Se tentas cargar un novo esbozo no teu ESP32 e recibes esta mensaxe de erro "Produciuse un erro fatal: non se puido conectar a ESP32: esgotou o tempo de espera... Conectando...". Significa que o teu ESP32 non está en modo parpadeante/carga.
Tendo o nome correcto da placa e o COM por seleccionado, siga estes pasos:
Mantén premido o botón "BOOT" no teu taboleiro ESP32
- Preme o botón "Cargar" no IDE de Arduino para cargar o teu bosquexo:
- Despois de ver "Conectándose...". mensaxe no teu IDE de Arduino, solta o dedo do botón "BOOT":
- Despois diso, deberías ver a mensaxe "Carga finalizada".
Iso é. O teu ESP32 debería ter o novo esbozo en execución. Preme o botón "ACTIVAR" para reiniciar o ESP32 e executar o novo bosquexo cargado.
Tamén terás que repetir esa secuencia de botóns cada vez que queiras cargar un novo esbozo.
Proxecto 1 ESP32 Entradas Saídas
Nesta guía de inicio aprenderás a ler entradas dixitais como un interruptor de botón e controlar as saídas dixitais como un LED usando o ESP32 con Arduino IDE.
Requisitos previos
Programaremos o ESP32 usando Arduino IDE. Polo tanto, asegúrate de ter instalado o complemento das placas ESP32 antes de continuar:
- Instalación do complemento ESP32 no IDE de Arduino
Control de saídas dixitais ESP32
En primeiro lugar, debes configurar o GPIO que queres controlar como SAÍDA. Use a función pinMode() do seguinte xeito:
pinMode (GPIO, OUTPUT);
Para controlar unha saída dixital só precisa utilizar a función digitalWrite(), que acepta como argumentos, o GPIO (número int) ao que se refire e o estado, ALTO ou BAIXO.
DigitalWrite (GPIO, ESTADO);
Pódense usar todos os GPIO como saídas excepto os GPIO 6 a 11 (conectados ao flash SPI integrado) e os GPIO 34, 35, 36 e 39 (só GPIO de entrada);
Obtén máis información sobre os ESP32 GPIO: ESP32 GPIO Reference Guide
Entradas dixitais de lectura ESP32
Primeiro, configura o GPIO que queres ler como INPUT, usando a función pinMode() do seguinte xeito:
pinMode (GPIO, ENTRADA);
Para ler unha entrada dixital, como un botón, utiliza a función digitalRead(), que acepta como argumento o GPIO (número int) ao que se refire.
lectura dixital (GPIO);
Todos os GPIO ESP32 pódense usar como entradas, excepto os GPIO 6 a 11 (conectados ao flash SPI integrado).
Obtén máis información sobre os ESP32 GPIO: ESP32 GPIO Reference Guide
Proxecto Example
Para mostrarche como usar entradas e saídas dixitais, imos construír un proxecto sinxelo, por exemploample cun pulsador e un LED. Leremos o estado do pulsador e iluminaremos o LED segundo se ilustra na seguinte figura.
Pezas necesarias
Aquí tes unha lista das pezas que necesitas para construír o circuíto:
- ESP32 DEVKIT V1
- LED de 5 mm
- Resistencia de 220 Ohm
- Pulsador
- Resistencia de 10k Ohm
- Breadboard
- Fios de puente
Diagrama esquemático
Antes de continuar, cómpre montar un circuíto cun LED e un pulsador.
Conectaremos o LED a GPIO 5 e o pulsador a GPIO 4.
Código
Abre o código Project_1_ESP32_Inputs_Outputs.ino no IDE de arduino
Como funciona o código
Nas seguintes dúas liñas, crea variables para asignar pinos:
O botón está conectado a GPIO 4 e o LED está conectado a GPIO 5. Cando se utiliza o Arduino IDE co ESP32, 4 corresponde a GPIO 4 e 5 corresponde a GPIO 5.
A continuación, crea unha variable para manter o estado do botón. Por defecto, é 0 (non presionado).
int buttonState = 0;
No setup(), inicializa o botón como INPUT e o LED como OUTPUT.
Para iso, usa a función pinMode() que acepta o pin ao que se refire, e o modo: INPUT ou OUTPUT.
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
No loop() é onde le o estado do botón e configura o LED en consecuencia.
Na seguinte liña, le o estado do botón e gárdao na variable buttonState.
Como vimos anteriormente, usa a función digitalRead().
buttonState = DigitalRead(buttonPin);
A seguinte instrución if verifica se o estado do botón é ALTO. Se é así, acende o LED usando a función digitalWrite() que acepta como argumento o ledPin e o estado HIGH.
if (buttonState == ALTO)
Se o estado do botón non é ALTO, apaga o LED. Só ten que configurar LOW como segundo argumento na función digitalWrite().
Cargando o Código
Antes de facer clic no botón de carga, vai a Ferramentas > Placa e selecciona a placa: placa DOIT ESP32 DEVKIT V1.
Vaia a Ferramentas > Porto e seleccione o porto COM ao que está conectado o ESP32. A continuación, preme o botón de carga e agarda a que apareza a mensaxe "Carga finalizada".
Nota: se ves moitos puntos (conectando…__…__) na xanela de depuración e a mensaxe "Fallo ao conectar a ESP32: esgotado o tempo esperando a cabeceira do paquete", isto significa que debes premer o botón BOOT de ESP32 integrado. botón despois dos puntos
comeza a aparecer.Solución de problemas
Demostración
Despois de cargar o código, proba o teu circuíto. O teu LED debería acenderse cando premes o botón:
E desactiva cando o soltes:
Proxecto 2 Entradas analóxicas ESP32
Este proxecto mostra como ler entradas analóxicas co ESP32 usando Arduino IDE.
A lectura analóxica é útil para ler valores de resistencias variables como potenciómetros ou sensores analóxicos.
Entradas analóxicas (ADC)
A lectura dun valor analóxico co ESP32 significa que pode medir diferentes volúmenestage niveis entre 0 V e 3.3 V.
O voltagA medida é entón asignada a un valor entre 0 e 4095, no que 0 V corresponde a 0 e 3.3 V corresponde a 4095. Calquera voltage entre 0 V e 3.3 V daráselle o valor intermedio correspondente.
ADC é non lineal
Idealmente, esperaría un comportamento lineal ao usar os pinos ESP32 ADC.
Non obstante, iso non ocorre. O que obterás é un comportamento como se mostra no seguinte gráfico:
Este comportamento significa que o seu ESP32 non é capaz de distinguir 3.3 V de 3.2 V.
Obterás o mesmo valor para os dous voltages: 4095.
O mesmo ocorre con vol. moi baixotagValores e: para 0 V e 0.1 V obterá o mesmo valor: 0. Debe ter isto en conta cando use os pines ADC ESP32.
Función analogRead().
Ler unha entrada analóxica co ESP32 usando o IDE de Arduino é tan sinxelo coma usar a función analogRead(). Acepta como argumento o GPIO que queres ler:
lectura analóxica (GPIO);
Só 15 están dispoñibles na placa DEVKIT V1 (versión con 30 GPIO).
Colle o pinout da tarxeta ESP32 e localiza os pines ADC. Estes están resaltados cun bordo vermello na figura seguinte.
Estes pinos de entrada analóxica teñen unha resolución de 12 bits. Isto significa que cando le unha entrada analóxica, o seu rango pode variar de 0 a 4095.
Nota: os pinos ADC2 non se poden usar cando se usa Wi-Fi. Polo tanto, se estás a usar wifi e tes problemas para obter o valor dun GPIO ADC2, podes considerar usar un GPIO ADC1, que debería resolver o teu problema.
Para ver como todo se une, faremos un sinxelo example para ler un valor analóxico dun potenciómetro.
Pezas necesarias
Para este example, necesitas as seguintes partes:
- Placa ESP32 DEVKIT V1
- Potenciómetro
- Breadboard
- Fios de puente
Esquemático
Conecte un potenciómetro ao seu ESP32. O pin central do potenciómetro debe estar conectado a GPIO 4. Podes usar o seguinte diagrama esquemático como referencia.
Código
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Abre o código Project_2_ESP32_Inputs_Outputs.ino no IDE de arduino
Este código simplemente le os valores do potenciómetro e imprime eses valores no monitor serie.
No código, comeza por definir o GPIO ao que está conectado o potenciómetro. Neste example, GPIO 4.
No setup(), inicializa unha comunicación en serie a unha velocidade en baudios de 115200.
No loop(), use a función analogRead() para ler a entrada analóxica do potPin.
Finalmente, imprima os valores lidos do potenciómetro no monitor serie.
Carga o código proporcionado no teu ESP32. Asegúrate de ter seleccionado o taboleiro e o porto COM correctos no menú Ferramentas.
Probando o Example
Despois de cargar o código e premer o botón de reinicio do ESP32, abra o monitor serie a unha velocidade de transmisión de 115200. Xire o potenciómetro e vexa os valores cambiando.
O valor máximo que obterá é 4095 e o valor mínimo é 0.
Concluíndo
Neste artigo aprendeu a ler entradas analóxicas usando o ESP32 co IDE de Arduino. En resumo:
- A placa ESP32 DEVKIT V1 DOIT (versión con 30 pinos) ten 15 pinos ADC que podes usar para ler entradas analóxicas.
- Estes pinos teñen unha resolución de 12 bits, o que significa que pode obter valores de 0 a 4095.
- Para ler un valor no IDE de Arduino, simplemente usa a función analogRead().
- Os pinos ADC ESP32 non teñen un comportamento lineal. Probablemente non poderás distinguir entre 0 e 0.1 V ou entre 3.2 e 3.3 V. Debe telo en conta cando use os pinos ADC.
Project 3 ESP32 PWM (saída analóxica)
Neste tutorial mostrarémosche como xerar sinais PWM co ESP32 usando Arduino IDE. Como example imos construír un circuíto sinxelo que atenua un LED usando o controlador LED PWM do ESP32.
Controlador LED PWM ESP32
O ESP32 ten un controlador PWM LED con 16 canles independentes que se poden configurar para xerar sinais PWM con diferentes propiedades.
Estes son os pasos que terás que seguir para atenuar un LED con PWM usando o IDE de Arduino:
- En primeiro lugar, debes escoller unha canle PWM. Hai 16 canles de 0 a 15.
- A continuación, cómpre configurar a frecuencia do sinal PWM. Para un LED, unha frecuencia de 5000 Hz está ben de usar.
- Tamén cómpre configurar a resolución do ciclo de traballo do sinal: tes resolucións de 1 a 16 bits. Usaremos unha resolución de 8 bits, o que significa que podes controlar o brillo do LED usando un valor de 0 a 255.
- A continuación, cómpre especificar en que GPIO ou GPIO aparecerá o sinal. Para iso empregarás a seguinte función:
ledcAttachPin (GPIO, canle)
Esta función acepta dous argumentos. O primeiro é o GPIO que emitirá o sinal e o segundo é a canle que xerará o sinal. - Finalmente, para controlar o brillo do LED mediante PWM, utiliza a seguinte función:
ledcWrite (canle, ciclo de traballo)
Esta función acepta como argumentos a canle que está a xerar o sinal PWM e o ciclo de traballo.
Pezas necesarias
Para seguir este tutorial necesitas estas partes:
- Placa ESP32 DEVKIT V1
- LED de 5 mm
- Resistencia de 220 Ohm
- Breadboard
- Fios de puente
Esquemático
Conecte un LED ao seu ESP32 como no seguinte diagrama esquemático. O LED debe estar conectado a GPIO 4.
Nota: podes usar calquera pin que queiras, sempre que poida actuar como saída. Todos os pinos que poden actuar como saídas pódense usar como pinos PWM. Para obter máis información sobre os GPIO ESP32, lea: Referencia de pinout ESP32: que pinos GPIO debería usar?
Código
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Abra o código Project_3_ESP32_PWM.ino no IDE de arduino
Comeza definindo o pin ao que está conectado o LED. Neste caso, o LED está conectado a GPIO 4.
A continuación, configura as propiedades do sinal PWM. Define unha frecuencia de 5000 Hz, escolle a canle 0 para xerar o sinal e establece unha resolución de 8 bits. Podes escoller outras propiedades, diferentes a estas, para xerar diferentes sinais PWM.
No setup(), cómpre configurar o LED PWM coas propiedades que definiu anteriormente usando a función ledcSetup() que acepta como argumentos, o ledChannel, a frecuencia e a resolución, como segue:
A continuación, debes escoller o GPIO do que recibirás o sinal. Para iso use a función ledcAttachPin() que acepta como argumentos o GPIO onde quere obter o sinal e a canle que está a xerar o sinal. Neste example, obteremos o sinal no ledPin GPIO, que corresponde ao GPIO 4. A canle que xera o sinal é o ledChannel, que corresponde á canle 0.
No ciclo, variarás o ciclo de traballo entre 0 e 255 para aumentar o brillo do LED.
E despois, entre 255 e 0 para diminuír o brillo.
Para configurar o brillo do LED, só precisa utilizar a función ledcWrite() que acepta como argumentos a canle que está a xerar o sinal e o ciclo de traballo.
Como estamos a usar resolución de 8 bits, o ciclo de traballo controlarase mediante un valor de 0 a 255. Teña en conta que na función ledcWrite() usamos a canle que xera o sinal, e non o GPIO.
Probando o Example
Carga o código no teu ESP32. Asegúrate de ter seleccionado o taboleiro e o porto COM correctos. Mira o teu circuíto. Debería ter un LED atenuador que aumente e diminúe o brillo.
Sensor de movemento PIR Project 4 ESP32
Este proxecto mostra como detectar movemento co ESP32 mediante un sensor de movemento PIR. O zumbador fará soar unha alarma cando se detecte movemento e parará a alarma cando non se detecte movemento durante un tempo predeterminado (como 4 segundos).
Como funciona o sensor de movemento HC-SR501
.
O principio de funcionamento do sensor HC-SR501 baséase no cambio da radiación infravermella no obxecto en movemento. Para ser detectado polo sensor HC-SR501, o obxecto debe cumprir dous requisitos:
- O obxecto está emitindo pola vía infravermella.
- O obxecto estase movendo ou tremendo
Entón:
Se un obxecto está a emitir o raio infravermello pero non se move (por exemplo, unha persoa está parada sen moverse), o sensor NON o detecta.
Se un obxecto se está movendo pero NON emite o raio infravermello (por exemplo, robot ou vehículo), o sensor NON o detecta.
Presentación de Temporizadores
Neste example tamén introduciremos temporizadores. Queremos que o LED permaneza acendido durante un número predeterminado de segundos despois de que se detecte o movemento. En lugar de usar unha función delay() que bloquea o teu código e non che permite facer nada máis durante un número determinado de segundos, deberíamos usar un temporizador.
A función delay().
Debería estar familiarizado coa función delay() xa que é moi utilizada. Esta función é bastante sinxela de usar. Acepta un único número int como argumento.
Este número representa o tempo en milisegundos que o programa ten que esperar ata pasar á seguinte liña de código.
Cando retrasas (1000) o teu programa detense nesa liña durante 1 segundo.
delay() é unha función de bloqueo. As funcións de bloqueo impiden que un programa faga outra cousa ata que se complete esa tarefa en particular. Se precisa que se realicen varias tarefas ao mesmo tempo, non pode usar delay().
Para a maioría dos proxectos, debes evitar usar atrasos e usar temporizadores no seu lugar.
A función millis().
Usando unha función chamada millis() pode devolver o número de milisegundos que pasaron desde que se iniciou o programa.
Por que é útil esa función? Porque usando algunhas matemáticas, podes verificar facilmente canto tempo pasou sen bloquear o teu código.
Pezas necesarias
Para seguir este tutorial necesitas as seguintes partes
- Placa ESP32 DEVKIT V1
- Sensor de movemento PIR (HC-SR501)
- Zumbador activo
- Fios de puente
- Breadboard
Esquemático
Nota: O traballo voltage do HC-SR501 é de 5 V. Use o pin Vin para alimentalo.
Código
Antes de continuar con este tutorial, debes ter o complemento ESP32 instalado no teu IDE de Arduino. Siga un dos seguintes tutoriais para instalar o ESP32 no IDE de Arduino, se aínda non o fixeches. (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Abra o código Project_4_ESP32_PIR_Motion_Sensor.ino no IDE de arduino.
Demostración
Carga o código na túa placa ESP32. Asegúrate de ter seleccionado o taboleiro e o porto COM correctos. Pasos de referencia do código de carga.
Abra o monitor en serie a unha velocidade en baudios de 115200.
Move a man diante do sensor PIR. O zumbador debería acenderse e a mensaxe impresa no monitor en serie di "Movemento detectado! Alarma do zumbador".
Despois de 4 segundos, o timbre debería apagarse.
Interruptor Project 5 ESP32 Web Servidor
Neste proxecto crearás un autónomo web servidor cun ESP32 que controla as saídas (dous LED) mediante o entorno de programación Arduino IDE. O web o servidor responde aos móbiles e pódese acceder con calquera dispositivo que sexa como navegador na rede local. Imos amosarche como crear o web servidor e como funciona o código paso a paso.
Proxecto rematadoview
Antes de ir directamente ao proxecto, é importante esbozar o noso web servidor fará, para que sexa máis fácil seguir os pasos máis adiante.
- O web servidor creará os controis dous LED conectados ao ESP32 GPIO 26 e GPIO 27;
- Podes acceder ao ESP32 web servidor escribindo o enderezo IP ESP32 nun navegador da rede local;
- Premendo nos botóns do teu web servidor pode cambiar instantaneamente o estado de cada LED.
Pezas necesarias
Para este tutorial necesitarás as seguintes partes:
- Placa ESP32 DEVKIT V1
- 2 x 5 mm LED
- 2 x resistencia de 200 ohmios
- Breadboard
- Fios de puente
Esquemático
Comeza construíndo o circuíto. Conecte dous LED ao ESP32 como se mostra no seguinte diagrama esquemático: un LED conectado a GPIO 26 e o outro a GPIO 27.
Nota: Estamos a usar a placa ESP32 DEVKIT DOIT con 36 pinos. Antes de montar o circuíto, asegúrese de comprobar o pinout da placa que está a usar.
Código
Aquí fornecemos o código que crea o ESP32 web servidor. Abre o código Project_5_ESP32_Switch _Web_Server.ino no IDE de arduino, pero aínda non o cargue. Debes facer algúns cambios para que che funcione.
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Establecer as súas credenciais de rede
Debe modificar as seguintes liñas coas súas credenciais de rede: SSID e contrasinal. O código está ben comentado sobre onde debes facer os cambios.
Cargando o Código
Agora, podes cargar o código e e o web servidor funcionará inmediatamente.
Siga os seguintes pasos para cargar código no ESP32:
- Conecte a tarxeta ESP32 ao seu ordenador;
- No IDE de Arduino selecciona a túa placa en Ferramentas > Placa (no noso caso estamos a usar a placa ESP32 DEVKIT DOIT);
- Seleccione o porto COM en Ferramentas > Porto.
- Preme o botón Cargar no IDE de Arduino e agarda uns segundos mentres o código se compila e se carga no teu taboleiro.
- Agarde a mensaxe de "Carga finalizada".
Buscando o enderezo IP ESP
Despois de cargar o código, abra o monitor serie a unha velocidade de transmisión de 115200.
Preme o botón ESP32 EN (reset). O ESP32 conéctase a Wi-Fi e emite o enderezo IP ESP no monitor serie. Copia ese enderezo IP, porque o necesitas para acceder ao ESP32 web servidor.
Accedendo ao Web Servidor
Para acceder ao web servidor, abra o seu navegador, pegue o enderezo IP de ESP32 e verá a seguinte páxina.
Nota: O teu navegador e ESP32 deben estar conectados á mesma LAN.
Se botas un ollo ao Monitor en serie, podes ver o que está a suceder en segundo plano. O ESP recibe unha solicitude HTTP dun novo cliente (neste caso, o teu navegador).
Tamén podes ver outra información sobre a solicitude HTTP.
Demostración
Agora podes probar se o teu web servidor funciona correctamente. Fai clic nos botóns para controlar os LED.
Ao mesmo tempo, podes botarlle unha ollada ao Monitor Serial para ver o que está a suceder en segundo plano. Por example, cando fai clic no botón para activar GPIO 26, ESP32 recibe unha solicitude no /26/on URL.
Cando o ESP32 recibe esa solicitude, acende o LED conectado ao GPIO 26 e actualiza o seu estado no web páxina.
O botón para GPIO 27 funciona dun xeito similar. Proba que funciona correctamente.
Como funciona o código
Nesta sección verá máis de cerca o código para ver como funciona.
O primeiro que cómpre facer é incluír a biblioteca WiFi.
Como se mencionou anteriormente, cómpre inserir o seu ssid e contrasinal nas seguintes liñas dentro das comiñas dobres.
Despois, configura o teu web servidor ao porto 80.
A seguinte liña crea unha variable para almacenar a cabeceira da solicitude HTTP:
A continuación, crea variables auxiliares para almacenar o estado actual das súas saídas. Se queres engadir máis saídas e gardar o seu estado, cómpre crear máis variables.
Tamén debes asignar un GPIO a cada unha das túas saídas. Aquí estamos usando GPIO 26 e GPIO 27. Podes usar calquera outro GPIO axeitado.
configuración ()
Agora, imos á configuración (). En primeiro lugar, iniciamos unha comunicación en serie a unha velocidade en baudios de 115200 para fins de depuración.
Tamén defines os teus GPIO como SAÍDAS e configuralos en BAIXO.
As liñas seguintes comezan a conexión Wi-Fi con WiFi.begin(ssid, contrasinal), agarda a conexión exitosa e imprime o enderezo IP ESP no monitor serie.
loop()
No loop() programamos o que ocorre cando un novo cliente establece unha conexión co web servidor.
O ESP32 sempre escoita os clientes entrantes coa seguinte liña:
Cando se reciba unha solicitude dun cliente, gardaremos os datos entrantes. O bucle while que segue executarase mentres o cliente permaneza conectado. Non recomendamos cambiar a seguinte parte do código a menos que saibas exactamente o que estás facendo.
A seguinte sección das declaracións if e else comproba que botón se premeu no teu web páxina e controla as saídas en consecuencia. Como vimos anteriormente, facemos unha solicitude en diferentes URLs dependendo do botón pulsado.
Por example, se premeches o botón GPIO 26 ON, o ESP32 recibe unha solicitude no /26/ON URL (podemos ver que esa información está na cabeceira HTTP do monitor serie). Así, podemos comprobar se a cabeceira contén a expresión GET /26/on. Se contén, cambiamos a variable output26state a ON e o ESP32 acende o LED.
Isto funciona de forma similar para os outros botóns. Polo tanto, se queres engadir máis saídas, debes modificar esta parte do código para incluílas.
Mostrando o HTML web páxina
O seguinte que debes facer é crear o web páxina. O ESP32 enviará unha resposta ao teu navegador con algún código HTML para crear o web páxina.
O web a páxina envíase ao cliente usando esta expresión client.println(). Debes introducir o que queres enviar ao cliente como argumento.
O primeiro que debemos enviar é sempre a seguinte liña, que indica que estamos enviando HTML.
Entón, a seguinte liña fai o web páxina sensible en calquera web navegador.
E o seguinte úsase para evitar solicitudes no favicon. – Non te preocupes por esta liña.
Estilizando o Web Páx
A continuación, temos un pouco de texto CSS para estilizar os botóns e o web aspecto da páxina.
Escollemos a fonte Helvetica, definimos o contido que se mostrará como un bloque e aliñamos no centro.
Peleamos os nosos botóns coa cor #4CAF50, sen bordo, texto en cor branca e con este recheo: 16px 40px. Tamén establecemos a decoración do texto en ningún, definimos o tamaño da fonte, a marxe e o cursor a un punteiro.
Tamén definimos o estilo dun segundo botón, con todas as propiedades do botón que definimos anteriormente, pero cunha cor diferente. Este será o estilo para o botón de apagado.
Configurando o Web Primeiro título da páxina
Na seguinte liña podes establecer o primeiro título do teu web páxina. Aquí temos "ESP32 Web Servidor”, pero podes cambiar este texto polo que queiras.
Mostrando os botóns e o estado correspondente
Despois, escribe un parágrafo para mostrar o estado actual de GPIO 26. Como podes ver, usamos a variable output26State, para que o estado actualice ao instante cando esta variable cambie.
Despois, mostramos o botón de acendido ou apagado, dependendo do estado actual do GPIO. Se o estado actual do GPIO está desactivado, mostramos o botón ON, se non, mostramos o botón OFF.
Usamos o mesmo procedemento para GPIO 27.
Pechando a conexión
Finalmente, cando remata a resposta, borramos a variable de cabeceira e detemos a conexión co cliente con client.stop().
Concluíndo
Neste tutorial mostrámosche como construír un web servidor con ESP32. Mostrámosche un ex sinxeloample que controla dous LED, pero a idea é substituír eses LED por un relé, ou calquera outra saída que queira controlar.
Project 6 LED RGB Web Servidor
Neste proxecto mostrarémosche como controlar remotamente un LED RGB cunha placa ESP32 usando un web servidor cun selector de cores.
Proxecto rematadoview
Antes de comezar, vexamos como funciona este proxecto:
- O ESP32 web o servidor mostra un selector de cores.
- Cando escolleches unha cor, o teu navegador fai unha solicitude en a URL que contén os parámetros R, G e B da cor seleccionada.
- O teu ESP32 recibe a solicitude e divide o valor de cada parámetro de cor.
- Despois, envía un sinal PWM co valor correspondente aos GPIO que controlan o LED RGB.
Como funcionan os LED RGB?
Nun LED RGB de cátodo común, os tres LED comparten unha conexión negativa (cátodo). Todos os incluídos no kit son RGB de cátodo común.
Como crear cores diferentes?
Cun LED RGB pode, por suposto, producir luz vermella, verde e azul e, configurando a intensidade de cada LED, tamén pode producir outras cores.
Por example, para producir luz puramente azul, establecería o LED azul coa intensidade máis alta e os LED verde e vermello coa intensidade máis baixa. Para unha luz branca, establecería os tres LED á maior intensidade.
Mestura de cores
Para producir outras cores, pode combinar as tres cores en diferentes intensidades. Para axustar a intensidade de cada LED pode utilizar un sinal PWM.
Debido a que os LED están moi preto uns dos outros, os nosos ollos ven o resultado da combinación de cores, e non as tres cores individualmente.
Para ter unha idea de como combinar as cores, bótalle un ollo ao seguinte gráfico.
Este é o gráfico de mestura de cores máis sinxelo, pero dáche unha idea de como funciona e como producir cores diferentes.
Pezas necesarias
Para este proxecto necesitas as seguintes partes:
- Placa ESP32 DEVKIT V1
- LED RGB
- 3 resistencias de 220 ohmios
- Fios de puente
- Breadboard
Esquemático
Código
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
- Instalación do complemento ESP32 no IDE de Arduino
Despois de montar o circuíto, abra o código
Proxecto_6_RGB_LED_Web_Server.ino no IDE de arduino.
Antes de cargar o código, non esquezas inserir as túas credenciais de rede para que o ESP poida conectarse á túa rede local.
Como funciona o código
O sketch ESP32 usa a biblioteca WiFi.h.
As liñas seguintes definen variables de cadea para manter os parámetros R, G e B da solicitude.
As seguintes catro variables úsanse para decodificar a solicitude HTTP máis adiante.
Crea tres variables para os GPIO que controlarán os parámetros R, G e B da tira. Neste caso, estamos a usar GPIO 13, GPIO 12 e GPIO 14.
Estes GPIO precisan emitir sinais PWM, polo que primeiro necesitamos configurar as propiedades PWM. Establece a frecuencia do sinal PWM en 5000 Hz. A continuación, asocia unha canle PWM para cada cor
E, finalmente, configura a resolución das canles PWM en 8 bits
Na configuración (), asigne as propiedades PWM ás canles PWM
Conecte as canles PWM aos GPIO correspondentes
A seguinte sección de código mostra o selector de cores no teu web páxina e fai unha solicitude en función da cor que escolleches.
Cando escollas unha cor, recibes unha solicitude co seguinte formato.
Entón, necesitamos dividir esta cadea para obter os parámetros R, G e B. Os parámetros gárdanse nas variables redString, greenString e blueString e poden ter valores entre 0 e 255.
Para controlar a tira co ESP32, use a función ledcWrite() para xerar sinais PWM cos valores descodificados do HTTP solicitude.
Nota: Obtén máis información sobre PWM con ESP32: Project 3 ESP32 PWM (saída analóxica)
Para controlar a tira co ESP8266, só necesitamos usala
a función analogWrite() para xerar sinais PWM cos valores descodificados da solicitude HTPP.
analogWrite(redPin, redString.toInt());
analogWrite(greenPin, greenString.toInt());
analogWrite(bluePin, blueString.toInt())
Como obtemos os valores nunha variable de cadea, necesitamos convertelos en números enteiros usando o método toInt().
Demostración
Despois de inserir as súas credenciais de rede, seleccione o taboleiro correcto e o porto COM e cargue o código no seu ESP32. Pasos de referencia do código de carga.
Despois de cargar, abra o monitor serie a unha velocidade en baudios de 115200 e prema o botón Activar/Reiniciar ESP. Debería obter o enderezo IP do taboleiro.
Abra o seu navegador e insira o enderezo IP ESP. Agora, usa o selector de cores para escoller unha cor para o LED RGB.
A continuación, cómpre premer o botón "Cambiar cor" para que a cor teña efecto.
Para apagar o LED RGB, selecciona a cor negra.
As cores máis fortes (na parte superior do selector de cores), son as que producirán mellores resultados.
Proxecto 7 Rele ESP32 Web Servidor
Usar un relé co ESP32 é unha boa forma de controlar os electrodomésticos de CA de forma remota. Este tutorial explica como controlar un módulo de relé co ESP32.
Veremos como funciona un módulo de relé, como conectar o relé ao ESP32 e construír un web servidor para controlar un relé de forma remota.
Presentación de Relés
Un relé é un interruptor accionado eléctricamente e como calquera outro interruptor, que se pode acender ou apagar, deixando pasar a corrente ou non. Pódese controlar con baixo voltages, como o 3.3V que proporcionan os GPIO ESP32 e permítenos controlar o alto voltagé como 12 V, 24 V ou volta de redetage (230 V en Europa e 120 V nos EE. UU.).
No lado esquerdo, hai dous xogos de tres tomas para conectar o alto voltages, e os pinos do lado dereito (baixo voltage) conectarse aos GPIO ESP32.
Rede Voltage Conexións
O módulo de relé que se mostra na foto anterior ten dous conectores, cada un con tres tomas: común (COM), normalmente pechado (NC) e normalmente aberto (NO).
- COM: conecte a corrente que quere controlar (red voltage).
- NC (Normalmente pechado): a configuración normalmente pechada úsase cando se quere que o relé estea pechado por defecto. Os pinos NC son COM conectados, o que significa que a corrente está a fluír a menos que envíe un sinal desde o ESP32 ao módulo de relé para abrir o circuíto e deter o fluxo de corrente.
- NO (Normalmente Aberto): a configuración normalmente aberta funciona ao revés: non hai conexión entre os pinos NO e COM, polo que o circuíto está roto a non ser que envíe un sinal desde o ESP32 para pechar o circuíto.
Pines de control
O baixo volumetagO lado ten un conxunto de catro pinos e un conxunto de tres pinos. O primeiro conxunto consta de VCC e GND para alimentar o módulo, e a entrada 1 (IN1) e a entrada 2 (IN2) para controlar os relés inferior e superior, respectivamente.
Se o teu módulo de relé só ten unha canle, só terás un pin IN. Se tes catro canles, terás catro pins IN e así por diante.
O sinal que envías aos pines IN determina se o relé está activo ou non. O relé activase cando a entrada baixa a uns 2 V. Isto significa que terás os seguintes escenarios:
- Configuración normalmente pechada (NC):
- Sinal ALTO: a corrente está a fluír
- Sinal BAIXO: a corrente non circula
- Configuración normalmente aberta (NON):
- Sinal ALTO: non circula a corrente
- Sinal BAIXO: corrente en circulación
Debería usar unha configuración normalmente pechada cando a corrente debería estar fluíndo a maioría das veces, e só quere parala ocasionalmente.
Use unha configuración normalmente aberta cando quere que a corrente fluya ocasionalmente (por exemploample, activar alamp ocasionalmente).
Selección da fonte de alimentación
O segundo conxunto de pinos consiste en pinos GND, VCC e JD-VCC.
O pin JD-VCC alimenta o electroimán do relé. Teña en conta que o módulo ten unha tapa de puente que conecta os pinos VCC e JD-VCC; o que se mostra aquí é amarelo, pero o teu pode ser dunha cor diferente.
Coa tapa do puente posto, os pinos VCC e JD-VCC están conectados. Isto significa que o electroimán do relé está alimentado directamente desde o pin de alimentación ESP32, polo que o módulo de relé e os circuítos ESP32 non están fisicamente illados entre si.
Sen a tapa do puente, cómpre proporcionar unha fonte de enerxía independente para alimentar o electroimán do relé a través do pin JD-VCC. Esa configuración illa fisicamente os relés do ESP32 co optoacoplador incorporado do módulo, o que evita danos ao ESP32 en caso de picos eléctricos.
Esquemático
Aviso: Uso de alto voltagAs fontes de alimentación poden causar lesións graves.
Polo tanto, utilízanse LEDs de 5 mm en lugar de alto volumen de subministracióntage lámpadas no experimento. Se non estás familiarizado co voltagPregúntalle a alguén que te axude. Durante a programación do ESP ou o cableado do seu circuíto, asegúrese de que todo estea desconectado da redetage.
Instalación da biblioteca para ESP32
Para construír isto web servidor, usamos o ESPAsyncWebBiblioteca do servidor e biblioteca AsyncTCP.
Instalación de ESPAsyncWebBiblioteca do servidor
Siga os seguintes pasos para instalar ESPAsyncWebServidor biblioteca:
- Fai clic aquí para descargar o ESPAsyncWebBiblioteca do servidor. Deberías ter
un cartafol .zip no cartafol Descargas - Descomprime o cartafol .zip e deberías obter ESPAsyncWebCartafol servidor-master
- Cambia o nome do teu cartafol desde ESPAsyncWebServer-master para ESPAsyncWebServidor
- Move o ESPAsyncWebCartafol do servidor ao cartafol das bibliotecas de instalación de Arduino IDE
Alternativamente, no teu IDE de Arduino, podes ir a Sketch > Incluír
Biblioteca > Engadir biblioteca .ZIP... e selecciona a biblioteca que acabas de descargar.
Instalación da biblioteca AsyncTCP para ESP32
O ESPAsyncWebServidor biblioteca require o AsyncTCP biblioteca para traballar. Segue
os seguintes pasos para instalar esa biblioteca:
- Fai clic aquí para descargar a biblioteca AsyncTCP. Debería ter un cartafol .zip no cartafol Descargas
- Descomprime o cartafol .zip e deberías obter o cartafol principal de AsyncTCP
1. Cambia o nome do teu cartafol de AsyncTCP-master a AsyncTCP
3. Move o cartafol AsyncTCP ao cartafol das bibliotecas de instalación de Arduino IDE
4. Finalmente, volve abrir o teu IDE de Arduino
Alternativamente, no teu IDE de Arduino, podes ir a Sketch > Incluír
Biblioteca > Engadir biblioteca .ZIP... e selecciona a biblioteca que acabas de descargar.
Código
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Despois de instalar as bibliotecas necesarias, abra o código Project_7_ESP32_Relay_Web_Server.ino no IDE de arduino.
Antes de cargar o código, non esquezas inserir as túas credenciais de rede para que o ESP poida conectarse á túa rede local.
Demostración
Despois de facer os cambios necesarios, carga o código no teu ESP32.Pasos de referencia do código de carga.
Abra o monitor en serie a unha velocidade en baudios de 115200 e prema o botón ESP32 EN para obter o seu enderezo IP. Despois, abra un navegador na súa rede local e escriba o enderezo IP ESP32 para acceder ao web servidor.
Abra o monitor en serie a unha velocidade en baudios de 115200 e prema o botón ESP32 EN para obter o seu enderezo IP. Despois, abra un navegador na súa rede local e escriba o enderezo IP ESP32 para acceder ao web servidor.
Nota: O teu navegador e ESP32 deben estar conectados á mesma LAN.
Debería obter algo do seguinte xeito con dous botóns como o número de relés que definiu no seu código.
Agora podes usar os botóns para controlar os teus relés co teu teléfono intelixente.
Proxecto_8_Sincronización_Estado_Saída_ Web_Servidor
Este proxecto mostra como controlar as saídas ESP32 ou ESP8266 usando un web servidor e un botón físico simultáneamente. O estado de saída actualízase no web páxina se se cambia mediante un botón físico ou web servidor.
Proxecto rematadoview
Vexamos rapidamente como funciona o proxecto.
O ESP32 ou o ESP8266 alberga a web servidor que permite controlar o estado dunha saída;
- O estado de saída actual móstrase no web servidor;
- O ESP tamén está conectado a un pulsador físico que controla a mesma saída;
- Se cambia o estado de saída mediante o botón pulsador físico, o seu estado actual tamén se actualiza no web servidor.
En resumo, este proxecto permítelle controlar a mesma saída usando a web servidor e un pulsador simultáneamente. Sempre que o estado de saída cambia, o web o servidor está actualizado.
Pezas necesarias
Aquí tes unha lista das pezas que necesitas para construír o circuíto:
- Placa ESP32 DEVKIT V1
- LED de 5 mm
- Resistencia de 220 ohms
- Pulsador
- Resistencia de 10k Ohm
- Breadboard
- Fios de puente
Esquemático
Instalación da biblioteca para ESP32
Para construír isto web servidor, usamos o ESPAsyncWebBiblioteca do servidor e biblioteca AsyncTCP. (Se xa fixo este paso, pode pasar ao seguinte paso).
Instalación de ESPAsyncWebBiblioteca do servidor
Siga os seguintes pasos para instalar o ESPAsyncWebBiblioteca do servidor:
- Fai clic aquí para descargar o ESPAsyncWebBiblioteca do servidor. Deberías ter
un cartafol .zip no cartafol Descargas - Descomprime o cartafol .zip e deberías obter ESPAsyncWebCartafol servidor-master
- Cambia o nome do teu cartafol desde ESPAsyncWebServer-master para ESPAsyncWebServidor
- Move o ESPAsyncWebCartafol do servidor ao cartafol das bibliotecas de instalación de Arduino IDE
Alternativamente, no teu IDE de Arduino, podes ir a Sketch > Incluír
Biblioteca > Engadir biblioteca .ZIP... e selecciona a biblioteca que acabas de descargar.
Instalación da biblioteca AsyncTCP para ESP32
O ESPAsyncWebA biblioteca do servidor require a biblioteca AsyncTCP para funcionar. Siga os seguintes pasos para instalar esa biblioteca:
- Fai clic aquí para descargar a biblioteca AsyncTCP. Debería ter un cartafol .zip no cartafol Descargas
- Descomprime o cartafol .zip e deberías obter o cartafol principal de AsyncTCP
- Cambia o nome do teu cartafol de AsyncTCP-master a AsyncTCP
- Move o cartafol AsyncTCP ao cartafol das bibliotecas de instalación de Arduino IDE
- Finalmente, volve abrir o teu IDE de Arduino
Alternativamente, no teu IDE de Arduino, podes ir a Sketch > Incluír
Biblioteca > Engadir biblioteca .ZIP... e selecciona a biblioteca que acabas de descargar.
Código
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Despois de instalar as bibliotecas necesarias, abra o código
Proxecto_8_Sincronización_Estado_Saída_Web_Server.ino no IDE de arduino.
Antes de cargar o código, non esquezas inserir as túas credenciais de rede para que o ESP poida conectarse á túa rede local.
Como funciona o código
Estado do botón e estado de saída
A variable ledState mantén o estado de saída do LED. Por defecto, cando o web o servidor comeza, é BAIXO.
ButtonState e lastButtonState utilízanse para detectar se o pulsador foi presionado ou non.
Botón (web servidor)
Non incluímos o HTML para crear o botón na variable index_html.
Iso é porque queremos poder cambialo dependendo do estado actual do LED que tamén se pode cambiar co pulsador.
Entón, creamos un marcador de posición para o botón %BUTTONPLACEHOLDER% que será substituído por texto HTML para crear o botón máis tarde no código (isto faise na función procesador()).
procesador ()
A función procesador() substitúe os marcadores de posición do texto HTML con valores reais. En primeiro lugar, comproba se os textos HTML contén algún
marcadores de posición %BUTTONPLACEHOLDER%.
A continuación, chame á funciónoutputState() que devolve o estado de saída actual. Gardamos na variable outputStateValue.
Despois diso, use ese valor para crear o texto HTML para mostrar o botón co estado correcto:
Solicitude HTTP GET para cambiar o estado de saída (JavaScript)
Cando preme o botón, chámase a función toggleCheckbox(). Esta función fará unha solicitude en diferentes URLs para acender ou apagar o LED.
Para acender o LED, fai unha solicitude no /update?state=1 URL:
En caso contrario, fai unha solicitude no /update?state=0 URL.
Solicitude HTTP GET para actualizar o estado (JavaScript)
Para manter o estado de saída actualizado no web servidor, chamamos á seguinte función que fai unha nova solicitude no /state URL cada segundo.
Xestionar solicitudes
Entón, necesitamos xestionar o que ocorre cando o ESP32 ou o ESP8266 reciben solicitudes URLs.
Cando se recibe unha solicitude na raíz /URL, enviamos a páxina HTML así como o procesador.
As seguintes liñas comproban se recibiu unha solicitude no /update?state=1 ou /update?state=0 URL e cambia o ledState en consecuencia.
Cando se recibe unha solicitude no /state URL, enviamos o estado de saída actual:
loop()
No loop(), desbotamos o pulsador e acendemos ou apagamos o LED dependendo do valor do ledState variable.
Demostración
Carga o código na túa placa ESP32. Carga os pasos de referencia do código.
A continuación, abra o monitor serie a unha velocidade en baudios de 115200. Prema o botón EN/RST incorporado para obter o seu enderezo IP.
Abra un navegador na súa rede local e escriba o enderezo IP ESP. Debería ter acceso ao web servidor como se mostra a continuación.
Nota: O teu navegador e ESP32 deben estar conectados á mesma LAN.
Podes alternar o botón do web servidor para acender o LED.
Tamén pode controlar o mesmo LED co pulsador físico. O seu estado sempre actualizarase automaticamente no web servidor.
Proxecto 9 ESP32 DHT11 Web Servidor
Neste proxecto, aprenderás a construír un ESP32 asíncrono web servidor co DHT11 que mostra a temperatura e a humidade usando Arduino IDE.
Requisitos previos
O web actualizaremos as lecturas automaticamente sen necesidade de actualizar o servidor web páxina.
Con este proxecto aprenderás:
- Como ler a temperatura e a humidade dos sensores DHT;
- Construír un asincrónico web servidor usando o ESPAsyncWebBiblioteca do servidor;
- Actualiza as lecturas do sensor automaticamente sen necesidade de actualizar o web páxina.
Asíncrono Web Servidor
Para construír o web servidor que usaremos ESPAsyncWebBiblioteca do servidor que proporciona un xeito sinxelo de construír un asincrónico web servidor. Construíndo un asíncrono web servidor ten varios advantages como se menciona na páxina de GitHub da biblioteca, como:
- "Xestionar máis dunha conexión ao mesmo tempo";
- "Cando envía a resposta, está inmediatamente preparado para xestionar outras conexións mentres o servidor se encarga de enviar a resposta en segundo plano";
- "Motor sinxelo de procesamento de modelos para manexar modelos";
Pezas necesarias
Para completar este tutorial necesitas as seguintes partes:
- Placa de desenvolvemento ESP32
- Módulo DHT11
- Breadboard
- Fios de puente
Esquemático
Instalación de bibliotecas
Necesitas instalar un par de bibliotecas para este proxecto:
- O DHT e o Sensor unificado de Adafruit Bibliotecas de controladores para ler desde o sensor DHT.
- ESPAsyncWebServidor e TCP asíncrono bibliotecas para construír o asíncrono web servidor.
Siga as seguintes instrucións para instalar esas bibliotecas:
Instalación da biblioteca de sensores DHT
Para ler desde o sensor DHT usando Arduino IDE, cómpre instalar o Biblioteca de sensores DHT. Siga os seguintes pasos para instalar a biblioteca.
- Fai clic aquí para descargar a biblioteca de sensores DHT. Debería ter un cartafol .zip no cartafol Descargas
- Descomprime o cartafol .zip e deberías obter o cartafol DHT-sensor-library-master
- Cambia o nome do teu cartafol de DHT-sensor-library-master a DHT_sensor
- Move o cartafol DHT_sensor ao cartafol das bibliotecas de instalación de Arduino IDE
- Finalmente, volve abrir o teu IDE de Arduino
Instalación do controlador de sensor unificado de Adafruit
Tamén cómpre instalar o Biblioteca de controladores de sensor unificado de Adafruit para traballar co sensor DHT. Siga os seguintes pasos para instalar a biblioteca.
- Fai clic aquí para descargar a biblioteca de sensores unificados de Adafruit. Debería ter un cartafol .zip no cartafol Descargas
- Descomprime o cartafol .zip e deberías obter o cartafol Adafruit_sensor-master
- Cambia o nome do teu cartafol de Adafruit_sensor-master a Adafruit_sensor
- Move o cartafol Adafruit_sensor ao cartafol das bibliotecas de instalación de Arduino IDE
- Finalmente, volve abrir o teu IDE de Arduino
Instalación de ESPAsyncWebBiblioteca do servidor
Siga os seguintes pasos para instalar ESPAsyncWebServidor biblioteca:
- Fai clic aquí para descargar o ESPAsyncWebBiblioteca do servidor. Deberías ter
un cartafol .zip no cartafol Descargas - Descomprime o cartafol .zip e deberías
obtén ESPAsyncWebCartafol servidor-master - Cambia o nome do teu cartafol desde ESPAsyncWebServer-master para ESPAsyncWebServidor
- Move o ESPAsyncWebCartafol do servidor ao cartafol das bibliotecas de instalación de Arduino IDE
Instalación da biblioteca Async TCP para ESP32
O ESPAsyncWebServidor biblioteca require o AsyncTCP biblioteca para traballar. Siga os seguintes pasos para instalar esa biblioteca:
- Fai clic aquí para descargar a biblioteca AsyncTCP. Debería ter un cartafol .zip no cartafol Descargas
- Descomprime o cartafol .zip e deberías obter o cartafol principal de AsyncTCP
- Cambia o nome do teu cartafol de AsyncTCP-master a AsyncTCP
- Move o cartafol AsyncTCP ao cartafol das bibliotecas de instalación de Arduino IDE
- Finalmente, volve abrir o teu IDE de Arduino
Código
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Despois de instalar as bibliotecas necesarias, abra o código
Proxecto_9_ESP32_DHT11_Web_Server.ino no IDE de arduino.
Antes de cargar o código, non esquezas inserir as túas credenciais de rede para que o ESP poida conectarse á túa rede local.
Como funciona o código
Nos seguintes parágrafos explicaremos como funciona o código. Continúa lendo se queres saber máis ou salta á sección Demostración para ver o resultado final.
Importación de bibliotecas
En primeiro lugar, importa as bibliotecas necesarias. O WiFi, ESPAsyncWebO servidor e o ESPAsyncTCP son necesarios para construír o web servidor. As bibliotecas Adafruit_Sensor e DHT son necesarias para ler desde os sensores DHT11 ou DHT22.
Definición de variables
Define o GPIO ao que está conectado o pin de datos DHT. Neste caso, está conectado a GPIO 4.
A continuación, seleccione o tipo de sensor DHT que está a usar. No noso example, estamos usando o DHT22. Se estás a usar outro tipo, só tes que descomentar o teu sensor e comentar todos os demais.
Instancia un obxecto DHT co tipo e pin que definimos anteriormente.
Crear un asíncronoWebObxecto servidor no porto 80.
Ler as funcións de temperatura e humidade
Creamos dúas funcións: unha para ler a temperatura Creamos dúas funcións: unha para ler a temperatura (readDHTTemperature()) e outra para ler a humidade (readDHTHhumidity()).
Obter lecturas dos sensores é tan sinxelo coma usar. Obter lecturas dos sensores é tan sinxelo coma usar os métodos readTemperature() e readHumidity() no obxecto dht.
Tamén temos unha condición que devolve dous trazos (–) no caso de que o sensor non obteña as lecturas.
As lecturas devólvense como tipo de cadea. Para converter un flotante nunha cadea, use a función String().
Por defecto, estamos lendo a temperatura en graos Celsius. Para obter a temperatura en graos Fahrenheit, comenta a temperatura en Celsius e descomenta a temperatura en Fahrenheit, para que teñas o seguinte:
Cargue o código
Agora, carga o código no teu ESP32. Asegúrate de ter seleccionado o taboleiro e o porto COM correctos. Pasos de referencia do código de carga.
Despois de cargar, abra o monitor serie a unha velocidade de transmisión de 115200. Preme o botón de reinicio do ESP32. O enderezo IP do ESP32 debe imprimirse na serie monitor.
Demostración
Abra un navegador e escriba o enderezo IP ESP32. O teu web o servidor debería mostrar as últimas lecturas do sensor.
Nota: O teu navegador e ESP32 deben estar conectados á mesma LAN.
Teña en conta que as lecturas de temperatura e humidade actualízanse automaticamente sen necesidade de actualizar web páxina.
Project_10_ESP32_OLED_Display
Este proxecto mostra como usar a pantalla OLED SSD0.96 de 1306 polgadas con ESP32 usando Arduino IDE.
Presentamos a pantalla OLED de 0.96 polgadas
O Pantalla OLED que usaremos neste tutorial é o modelo SSD1306: unha pantalla monocolor de 0.96 polgadas con 128×64 píxeles como se mostra na seguinte figura.
A pantalla OLED non require luz de fondo, o que dá como resultado un contraste moi agradable en ambientes escuros. Ademais, os seus píxeles consomen enerxía só cando están acesos, polo que a pantalla OLED consome menos enerxía en comparación con outras pantallas.
Debido a que a pantalla OLED usa o protocolo de comunicación I2C, o cableado é moi sinxelo. Podes utilizar a seguinte táboa como referencia.
| Pin OLED | ESP 32 |
| Vin | 3.3 V |
| GND | GND |
| SCL | GPIO 22 |
| SDA | GPIO 21 |
Esquemático
Instalación da biblioteca OLED SSD1306 - ESP32
Hai varias bibliotecas dispoñibles para controlar a pantalla OLED co ESP32.
Neste tutorial usaremos dúas bibliotecas de Adafruit: Biblioteca Adafruit_SSD1306 e Biblioteca Adafruit_GFX.
Siga os seguintes pasos para instalar esas bibliotecas.
- Abre o teu Arduino IDE e vai a Sketch > Incluír biblioteca > Xestionar bibliotecas. O xestor da biblioteca debería abrir.
- Escribe "SSD1306" na caixa de busca e instala a biblioteca SSD1306 de Adafruit.
- Despois de instalar a biblioteca SSD1306 de Adafruit, escriba "GFX" na caixa de busca e instale a biblioteca.
- Despois de instalar as bibliotecas, reinicie o seu IDE Arduino.
Código
Despois de instalar as bibliotecas necesarias, abra o Project_10_ESP32_OLED_Display.ino no IDE de arduino. código
Programaremos o ESP32 usando Arduino IDE, así que asegúrate de ter instalado o complemento ESP32 antes de continuar: (Se xa fixeches este paso, podes pasar ao seguinte paso).
Instalación do complemento ESP32 no IDE de Arduino
Como funciona o código
Importación de bibliotecas
En primeiro lugar, cómpre importar as bibliotecas necesarias. A biblioteca Wire para usar I2C e as bibliotecas Adafruit para escribir na pantalla: Adafruit_GFX e Adafruit_SSD1306.
Inicializa a pantalla OLED
Despois, define o ancho e a altura do OLED. Neste example, estamos usando unha pantalla OLED de 128×64. Se estás a usar outros tamaños, podes cambialo nas variables SCREEN_WIDTH e SCREEN_HEIGHT.
A continuación, inicialice un obxecto de visualización co ancho e alto definidos anteriormente co protocolo de comunicación I2C (&Wire).
O parámetro (-1) significa que a túa pantalla OLED non ten un PIN de RESET. Se a túa pantalla OLED ten un pin de RESET, debería estar conectada a un GPIO. Nese caso, debería pasar o número GPIO como parámetro.
No setup(), inicialice o monitor serie a unha velocidade en baudios de 115200 para fins de depuración.
Inicialice a pantalla OLED co método begin() do seguinte xeito:
Este fragmento tamén imprime unha mensaxe no monitor serie, por se non podemos conectarnos á pantalla.
No caso de que esteas a usar unha pantalla OLED diferente, quizais necesites cambiar o enderezo OLED. No noso caso, o enderezo é 0x3C.
Despois de inicializar a pantalla, engade un atraso de dous segundos, para que o OLED teña tempo suficiente para inicializarse antes de escribir texto:
Pantalla clara, establece o tamaño da fonte, a cor e escribe texto
Despois de inicializar a pantalla, borre o búfer de visualización co método clearDisplay():
Antes de escribir texto, cómpre definir o tamaño do texto, a cor e onde se mostrará o texto no OLED.
Establece o tamaño da fonte usando o método setTextSize():
Establece a cor da fonte co método setTextColor():
BRANCO establece o tipo de letra branco e o fondo negro.
Define a posición onde comeza o texto usando o método setCursor(x,y). Neste caso, configuramos o texto para que comece nas coordenadas (0,0), na esquina superior esquerda.
Finalmente, pode enviar o texto á pantalla usando o método println(), como segue
Entón, cómpre chamar ao método display() para mostrar realmente o texto na pantalla.
A biblioteca OLED de Adafruit ofrece métodos útiles para desprazar facilmente o texto.
- startscrollright(0x00, 0x0F): despraza o texto de esquerda a dereita
- startscrollleft(0x00, 0x0F): despraza o texto de dereita a esquerda
- startscrolldiagright(0x00, 0x07): despraza o texto dende a esquina inferior esquerda ata a esquina superior dereita startscrolldiagleft(0x00, 0x07): despraza o texto dende a esquina inferior dereita ata a esquina superior esquerda
Cargue o código
Agora, carga o código no teu ESP32. Pasos de referencia do código de carga.
Despois de cargar o código, o OLED mostrará un texto de desprazamento.
Documentos/Recursos
 |
Kit de inicio básico LAFVIN ESP32 [pdfManual de instrucións ESP32 Kit de inicio básico, ESP32, Kit de inicio básico, Kit de inicio |