Manual de instruções do kit básico de iniciação LAFVIN ESP32

Novo no ESP32? Comece aqui! O ESP32 é uma série de microcontroladores System on a Chip (SoC) de baixo custo e baixo consumo de energia desenvolvidos pela Espressif que incluem recursos sem fio Wi-Fi e Bluetooth e processador dual-core. Se você conhece o ESP8266, o ESP32 é seu sucessor, carregado com muitos recursos novos.Especificações do ESP32
Se você quiser obter informações um pouco mais técnicas e específicas, pode dar uma olhada nas seguintes especificações detalhadas do ESP32 (fonte: http://esp32.net/)—para mais detalhes, verifique a folha de dados):

Conectividade sem fio WiFi: taxa de dados de 150.0 Mbps com HT40
Bluetooth: BLE (Bluetooth Low Energy) e Bluetooth Clássico

Processador: Microprocessador Tensilica Xtensa Dual-Core LX32 de 6 bits, rodando a 160 ou 240 MHz
Memória:

ROM: 448 KB (para inicialização e funções principais)
SRAM: 520 KB (para dados e instruções)

RTC fas SRAM: 8 KB (para armazenamento de dados e CPU principal durante a inicialização do RTC a partir do modo de hibernação)
RTC SRAM lento: 8 KB (para acesso do coprocessador durante o modo de hibernação) eFuse: 1 Kbit (dos quais 256 bits são usados para o sistema (endereço MAC e configuração do chip) e os 768 bits restantes são reservados para aplicativos do cliente, incluindo Flash-Encryption e Chip-ID)

Flash incorporado: flash conectado internamente via IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0 e SD_DATA_1 no 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 SiP ESP32-PICO-D4)

Baixo consumo de energia: garante que você ainda pode usar conversões ADC, por exemploample, durante o sono profundo.
Entrada/Saída Periférica:

interface periférica com DMA que inclui toque capacitivo

ADCs (Conversor analógico-digital)
DACs (Conversor Digital para Analógico)

I²C (Circuito Inter-Integrado)
UART (Receptor/Transmissor Assíncrono Universal)

SPI (Interface Periférica Serial)
I²S (Som Interchip Integrado)

RMII (Interface Independente de Mídia Reduzida)
PWM (Modulação por Largura de Pulso)

Segurança: aceleradores de hardware para AES e SSL/TLS

Placas de desenvolvimento ESP32

ESP32 se refere ao chip ESP32 nu. No entanto, o termo “ESP32” também é usado para se referir às placas de desenvolvimento ESP32. Usar chips ESP32 nus não é fácil nem prático, especialmente ao aprender, testar e prototipar. Na maioria das vezes, você vai querer usar uma placa de desenvolvimento ESP32.
Usaremos a placa ESP32 DEVKIT V1 como referência. A imagem abaixo mostra a placa ESP32 DEVKIT V1, versão com 30 pinos GPIO.Especificações – ESP32 DEVKIT V1
A tabela a seguir mostra um resumo dos recursos e especificações da placa ESP32 DEVKIT V1 DOIT:

Número de núcleos	2 (núcleo duplo)
Wi-fi	2.4 GHz até 150 Mbits/s
Bluetooth	BLE (Bluetooth Low Energy) e Bluetooth legado
Arquitetura	32 bits
Frequência do relógio	Até 240 MHz
BATER	512 KB
Alfinetes	30 (dependendo do modelo)

Periféricos	Toque capacitivo, ADC (conversor analógico para digital), DAC (conversor digital para analógico), 12C (Circuito Interintegrado), UART (receptor/transmissor assíncrono universal), CAN 2.0 (Rede de Área do Controlador), SPI (Interface Periférica Serial), 12S (Interface Inter-IC Integrada). Som), RMII (Reduced Media-Independent Interface), PWM (modulação por largura de pulso) e muito mais.
Botões embutidos	Botões RESET e BOOT
LEDs embutidos	LED azul integrado conectado ao GPIO2; LED vermelho integrado que mostra que a placa está sendo alimentada
USB para UART ponte	CP2102

Ele vem com uma interface microUSB que você pode usar para conectar a placa ao seu computador para carregar código ou aplicar energia.
Ele usa o chip CP2102 (USB para UART) para se comunicar com seu computador por meio de uma porta COM usando uma interface serial. Outro chip popular é o CH340. Verifique qual é o conversor de chip USB para UART em sua placa porque você precisará instalar os drivers necessários para que seu computador possa se comunicar com a placa (mais informações sobre isso posteriormente neste guia).
Esta placa também vem com um botão RESET (pode ser rotulado EN) para reiniciar a placa e um botão BOOT para colocar a placa em modo piscante (disponível para receber código). Observe que algumas placas podem não ter um botão BOOT.
Ele também vem com um LED azul embutido que é conectado internamente ao GPIO 2. Este LED é útil para depuração para dar algum tipo de saída física visual. Há também um LED vermelho que acende quando você fornece energia para a placa.Pinagem ESP32
Os periféricos ESP32 incluem:

18 canais de conversor analógico-digital (ADC)

3 interfaces SPI
3 interfaces UART

2 interfaces I2C
16 canais de saída PWM
2 Conversores Digital-Analógico (DAC)
2 interfaces I2S
10 GPIOs de detecção capacitiva

Os recursos ADC (conversor analógico para digital) e DAC (conversor digital para analógico) são atribuídos a pinos estáticos específicos. No entanto, você pode decidir quais pinos são UART, I2C, SPI, PWM, etc. – você só precisa atribuí-los no código. Isso é possível devido ao recurso de multiplexação do chip ESP32.
Embora você possa definir as propriedades dos pinos no software, há pinos atribuídos por padrão, conforme mostrado na figura a seguirAlém disso, há pinos com características específicas que os tornam adequados ou não para um projeto em particular. A tabela a seguir mostra quais pinos são melhores para usar como entradas, saídas e quais você precisa ter cuidado.
Os pinos destacados em verde são OK para uso. Os destacados em amarelo são OK para uso, mas você precisa prestar atenção porque eles podem ter um comportamento inesperado principalmente na inicialização. Os pinos destacados em vermelho não são recomendados para uso como entradas ou saídas.

GP IO	Entrada	Saída	Notas
0	puxado para cima	OK	emite sinal PWM na inicialização, deve ser BAIXO para entrar no modo de piscar
1	pino TX	OK	saída de depuração na inicialização
2	OK	OK	conectado ao LED integrado, deve ser deixado flutuando ou BAIXO para entrar no modo intermitente
3	OK	pino RX	ALTO na inicialização
4	OK	OK
5	OK	OK	emite sinal PWM na inicialização, pino de amarração
12	OK	OK	a bota falha se puxada para cima, pino de amarração
13	OK	OK
14	OK	OK	emite sinal PWM na inicialização
15	OK	OK	emite sinal PWM na inicialização, pino de amarração

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		apenas entrada
35	OK		apenas entrada
36	OK		apenas entrada
39	OK		apenas entrada

Continue lendo para uma análise mais detalhada e aprofundada dos GPIOs ESP32 e suas funções.
Pinos somente de entrada
GPIOs 34 a 39 são GPIs – pinos somente de entrada. Esses pinos não têm resistores pull-up ou pull-down internos. Eles não podem ser usados como saídas, então use esses pinos somente como entradas:

GPIO34
GPIO35
GPIO36
GPIO39

Flash SPI integrado no ESP-WROOM-32
GPIO 6 a GPIO 11 são expostos em algumas placas de desenvolvimento ESP32. No entanto, esses pinos são conectados ao flash SPI integrado no chip ESP-WROOM-32 e não são recomendados para outros usos. Então, não use esses pinos em seus projetos:

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 de toque capacitivo
O ESP32 tem 10 sensores de toque capacitivos internos. Eles podem detectar variações em qualquer coisa que tenha carga elétrica, como a pele humana. Então eles podem detectar variações induzidas ao tocar os GPIOs com um dedo. Esses pinos podem ser facilmente integrados em pads capacitivos e substituir botões mecânicos. Os pinos de toque capacitivos também podem ser usados para despertar o ESP32 do sono profundo. Esses sensores de toque internos são conectados a esses GPIOs:

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ógico para Digital (ADC)
O ESP32 tem 18 canais de entrada ADC de 12 bits (enquanto o ESP8266 tem apenas 1 ADC de 10 bits). Estes são os GPIOs que podem ser usados como ADC e respectivos canais:

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)

Observação: Os pinos ADC2 não podem ser usados quando o Wi-Fi é usado. Então, se você estiver usando Wi-Fi e estiver tendo problemas para obter o valor de um ADC2 GPIO, você pode considerar usar um ADC1 GPIO. Isso deve resolver seu problema.
Os canais de entrada ADC têm uma resolução de 12 bits. Isso significa que você pode obter leituras analógicas variando de 0 a 4095, em que 0 corresponde a 0 V e 4095 a 3.3 V. Você também pode definir a resolução dos seus canais no código e no intervalo ADC.
Os pinos ADC do ESP32 não têm um comportamento linear. Você provavelmente não conseguirá distinguir entre 0 e 0.1 V, ou entre 3.2 e 3.3 V. Você precisa ter isso em mente ao usar os pinos ADC. Você obterá um comportamento semelhante ao mostrado na figura a seguir.Conversor digital para analógico (DAC)
Existem 2 canais DAC de 8 bits no ESP32 para converter sinais digitais em vol analógicotage saídas de sinal. Estes são os canais DAC:

DAC1 (GPIO25)

DAC2 (GPIO26)

GPIOs RTC
Há suporte a RTC GPIO no ESP32. Os GPIOs roteados para o subsistema de baixa potência RTC podem ser usados quando o ESP32 está em sono profundo. Esses RTC GPIOs podem ser usados para despertar o ESP32 do sono profundo quando o Ultra Low
O coprocessador Power (ULP) está em execução. Os seguintes GPIOs podem ser usados como uma fonte de ativação 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 tem 16 canais independentes que podem ser configurados para gerar sinais PWM com propriedades diferentes. Todos os pinos que podem atuar como saídas podem ser usados como pinos PWM (GPIOs 34 a 39 não podem gerar PWM).
Para definir um sinal PWM, você precisa definir estes parâmetros no código:

Frequência do sinal;
Ciclo de trabalho;

Canal PWM;
GPIO onde você deseja enviar o sinal.

I2C
O ESP32 tem dois canais I2C e qualquer pino pode ser definido como SDA ou SCL. Ao usar o ESP32 com o Arduino IDE, os pinos I2C padrão são:

GPIO21 (SDA)
GPIO22 (SCL)

Se você quiser usar outros pinos ao usar a biblioteca wire, basta chamar:
Fio.begin(SDA, SCL);
SPI
Por padrão, o mapeamento de pinos para SPI é:

SPI	MOSI	MISO	CLK	CS
VSPI	GPIO23	GPIO19	GPIO18	GPIO5
HSPI	GPIO13	GPIO12	GPIO14	GPIO15

Interrompe
Todos os GPIOs podem ser configurados como interrupções.
Alfinetes de Cintagem
O chip ESP32 possui os seguintes pinos de fixação:

GPIO 0 (deve estar BAIXO para entrar no modo de inicialização)
GPIO 2 (deve estar flutuante ou BAIXO durante a inicialização)

GPIO4
GPIO 5 (deve estar ALTO durante a inicialização)
GPIO 12 (deve estar BAIXO durante a inicialização)

GPIO 15 (deve estar ALTO durante a inicialização)

Eles são usados para colocar o ESP32 no bootloader ou no modo flashing. Na maioria das placas de desenvolvimento com USB/Serial integrado, você não precisa se preocupar com o estado desses pinos. A placa coloca os pinos no estado certo para o modo flashing ou boot. Mais informações sobre a Seleção do Modo Boot do ESP32 podem ser encontradas aqui.
No entanto, se você tiver periféricos conectados a esses pinos, poderá ter problemas ao tentar carregar um novo código, atualizar o ESP32 com um novo firmware ou redefinir a placa. Se você tiver alguns periféricos conectados aos pinos de cintagem e estiver tendo problemas para carregar o código ou atualizar o ESP32, pode ser porque esses periféricos estão impedindo o ESP32 de entrar no modo correto. Leia a documentação Boot Mode Selection para orientá-lo na direção certa. Após redefinir, atualizar ou inicializar, esses pinos funcionam conforme o esperado.
Pinos ALTOS na Bota
Alguns GPIOs alteram seu estado para ALTO ou emitem sinais PWM na inicialização ou reinicialização.
Isso significa que se você tiver saídas conectadas a esses GPIOs, poderá obter resultados inesperados quando o ESP32 for reinicializado ou inicializado.

GPIO1

GPIO3
GPIO5
GPIO 6 a GPIO 11 (conectado à memória flash SPI integrada ESP32 – não recomendado para uso).

GPIO14
GPIO15

Habilitar (PT)
Enable (EN) é o pino de habilitação do regulador de 3.3 V. Ele é puxado para cima, então conecte ao terra para desabilitar o regulador de 3.3 V. Isso significa que você pode usar este pino conectado a um botão de pressão para reiniciar seu ESP32, por exemploampeu.
Corrente GPIO consumida
A corrente máxima absoluta consumida por GPIO é de 40 mA, de acordo com a seção “Condições operacionais recomendadas” na folha de dados do ESP32.
Sensor de efeito Hall integrado ESP32
O ESP32 também possui um sensor de efeito Hall integrado que detecta mudanças no campo magnético em seu entorno
ESP32 Arduino IDE
Há um add-on para o Arduino IDE que permite programar o ESP32 usando o Arduino IDE e sua linguagem de programação. Neste tutorial, mostraremos como instalar a placa ESP32 no Arduino IDE, esteja você usando Windows, Mac OS X ou Linux.
Pré-requisitos: Arduino IDE instalado
Antes de iniciar este procedimento de instalação, você precisa ter o Arduino IDE instalado no seu computador. Há duas versões do Arduino IDE que você pode instalar: versão 1 e versão 2.
Você pode baixar e instalar o Arduino IDE clicando no seguinte link: arduino.cc/pt/Principal/Software
Qual versão do Arduino IDE recomendamos? No momento, existem algumas plugins para o ESP32 (como o SPIFFS Filesystem Uploader Plugin) que ainda não são suportados no Arduino 2. Então, se você pretende usar o plugin SPIFFS no futuro, recomendamos instalar a versão legada 1.8.X. Você só precisa rolar para baixo na página do software Arduino para encontrá-lo.
Instalando o complemento ESP32 no Arduino IDE
Para instalar a placa ESP32 no seu Arduino IDE, siga estas instruções:

No seu Arduino IDE, vá para File> Preferências
Insira o seguinte no “Gerenciador de Conselho Adicional URLs” campo:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Em seguida, clique no botão “OK”:Observação: se você já tem as placas ESP8266 URL, você pode separar o URLs com uma vírgula como segue:
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Abra o Boards Manager. Vá para Tools > Board > Boards Manager…Procurar ESP32 and press install button for the “ESP32 by Espressif Systems“:Pronto. Ele deve ser instalado após alguns segundos.

Carregar código de teste

Conecte a placa ESP32 ao seu computador. Com seu Arduino IDE aberto, siga estes passos:

Selecione sua placa no menu Ferramentas > Placa (no meu caso é o módulo ESP32 DEV）
Selecione a porta (se você não vir a porta COM no seu Arduino IDE, você precisa instalar os drivers CP210x USB to UART Bridge VCP):

Abra o seguinte example abaixo File > Examples > WiFi
(ESP32) > WiFiScan
Um novo esboço é aberto no seu Arduino IDE:
Pressione o botão Upload no Arduino IDE. Aguarde alguns segundos enquanto o código compila e carrega para sua placa.

Se tudo ocorreu conforme o esperado, você deverá ver a mensagem “Upload concluído”.
Abra o Arduino IDE Serial Monitor a uma taxa de transmissão de 115200:
Pressione o botão Habilitar ESP32 on-board e você deverá ver as redes disponíveis perto do seu ESP32:

Solução de problemas

Se você tentar carregar um novo esboço para seu ESP32 e receber esta mensagem de erro “Ocorreu um erro fatal: Falha ao conectar ao ESP32: Tempo esgotado… Conectando…“. Isso significa que seu ESP32 não está no modo de flashing/upload.
Tendo o nome da placa e a porta COM corretos selecionados, siga estes passos:
Mantenha pressionado o botão “BOOT” na sua placa ESP32

Pressione o botão “Upload” no Arduino IDE para carregar seu esboço:
Depois de ver a mensagem “Connecting….” no seu Arduino IDE, solte o dedo do botão “BOOT”:

Depois disso, você deverá ver a mensagem “Carregamento concluído”
Pronto. Seu ESP32 deve ter o novo sketch rodando. Pressione o botão “ENABLE” para reiniciar o ESP32 e rodar o novo sketch carregado.
Você também terá que repetir essa sequência de botões toda vez que quiser carregar um novo esboço.

Projeto 1 ESP32 Entradas Saídas

Neste guia de introdução, você aprenderá a ler entradas digitais, como um botão, e controlar saídas digitais, como um LED, usando o ESP32 com o Arduino IDE.
Pré-requisitos
Vamos programar o ESP32 usando o Arduino IDE. Então, certifique-se de ter o add-on de placas ESP32 instalado antes de prosseguir:

Instalando o complemento ESP32 no Arduino IDE

Saídas Digitais de Controle ESP32
Primeiro, você precisa definir o GPIO que deseja controlar como OUTPUT. Use a função pinMode() da seguinte forma:
pinMode(GPIO, SAÍDA);
Para controlar uma saída digital, você só precisa usar a função digitalWrite(), que aceita como argumentos o GPIO (número inteiro) ao qual você está se referindo e o estado, HIGH ou LOW.
digitalWrite(GPIO, ESTADO);
Todos os GPIOs podem ser usados como saídas, exceto os GPIOs 6 a 11 (conectados ao flash SPI integrado) e os GPIOs 34, 35, 36 e 39 (GPIOs somente de entrada);
Saiba mais sobre os GPIOs ESP32: Guia de referência do GPIO ESP32
ESP32 Ler Entradas Digitais
Primeiro, defina o GPIO que você deseja ler como INPUT, usando a função pinMode() da seguinte maneira:
pinMode(GPIO, ENTRADA);
Para ler uma entrada digital, como um botão, você usa a função digitalRead(), que aceita como argumento o GPIO (número inteiro) ao qual você está se referindo.
Leituradigital(GPIO);
Todos os GPIOs ESP32 podem ser usados como entradas, exceto os GPIOs 6 a 11 (conectados ao flash SPI integrado).
Saiba mais sobre os GPIOs ESP32: Guia de referência do GPIO ESP32
Projeto Example
Para mostrar como usar entradas e saídas digitais, construiremos um projeto simplesample com um botão de pressão e um LED. Leremos o estado do botão de pressão e acenderemos o LED de acordo, conforme ilustrado na figura a seguir.

Peças necessárias
Aqui está uma lista das peças que você precisa para construir o circuito:

ESP32 DEVKIT V1

LED de 5 mm
Resistor de 220 ohms
Botão de apertar

Resistor de 10k Ohms
Placa de ensaio
Fios de ligação

Diagrama esquemático
Antes de prosseguir, você precisa montar um circuito com um LED e um botão de pressão.
Conectaremos o LED ao GPIO 5 e o botão de pressão ao GPIO 4.Código
Abra o código Project_1_ESP32_Inputs_Outputs.ino no arduino IDEComo o código funciona
Nas duas linhas seguintes, você cria variáveis para atribuir pinos:

O botão é conectado ao GPIO 4 e o LED é conectado ao GPIO 5. Ao usar o Arduino IDE com o ESP32, 4 corresponde ao GPIO 4 e 5 corresponde ao GPIO 5.
Em seguida, você cria uma variável para manter o estado do botão. Por padrão, é 0 (não pressionado).
int estado do botão = 0;
No setup(), você inicializa o botão como uma ENTRADA e o LED como uma SAÍDA.
Para isso, você usa a função pinMode() que aceita o pino ao qual você está se referindo e o modo: INPUT ou OUTPUT.
pinMode(botãoPin, ENTRADA);
pinMode(ledPin, SAÍDA);
No loop() é onde você lê o estado do botão e define o LED adequadamente.
Na próxima linha, você lê o estado do botão e o salva na variável buttonState.
Como vimos anteriormente, você usa a função digitalRead().
buttonState = digitalRead(buttonPin);
A seguinte declaração if verifica se o estado do botão é HIGH. Se for, ele liga o LED usando a função digitalWrite() que aceita como argumento o ledPin e o estado HIGH.
se (buttonState == ALTO)Se o estado do botão não for HIGH, você desliga o LED. Basta definir LOW como um segundo argumento na função digitalWrite().Carregando o código
Antes de clicar no botão de upload, vá em Ferramentas > Placa e selecione a placa: placa DOIT ESP32 DEVKIT V1.
Vá para Tools > Port e selecione a porta COM à qual o ESP32 está conectado. Então, pressione o botão upload e aguarde a mensagem “Done uploading”.Nota: Se você vir muitos pontos (conectando…__…__) na janela de depuração e a mensagem “Falha ao conectar ao ESP32: Tempo limite esgotado ao aguardar o cabeçalho do pacote”, isso significa que você precisa pressionar o botão BOOT integrado do ESP32 após os pontos
começam a aparecer.Solução de problemas

Demonstração

Após carregar o código, teste seu circuito. Seu LED deve acender quando você pressionar o botão:E desligue quando soltar:

Projeto 2 ESP32 Entradas Analógicas

Este projeto mostra como ler entradas analógicas com o ESP32 usando o Arduino IDE.
A leitura analógica é útil para ler valores de resistores variáveis, como potenciômetros, ou sensores analógicos.
Entradas analógicas (ADC)
Ler um valor analógico com o ESP32 significa que você pode medir volumes variáveistage níveis entre 0 V e 3.3 V.
O voltage medido é então atribuído a um valor entre 0 e 4095, em que 0 V corresponde a 0 e 3.3 V corresponde a 4095. Qualquer voltage entre 0 V e 3.3 V receberá o valor correspondente entre eles.ADC é não linear
O ideal seria esperar um comportamento linear ao usar os pinos ADC do ESP32.
No entanto, isso não acontece. O que você obterá é um comportamento como o mostrado no gráfico a seguir:Esse comportamento significa que seu ESP32 não consegue distinguir 3.3 V de 3.2 V.
Você obterá o mesmo valor para ambos os volumestagé: 4095.
O mesmo acontece para volumes muito baixostage valores: para 0 V e 0.1 V você obterá o mesmo valor: 0. Você precisa ter isso em mente ao usar os pinos ADC do ESP32.
Função analogRead()
Ler uma entrada analógica com o ESP32 usando o Arduino IDE é tão simples quanto usar a função analogRead(). Ela aceita como argumento o GPIO que você quer ler:
analogRead(GPIO);
Apenas 15 estão disponíveis no DEVKIT V1board (versão com 30 GPIOs).
Pegue o pinout da sua placa ESP32 e localize os pinos ADC. Eles estão destacados com uma borda vermelha na figura abaixo.Esses pinos de entrada analógicos têm resolução de 12 bits. Isso significa que quando você lê uma entrada analógica, seu intervalo pode variar de 0 a 4095.
Nota: Os pinos ADC2 não podem ser usados quando o Wi-Fi é usado. Então, se você estiver usando Wi-Fi e estiver com problemas para obter o valor de um ADC2 GPIO, você pode considerar usar um ADC1 GPIO, isso deve resolver seu problema.
Para ver como tudo se encaixa, faremos um exemplo simplesample para ler um valor analógico de um potenciômetro.
Peças necessárias
Para este example, você precisa das seguintes peças:

Placa ESP32 DEVKIT V1
Potenciômetro

Placa de ensaio
Fios de ligação

esquemático
Conecte um potenciômetro ao seu ESP32. O pino do meio do potenciômetro deve ser conectado ao GPIO 4. Você pode usar o seguinte diagrama esquemático como referência.Código
Programaremos o ESP32 usando o Arduino IDE, então certifique-se de ter o complemento ESP32 instalado antes de prosseguir: (Se você já tiver feito esta etapa, pode pular para a próxima.)
Instalando o complemento ESP32 no Arduino IDE
Abra o código Project_2_ESP32_Inputs_Outputs.ino no arduino IDEEste código simplesmente lê os valores do potenciômetro e imprime esses valores no Monitor Serial.
No código, você começa definindo o GPIO ao qual o potenciômetro está conectado. Neste exemploample, GPIO 4.Em setup(), inicialize uma comunicação serial a uma taxa de transmissão de 115200.No loop(), use a função analogRead() para ler a entrada analógica do potPin.Por fim, imprima os valores lidos do potenciômetro no monitor serial.Carregue o código fornecido para seu ESP32. Certifique-se de ter a placa e a porta COM corretas selecionadas no menu Tools.
Testando o Example
Após carregar o código e pressionar o botão de reset do ESP32, abra o Serial Monitor a uma taxa de transmissão de 115200. Gire o potenciômetro e veja os valores mudando.O valor máximo que você obterá é 4095 e o valor mínimo é 0.

Encerrando

Neste artigo você aprendeu como ler entradas analógicas usando o ESP32 com o Arduino IDE. Em resumo:

A placa ESP32 DEVKIT V1 DOIT (versão com 30 pinos) tem 15 pinos ADC que você pode usar para ler entradas analógicas.
Esses pinos têm uma resolução de 12 bits, o que significa que você pode obter valores de 0 a 4095.
Para ler um valor no Arduino IDE, basta usar a função analogRead().
Os pinos ADC do ESP32 não têm um comportamento linear. Você provavelmente não conseguirá distinguir entre 0 e 0.1 V, ou entre 3.2 e 3.3 V. Você precisa ter isso em mente ao usar os pinos ADC.

Projeto 3 ESP32 PWM (Saída Analógica)

Neste tutorial mostraremos como gerar sinais PWM com o ESP32 usando o Arduino IDE. Como um exampVamos construir um circuito simples que escurece um LED usando o controlador PWM de LED do ESP32.Controlador PWM LED ESP32
O ESP32 possui um controlador PWM de LED com 16 canais independentes que podem ser configurados para gerar sinais PWM com diferentes propriedades.
Aqui estão os passos que você terá que seguir para diminuir a intensidade de um LED com PWM usando o Arduino IDE:

Primeiro, você precisa escolher um canal PWM. Há 16 canais de 0 a 15.
Então, você precisa definir a frequência do sinal PWM. Para um LED, uma frequência de 5000 Hz é boa para usar.
Você também precisa definir a resolução do ciclo de trabalho do sinal: você tem resoluções de 1 a 16 bits. Usaremos resolução de 8 bits, o que significa que você pode controlar o brilho do LED usando um valor de 0 a 255.
Em seguida, você precisa especificar em qual GPIO ou GPIOs o sinal aparecerá. Para isso, você usará a seguinte função:
ledcAttachPin(GPIO, canal)
Esta função aceita dois argumentos. O primeiro é o GPIO que vai emitir o sinal, e o segundo é o canal que vai gerar o sinal.
Por fim, para controlar o brilho do LED usando PWM, você usa a seguinte função:

ledcWrite(canal, ciclo de trabalho)
Esta função aceita como argumentos o canal que está gerando o sinal PWM e o ciclo de trabalho.
Peças necessárias
Para seguir este tutorial você precisa destas peças:

Placa ESP32 DEVKIT V1
LED 5mm
Resistor de 220 ohms
Placa de ensaio
Fios de ligação

esquemático
Conecte um LED ao seu ESP32 como no diagrama esquemático a seguir. O LED deve ser conectado ao GPIO 4.Observação: você pode usar qualquer pino que quiser, desde que ele possa atuar como uma saída. Todos os pinos que podem atuar como saídas podem ser usados como pinos PWM. Para mais informações sobre os GPIOs ESP32, leia: ESP32 Pinout Reference: Which GPIO pins you should use?
Código
Programaremos o ESP32 usando o Arduino IDE, então certifique-se de ter o complemento ESP32 instalado antes de prosseguir: (Se você já tiver feito esta etapa, pode pular para a próxima.)
Instalando o complemento ESP32 no Arduino IDE
Abra o código Project_3_ESP32_PWM.ino no arduino IDEVocê começa definindo o pino ao qual o LED está conectado. Neste caso, o LED está conectado ao GPIO 4.Então, você define as propriedades do sinal PWM. Você define uma frequência de 5000 Hz, escolhe o canal 0 para gerar o sinal e define uma resolução de 8 bits. Você pode escolher outras propriedades, diferentes destas, para gerar diferentes sinais PWM.No setup(), você precisa configurar o LED PWM com as propriedades definidas anteriormente usando a função ledcSetup() que aceita como argumentos o ledChannel, a frequência e a resolução, da seguinte maneira:Em seguida, você precisa escolher o GPIO de onde você obterá o sinal. Para isso, use a função ledcAttachPin() que aceita como argumentos o GPIO onde você deseja obter o sinal e o canal que está gerando o sinal. Neste exemploample, obteremos o sinal no ledPin GPIO, que corresponde ao GPIO 4. O canal que gera o sinal é o ledChannel, que corresponde ao canal 0.No loop, você variará o ciclo de trabalho entre 0 e 255 para aumentar o brilho do LED.E depois, entre 255 e 0 para diminuir o brilho.Para definir o brilho do LED, basta utilizar a função ledcWrite() que aceita como argumentos o canal que está gerando o sinal e o ciclo de trabalho.Como estamos usando resolução de 8 bits, o ciclo de trabalho será controlado usando um valor de 0 a 255. Observe que na função ledcWrite() usamos o canal que está gerando o sinal, e não o GPIO.

Testando o Example

Carregue o código para seu ESP32. Certifique-se de ter a placa e a porta COM corretas selecionadas. Olhe para seu circuito. Você deve ter um LED dimmer que aumenta e diminui o brilho.

Projeto 4 ESP32 Sensor de movimento PIR

Este projeto mostra como detectar movimento com o ESP32 usando um sensor de movimento PIR. A campainha soará um alarme quando o movimento for detectado e interromperá o alarme quando nenhum movimento for detectado por um tempo predefinido (como 4 segundos).
Como funciona o sensor de movimento HC-SR501
.O princípio de funcionamento do sensor HC-SR501 é baseado na mudança da radiação infravermelha no objeto em movimento. Para ser detectado pelo sensor HC-SR501, o objeto deve atender a dois requisitos:

O objeto está emitindo o caminho infravermelho.
O objeto está se movendo ou tremendo

Então:
Se um objeto estiver emitindo raios infravermelhos, mas NÃO estiver se movendo (por exemplo, uma pessoa parada sem se mover), ele NÃO será detectado pelo sensor.
Se um objeto estiver se movendo, mas NÃO estiver emitindo raios infravermelhos (por exemplo, robô ou veículo), ele NÃO será detectado pelo sensor.
Apresentando temporizadores
Neste example também apresentaremos temporizadores. Queremos que o LED permaneça ligado por um número predeterminado de segundos após o movimento ser detectado. Em vez de usar uma função delay() que bloqueia seu código e não permite que você faça mais nada por um número determinado de segundos, devemos usar um temporizador.A função delay()
Você deve estar familiarizado com a função delay(), pois ela é amplamente usada. Essa função é bem direta de usar. Ela aceita um único número int como argumento.
Este número representa o tempo em milissegundos que o programa tem que esperar até passar para a próxima linha de código.Quando você faz delay(1000), seu programa para naquela linha por 1 segundo.
delay() é uma função de bloqueio. Funções de bloqueio impedem que um programa faça qualquer outra coisa até que uma tarefa específica seja concluída. Se você precisa que várias tarefas ocorram ao mesmo tempo, não pode usar delay().
Para a maioria dos projetos, você deve evitar o uso de atrasos e, em vez disso, usar temporizadores.
A função millis()
Usando uma função chamada millis() você pode retornar o número de milissegundos que se passaram desde que o programa foi iniciado.Por que essa função é útil? Porque usando um pouco de matemática, você pode facilmente verificar quanto tempo passou sem bloquear seu código.
Peças necessárias
Para seguir este tutorial você precisa das seguintes peças

Placa ESP32 DEVKIT V1
Sensor de movimento PIR (HC-SR501)
Buzzer ativo
Fios de ligação
Placa de ensaio

esquemáticoObservação: O volume de trabalhotagA tensão do HC-SR501 é 5 V. Use o pino Vin para alimentá-lo.
Código
Antes de prosseguir com este tutorial, você deve ter o complemento ESP32 instalado no seu Arduino IDE. Siga um dos seguintes tutoriais para instalar o ESP32 no Arduino IDE, se você ainda não o fez. (Se você já fez esta etapa, pode pular para a próxima.)
Instalando o complemento ESP32 no Arduino IDE
Abra o código Project_4_ESP32_PIR_Motion_Sensor.ino no Arduino IDE.
Demonstração
Carregue o código para sua placa ESP32. Certifique-se de ter a placa e a porta COM corretas selecionadas. Etapas de referência do código de upload.
Abra o Serial Monitor a uma taxa de transmissão de 115200.Mova sua mão na frente do sensor PIR. O buzzer deve ligar, e a mensagem é impressa no Serial Monitor dizendo “Movimento detectado!Alarme de buzzer”.
Após 4 segundos, a campainha deve desligar.

Projeto 5 ESP32 Switch Web Servidor

Neste projeto você criará um autônomo web servidor com um ESP32 que controla saídas (dois LEDs) usando o ambiente de programação Arduino IDE. O web O servidor é responsivo a dispositivos móveis e pode ser acessado com qualquer dispositivo que tenha um navegador na rede local. Mostraremos como criar o web servidor e como o código funciona passo a passo.
Projeto encerradoview
Antes de partir direto para o projeto, é importante delinear o que é o nosso web o servidor fará isso, para que seja mais fácil seguir os passos mais tarde.

O web o servidor que você construirá controla dois LEDs conectados ao ESP32 GPIO 26 e GPIO 27;
Você pode acessar o ESP32 web servidor digitando o endereço IP do ESP32 em um navegador na rede local;
Ao clicar nos botões do seu web servidor você pode alterar instantaneamente o estado de cada LED.

Peças necessárias
Para este tutorial você precisará das seguintes peças:

Placa ESP32 DEVKIT V1
2x LEDs de 5 mm
2x resistor de 200 ohms
Placa de ensaio
Fios de ligação

esquemático
Comece construindo o circuito. Conecte dois LEDs ao ESP32 conforme mostrado no diagrama esquemático a seguir – um LED conectado ao GPIO 26 e o outro ao GPIO 27.
Observação: Estamos usando a placa ESP32 DEVKIT DOIT com 36 pinos. Antes de montar o circuito, certifique-se de verificar a pinagem da placa que você está usando.Código
Aqui fornecemos o código que cria o ESP32 web servidor. Abra o código Project_5_ESP32_Switch _Web_Server.ino no arduino IDE, mas não carregue ainda. Você precisa fazer algumas mudanças para que funcione para você.
Programaremos o ESP32 usando o Arduino IDE, então certifique-se de ter o complemento ESP32 instalado antes de prosseguir: (Se você já tiver feito esta etapa, pode pular para a próxima.)
Instalando o complemento ESP32 no Arduino IDE
Configurando suas credenciais de rede
Você precisa modificar as seguintes linhas com suas credenciais de rede: SSID e senha. O código está bem comentado sobre onde você deve fazer as alterações.Carregando o código
Agora, você pode fazer o upload do código e do web o servidor funcionará imediatamente.
Siga os próximos passos para enviar o código para o ESP32:

Conecte sua placa ESP32 no seu computador;
No Arduino IDE, selecione sua placa em Ferramentas > Placa (no nosso caso, estamos usando a placa ESP32 DEVKIT DOIT);
Selecione a porta COM em Ferramentas > Porta.
Pressione o botão Upload no Arduino IDE e aguarde alguns segundos enquanto o código é compilado e carregado na sua placa.
Aguarde a mensagem “Envio concluído”.

Encontrando o endereço IP do ESP
Após enviar o código, abra o Serial Monitor a uma taxa de transmissão de 115200.Pressione o botão ESP32 EN (reset). O ESP32 se conecta ao Wi-Fi e emite o endereço IP do ESP no Serial Monitor. Copie esse endereço IP, porque você precisa dele para acessar o ESP32 web servidor.Acessando o Web Servidor
Para acessar o web servidor, abra seu navegador, cole o endereço IP do ESP32 e você verá a seguinte página.
Observação: Seu navegador e o ESP32 devem estar conectados à mesma LAN.Se você der uma olhada no Serial Monitor, você pode ver o que está acontecendo no fundo. O ESP recebe uma solicitação HTTP de um novo cliente (neste caso, seu navegador).Você também pode ver outras informações sobre a solicitação HTTP.
Demonstração
Agora você pode testar se o seu web o servidor está funcionando corretamente. Clique nos botões para controlar os LEDs.Ao mesmo tempo, você pode dar uma olhada no Serial Monitor para ver o que está acontecendo em segundo plano. Por ex.ampou seja, quando você clica no botão para ligar o GPIO 26, o ESP32 recebe uma solicitação no /26/on URL.Quando o ESP32 recebe essa solicitação, ele liga o LED conectado ao GPIO 26 e atualiza seu estado no web página.O botão para GPIO 27 funciona de forma similar. Teste se está funcionando corretamente.

Como o código funciona

Nesta seção, examinaremos mais de perto o código para ver como ele funciona.
A primeira coisa que você precisa fazer é incluir a biblioteca WiFi.Como mencionado anteriormente, você precisa inserir seu SSID e senha nas linhas a seguir, dentro das aspas duplas.Então, você define seu web servidor para a porta 80.A linha a seguir cria uma variável para armazenar o cabeçalho da solicitação HTTP:Em seguida, você cria variáveis auxiliares para armazenar o estado atual de suas saídas. Se quiser adicionar mais saídas e salvar seu estado, você precisa criar mais variáveis.Você também precisa atribuir um GPIO a cada uma de suas saídas. Aqui estamos usando GPIO 26 e GPIO 27. Você pode usar qualquer outro GPIO adequado.configurar()
Agora, vamos para o setup(). Primeiro, iniciamos uma comunicação serial a uma taxa de transmissão de 115200 para fins de depuração.Você também define seus GPIOs como SAÍDAS e os configura como BAIXOS.As linhas a seguir iniciam a conexão Wi-Fi com WiFi.begin(ssid, password), aguardam uma conexão bem-sucedida e imprimem o endereço IP do ESP no Serial Monitor.laço()
No loop() programamos o que acontece quando um novo cliente estabelece uma conexão com o web servidor.
O ESP32 está sempre escutando clientes de entrada com a seguinte linha:Quando uma solicitação é recebida de um cliente, salvaremos os dados de entrada. O loop while que se segue estará em execução enquanto o cliente permanecer conectado. Não recomendamos alterar a parte a seguir do código, a menos que você saiba exatamente o que está fazendo.A próxima seção de instruções if e else verifica qual botão foi pressionado em seu web página e controla as saídas de acordo. Como vimos anteriormente, fazemos uma solicitação em diferentes URLs dependendo do botão pressionado.Por exemploampou seja, se você pressionar o botão GPIO 26 ON, o ESP32 recebe uma solicitação no /26/ON URL (podemos ver essa informação no cabeçalho HTTP no Serial Monitor). Então, podemos verificar se o cabeçalho contém a expressão GET /26/on. Se contiver, mudamos a variável output26state para ON, e o ESP32 acende o LED.
Isso funciona de forma similar para os outros botões. Então, se você quiser adicionar mais saídas, você deve modificar esta parte do código para incluí-las.
Exibindo o HTML web página
A próxima coisa que você precisa fazer é criar o web página. O ESP32 enviará uma resposta ao seu navegador com algum código HTML para construir a web página.
O web a página é enviada ao cliente usando esta expressão client.println(). Você deve digitar o que deseja enviar ao cliente como um argumento.
A primeira coisa que devemos enviar é sempre a seguinte linha, que indica que estamos enviando HTML.Então, a linha a seguir faz o web página responsiva em qualquer web navegador.E o seguinte é usado para evitar solicitações no favicon. – Você não precisa se preocupar com esta linha.

Estilizando o Web Página

Em seguida, temos algum texto CSS para estilizar os botões e o web aparência da página.
Escolhemos a fonte Helvetica, definimos o conteúdo a ser exibido como um bloco e alinhamos ao centro.Estilizamos nossos botões com a cor #4CAF50, sem borda, texto na cor branca e com este padding: 16px 40px. Também definimos o text-decoration como none, definimos o tamanho da fonte, a margem e o cursor como um ponteiro.Também definimos o estilo para um segundo botão, com todas as propriedades do botão que definimos anteriormente, mas com uma cor diferente. Este será o estilo para o botão off.

Definindo o Web Cabeçalho da primeira página
Na próxima linha você pode definir o primeiro título do seu web página. Aqui temos “ESP32 Web Servidor”, mas você pode alterar esse texto para o que quiser.Exibindo os botões e o estado correspondente
Então, você escreve um parágrafo para exibir o estado atual do GPIO 26. Como você pode ver, usamos a variável output26State, para que o estado seja atualizado instantaneamente quando essa variável mudar.Então, exibimos o botão on ou off, dependendo do estado atual do GPIO. Se o estado atual do GPIO for off, mostramos o botão ON, se não, exibimos o botão OFF.Usamos o mesmo procedimento para GPIO 27.
Fechando a conexão
Por fim, quando a resposta termina, limpamos a variável de cabeçalho e interrompemos a conexão com o cliente com client.stop().

Encerrando

Neste tutorial mostramos como construir um web servidor com o ESP32. Mostramos a você um exemplo simplesample que controla dois LEDs, mas a ideia é substituir esses LEDs por um relé ou qualquer outra saída que você queira controlar.

Projeto 6 LED RGB Web Servidor

Neste projeto mostraremos como controlar remotamente um LED RGB com uma placa ESP32 usando um web servidor com um seletor de cores.
Projeto encerradoview
Antes de começar, vamos ver como esse projeto funciona:

O ESP32 web o servidor exibe um seletor de cores.
Quando você escolhe uma cor, seu navegador faz uma solicitação em um URL que contém os parâmetros R, G e B da cor selecionada.
Seu ESP32 recebe a solicitação e divide o valor para cada parâmetro de cor.
Em seguida, ele envia um sinal PWM com o valor correspondente para os GPIOs que estão controlando o LED RGB.

Como funcionam os LEDs RGB?
Em um LED RGB de cátodo comum, todos os três LEDs compartilham uma conexão negativa (cátodo). Todos os incluídos no kit são RGB de cátodo comum.Como criar cores diferentes?
Com um LED RGB você pode, é claro, produzir luz vermelha, verde e azul e, configurando a intensidade de cada LED, você pode produzir outras cores também.
Por exemploample, para produzir luz puramente azul, você ajustaria o LED azul para a intensidade mais alta e os LEDs verde e vermelho para a intensidade mais baixa. Para uma luz branca, você ajustaria todos os três LEDs para a intensidade mais alta.
Misturando cores
Para produzir outras cores, você pode combinar as três cores em intensidades diferentes. Para ajustar a intensidade de cada LED, você pode usar um sinal PWM.
Como os LEDs estão muito próximos uns dos outros, nossos olhos veem o resultado da combinação de cores, em vez das três cores individualmente.
Para ter uma ideia de como combinar as cores, dê uma olhada no gráfico a seguir.
Esta é a tabela de mistura de cores mais simples, mas dá uma ideia de como funciona e como produzir cores diferentes.Peças necessárias
Para este projeto você precisa das seguintes peças:

Placa ESP32 DEVKIT V1
LED RGB
3 resistores de 220 ohms
Fios de ligação
Placa de ensaio

esquemáticoCódigo
Programaremos o ESP32 usando o Arduino IDE, então certifique-se de ter o complemento ESP32 instalado antes de prosseguir: (Se você já tiver feito esta etapa, pode pular para a próxima.)

Instalando o complemento ESP32 no Arduino IDE

Após montar o circuito, abra o código
Projeto_6_RGB_LED_Web_Server.ino no IDE do Arduino.
Antes de enviar o código, não se esqueça de inserir suas credenciais de rede para que o ESP possa se conectar à sua rede local.Como o código funciona
O esboço do ESP32 usa a biblioteca WiFi.h.As linhas a seguir definem variáveis de string para conter os parâmetros R, G e B da solicitação.As próximas quatro variáveis são usadas para decodificar a solicitação HTTP posteriormente.Crie três variáveis para os GPIOs que controlarão os parâmetros R, G e B da tira. Neste caso, estamos usando GPIO 13, GPIO 12 e GPIO 14.Esses GPIOs precisam emitir sinais PWM, então precisamos configurar as propriedades PWM primeiro. Defina a frequência do sinal PWM para 5000 Hz. Em seguida, associe um canal PWM para cada corE finalmente, defina a resolução dos canais PWM para 8 bitsNa configuração(), atribua as propriedades PWM aos canais PWMAnexar os canais PWM aos GPIOs correspondentesA seção de código a seguir exibe o seletor de cores em seu web página e faz uma solicitação com base na cor que você escolheu.Ao escolher uma cor, você recebe uma solicitação com o seguinte formato.

Então, precisamos dividir essa string para obter os parâmetros R, G e B. Os parâmetros são salvos nas variáveis redString, greenString e blueString e podem ter valores entre 0 e 255.Para controlar a tira com o ESP32, use a função ledcWrite() para gerar sinais PWM com os valores decodificados do HTTP solicitar.Observação: saiba mais sobre PWM com ESP32: Projeto 3 ESP32 PWM(Saída Analógica)
Para controlar a tira com o ESP8266, basta utilizar
a função analogWrite() para gerar sinais PWM com os valores decodificados da solicitação HTPP.
analogWrite(redPin, redString.toInt());
analogWrite(pinoverde, stringverde.toInt());
analogWrite(pinoazul, azulString.toInt())
Como obtemos os valores em uma variável de string, precisamos convertê-los em inteiros usando o método toInt().
Demonstração
Depois de inserir suas credenciais de rede, selecione a placa e a porta COM corretas e carregue o código no seu ESP32. Etapas de referência para upload de código.
Após o upload, abra o Serial Monitor a uma taxa de transmissão de 115200 e pressione o botão ESP Enable/Reset. Você deve obter o endereço IP da placa.Abra seu navegador e insira o endereço IP do ESP. Agora, use o seletor de cores para escolher uma cor para o LED RGB.
Em seguida, você precisa pressionar o botão “Alterar cor” para que a cor tenha efeito.Para desligar o LED RGB, selecione a cor preta.
As cores mais fortes (no topo do seletor de cores) são as que produzirão melhores resultados.

Projeto 7 ESP32 Relé Web Servidor

Usar um relé com o ESP32 é uma ótima maneira de controlar aparelhos domésticos de CA remotamente. Este tutorial explica como controlar um módulo de relé com o ESP32.
Veremos como funciona um módulo de relé, como conectar o relé ao ESP32 e construir um web servidor para controlar um relé remotamente.
Apresentando Relés
Um relé é um interruptor operado eletricamente e, como qualquer outro interruptor, pode ser ligado ou desligado, deixando a corrente passar ou não. Pode ser controlado com baixa voltages, como os 3.3 V fornecidos pelos GPIOs ESP32 e nos permite controlar altos volumestagé como 12 V, 24 V ou tensão da rede elétricatage (230 V na Europa e 120 V nos EUA).No lado esquerdo, há dois conjuntos de três soquetes para conectar alto volumetages, e os pinos do lado direito (baixo volumetage) conectar aos GPIOs do ESP32.
Volume da redetage conexõesO módulo de relé mostrado na foto anterior possui dois conectores, cada um com três soquetes: comum (COM), normalmente fechado (NC) e normalmente aberto (NO).

COM: conecte a corrente que deseja controlar (voltagem da rede elétricatage)
NC (Normalmente Fechado): a configuração normalmente fechada é usada quando você quer que o relé seja fechado por padrão. Os pinos NC e COM estão conectados, o que significa que a corrente está fluindo a menos que você envie um sinal do ESP32 para o módulo de relé para abrir o circuito e parar o fluxo de corrente.
NO (Normalmente aberto): a configuração normalmente aberta funciona ao contrário: não há conexão entre os pinos NO e COM, então o circuito é interrompido, a menos que você envie um sinal do ESP32 para fechar o circuito.

Pinos de controleO baixo volumetagO lado tem um conjunto de quatro pinos e um conjunto de três pinos. O primeiro conjunto consiste em VCC e GND para energizar o módulo, e entrada 1 (IN1) e entrada 2 (IN2) para controlar os relés inferior e superior, respectivamente.
Se seu módulo de relé tiver apenas um canal, você terá apenas um pino IN. Se você tiver quatro canais, terá quatro pinos IN, e assim por diante.
O sinal que você envia para os pinos IN determina se o relé está ativo ou não. O relé é acionado quando a entrada fica abaixo de cerca de 2 V. Isso significa que você terá os seguintes cenários:

Configuração normalmente fechada (NC):
Sinal ALTO – corrente está fluindo
Sinal BAIXO – a corrente não está fluindo
Configuração normalmente aberta (NO):
Sinal ALTO – a corrente não está fluindo
Sinal BAIXO – corrente fluindo

Você deve usar uma configuração normalmente fechada quando a corrente deve fluir na maior parte do tempo e você só deseja interrompê-la ocasionalmente.
Use uma configuração normalmente aberta quando quiser que a corrente flua ocasionalmente (por exemploample, ligue tudoamp ocasionalmente).
Seleção de fonte de alimentaçãoO segundo conjunto de pinos consiste em pinos GND, VCC e JD-VCC.
O pino JD-VCC energiza o eletroímã do relé. Observe que o módulo tem um jumper cap conectando os pinos VCC e JD-VCC; o mostrado aqui é amarelo, mas o seu pode ser de uma cor diferente.
Com a tampa do jumper ligada, os pinos VCC e JD-VCC são conectados. Isso significa que o eletroímã do relé é alimentado diretamente pelo pino de energia do ESP32, então o módulo do relé e os circuitos do ESP32 não são fisicamente isolados um do outro.
Sem a tampa do jumper, você precisa fornecer uma fonte de energia independente para alimentar o eletroímã do relé através do pino JD-VCC. Essa configuração isola fisicamente os relés do ESP32 com o optoacoplador integrado do módulo, o que evita danos ao ESP32 em caso de picos elétricos.
esquemáticoAviso: Uso de alto volumetagFontes de alimentação elétricas podem causar ferimentos graves.
Portanto, LEDs de 5 mm são usados em vez de alto volume de alimentaçãotage lâmpadas no experimento. Se você não estiver familiarizado com o volume da rede elétricatage peça a alguém que esteja para ajudá-lo. Ao programar o ESP ou conectar seu circuito, certifique-se de que tudo esteja desconectado da rede elétrica.tage.Instalando a biblioteca para ESP32
Para construir isso web servidor, usamos o ESPAsyncWebBiblioteca do servidor e biblioteca AsyncTCP.
Instalando o ESPAsyncWebBiblioteca de servidores
Siga os próximos passos para instalar o ESPAsyncWebServidor biblioteca:

Clique aqui para baixar o ESPAsyncWebBiblioteca do servidor. Você deve ter
uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá obter o ESPAsyncWebPasta mestre do servidor
Renomeie sua pasta de ESPAsyncWebServidor-mestre para ESPAsyncWebServidor
Mova o ESPAsyncWebPasta do servidor para a pasta de bibliotecas de instalação do Arduino IDE

Alternativamente, no seu Arduino IDE, você pode ir para Sketch > Incluir
Biblioteca > Adicionar biblioteca .ZIP… e selecione a biblioteca que você acabou de baixar.
Instalando a biblioteca AsyncTCP para ESP32
O ESPAsyncWebServidor a biblioteca requer o AsyncTCP biblioteca para trabalhar. Siga
os próximos passos para instalar essa biblioteca:

Clique aqui para baixar a biblioteca AsyncTCP. Você deve ter uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá obter a pasta AsyncTCP-master
1. Renomeie sua pasta de AsyncTCP-master para AsyncTCP
3. Mova a pasta AsyncTCP para a pasta de bibliotecas de instalação do Arduino IDE
4. Por fim, abra novamente o seu Arduino IDE

Alternativamente, no seu Arduino IDE, você pode ir para Sketch > Incluir
Biblioteca > Adicionar biblioteca .ZIP… e selecione a biblioteca que você acabou de baixar.
Código
Programaremos o ESP32 usando o Arduino IDE, então certifique-se de ter o complemento ESP32 instalado antes de prosseguir: (Se você já tiver feito esta etapa, pode pular para a próxima.)
Instalando o complemento ESP32 no Arduino IDE
Após instalar as bibliotecas necessárias, abra o código Project_7_ESP32_Relay_Web_Server.ino no IDE do Arduino.
Antes de enviar o código, não se esqueça de inserir suas credenciais de rede para que o ESP possa se conectar à sua rede local.Demonstração
Depois de fazer as alterações necessárias, carregue o código no seu ESP32. Etapas de referência de upload de código.
Abra o Serial Monitor a uma taxa de transmissão de 115200 e pressione o botão ESP32 EN para obter seu endereço IP. Em seguida, abra um navegador em sua rede local e digite o endereço IP do ESP32 para obter acesso ao web servidor.
Abra o Serial Monitor a uma taxa de transmissão de 115200 e pressione o botão ESP32 EN para obter seu endereço IP. Em seguida, abra um navegador em sua rede local e digite o endereço IP do ESP32 para obter acesso ao web servidor.Observação: Seu navegador e o ESP32 devem estar conectados à mesma LAN.
Você deve obter algo como o seguinte, com dois botões iguais ao número de relés que você definiu no seu código.Agora você pode usar os botões para controlar seus relés usando seu smartphone.

Projeto_8_Sincronização_do_Estado_de_Saída_ Web_Servidor

Este projeto mostra como controlar as saídas do ESP32 ou ESP8266 usando um web servidor e um botão físico simultaneamente. O estado de saída é atualizado no web página, seja ela alterada por meio de botão físico ou web servidor.
Projeto encerradoview
Vamos dar uma olhada rápida em como o projeto funciona.O ESP32 ou ESP8266 hospeda um web servidor que permite controlar o estado de uma saída;

O estado de saída atual é exibido no web servidor;
O ESP também é conectado a um botão físico que controla a mesma saída;
Se você alterar o estado de saída usando o botão físico, seu estado atual também será atualizado no web servidor.

Em resumo, este projeto permite que você controle a mesma saída usando um web servidor e um botão de pressão simultaneamente. Sempre que o estado de saída muda, o web o servidor é atualizado.
Peças necessárias
Aqui está uma lista das peças que você precisa para construir o circuito:

Placa ESP32 DEVKIT V1
LED de 5 mm
Resistor de 220 Ohm
Botão de apertar
Resistor de 10k Ohms
Placa de ensaio
Fios de ligação

esquemáticoInstalando a biblioteca para ESP32
Para construir isso web servidor, usamos o ESPAsyncWebBiblioteca do servidor e biblioteca AsyncTCP. (Se você já tiver feito esta etapa, pode pular para a próxima.)
Instalando o ESPAsyncWebBiblioteca de servidores
Siga os próximos passos para instalar o ESPAsyncWebBiblioteca do servidor:

Clique aqui para baixar o ESPAsyncWebBiblioteca do servidor. Você deve ter
uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá obter o ESPAsyncWebPasta mestre do servidor
Renomeie sua pasta de ESPAsyncWebServidor-mestre para ESPAsyncWebServidor
Mova o ESPAsyncWebPasta do servidor para a pasta de bibliotecas de instalação do Arduino IDE
Alternativamente, no seu Arduino IDE, você pode ir para Sketch > Incluir
Biblioteca > Adicionar biblioteca .ZIP… e selecione a biblioteca que você acabou de baixar.

Instalando a biblioteca AsyncTCP para ESP32
O ESPAsyncWebA biblioteca do servidor requer a biblioteca AsyncTCP para funcionar. Siga os próximos passos para instalar essa biblioteca:

Clique aqui para baixar a biblioteca AsyncTCP. Você deve ter uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá obter a pasta AsyncTCP-master
Renomeie sua pasta de AsyncTCP-master para AsyncTCP
Mova a pasta AsyncTCP para a pasta de bibliotecas de instalação do Arduino IDE
Por fim, abra novamente o seu Arduino IDE
Alternativamente, no seu Arduino IDE, você pode ir para Sketch > Incluir
Biblioteca > Adicionar biblioteca .ZIP… e selecione a biblioteca que você acabou de baixar.

Como o código funciona

Estado do botão e estado de saída
A variável ledState contém o estado de saída do LED. Por padrão, quando o web servidor inicia, está BAIXO.

O buttonState e o lastButtonState são usados para detectar se o botão foi pressionado ou não.Botão (web servidor)
Não incluímos o HTML para criar o botão na variável index_html.
Isso porque queremos poder alterá-lo dependendo do estado atual do LED, que também pode ser alterado com o botão de pressão.
Então, criamos um espaço reservado para o botão %BUTTONPLACEHOLDER% que será substituído pelo texto HTML para criar o botão posteriormente no código (isso é feito na função processor()).processador()
A função processor() substitui quaisquer espaços reservados no texto HTML por valores reais. Primeiro, ela verifica se os textos HTML contêm algum
marcadores de posição %BUTTONPLACEHOLDER%.Então, chame a função outputState() que retorna o estado de saída atual. Nós o salvamos na variável outputStateValue.Depois disso, use esse valor para criar o texto HTML para exibir o botão com o estado correto:Solicitação HTTP GET para alterar o estado de saída (JavaScript)
Quando você pressiona o botão, a função toggleCheckbox() é chamada. Esta função fará uma solicitação em diferentes URLs para ligar ou desligar o LED.Para ligar o LED, ele faz uma solicitação em /update?state=1 URL:Caso contrário, ele faz uma solicitação em /update?state=0 URL.
Solicitação HTTP GET para atualizar o estado (JavaScript)
Para manter o estado de saída atualizado no web servidor, chamamos a seguinte função que faz uma nova solicitação no /state URL a cada segundo.Lidar com solicitações
Então, precisamos lidar com o que acontece quando o ESP32 ou ESP8266 recebe solicitações nesses URLs.
Quando uma solicitação é recebida na raiz /URL, enviamos a página HTML e também o processador.As linhas a seguir verificam se você recebeu uma solicitação em /update?state=1 ou /update?state=0 URL e altera o ledState adequadamente.Quando uma solicitação é recebida no /state URL, enviamos o estado de saída atual:laço()
No loop(), desfazemos o efeito de rejeição do botão de pressão e ligamos ou desligamos o LED dependendo do valor do ledState variável.Demonstração
Carregue o código na sua placa ESP32. Faça o upload das etapas de referência do código.
Em seguida, abra o Serial Monitor a uma taxa de transmissão de 115200. Pressione o botão EN/RST integrado para obter o endereço IP.Abra um navegador na sua rede local e digite o endereço IP do ESP. Você deve ter acesso ao web servidor conforme mostrado abaixo.
Observação: Seu navegador e o ESP32 devem estar conectados à mesma LAN.Você pode alternar o botão no web servidor para acender o LED.Você também pode controlar o mesmo LED com o botão físico. Seu estado sempre será atualizado automaticamente no web servidor.

Projeto 9 ESP32 DHT11 Web Servidor

Neste projeto, você aprenderá a construir um ESP32 assíncrono web servidor com o DHT11 que exibe temperatura e umidade usando o Arduino IDE.
Pré-requisitos
O web o servidor que iremos construir atualiza as leituras automaticamente sem a necessidade de atualizar o web página.
Com este projeto você aprenderá:

Como ler temperatura e umidade de sensores DHT;
Crie um assíncrono web servidor usando o ESPAsyncWebBiblioteca de servidores;
Atualizar as leituras do sensor automaticamente sem a necessidade de atualizar o web página.

Assíncrono Web Servidor
Para construir o web servidor usaremos o ESPAsyncWebBiblioteca de servidores que fornece uma maneira fácil de construir um assíncrono web servidor. Construindo um assíncrono web servidor tem várias vantagenstagcomo mencionado na página da biblioteca no GitHub, como:

“Lidar com mais de uma conexão ao mesmo tempo”;
“Quando você envia a resposta, você está imediatamente pronto para lidar com outras conexões enquanto o servidor cuida do envio da resposta em segundo plano”;
“Mecanismo de processamento de modelos simples para manipular modelos”;

Peças necessárias
Para concluir este tutorial, você precisa das seguintes peças:

Placa de desenvolvimento ESP32
Módulo DHT11
Placa de ensaio
Fios de ligação

esquemáticoInstalando Bibliotecas
Você precisa instalar algumas bibliotecas para este projeto:

O DHT e o Sensor unificado Adafruit Bibliotecas de driver para leitura do sensor DHT.
ESPAsyncWebServidor e TCP assíncrono bibliotecas para construir o assíncrono web servidor.
Siga as próximas instruções para instalar essas bibliotecas:

Instalando a biblioteca do sensor DHT
Para ler o sensor DHT usando o Arduino IDE, você precisa instalar o Biblioteca de sensores DHT. Siga os próximos passos para instalar a biblioteca.

Clique aqui para baixar a biblioteca do sensor DHT. Você deve ter uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá obter a pasta DHT-sensor-library-master
Renomeie sua pasta de DHT-sensor-library-master para DHT_sensor
Mova a pasta DHT_sensor para a pasta de bibliotecas de instalação do Arduino IDE
Por fim, abra novamente o seu Arduino IDE

Instalando o driver do sensor unificado Adafruit
Você também precisa instalar o Biblioteca de drivers de sensor unificado Adafruit para trabalhar com o sensor DHT. Siga os próximos passos para instalar a biblioteca.

Clique aqui para baixar a biblioteca Adafruit Unified Sensor. Você deve ter uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá obter a pasta Adafruit_sensor-master
Renomeie sua pasta de Adafruit_sensor-master para Adafruit_sensor
Mova a pasta Adafruit_sensor para a pasta de bibliotecas de instalação do Arduino IDE
Por fim, abra novamente o seu Arduino IDE

Instalando o ESPAsyncWebBiblioteca de servidores

Siga os próximos passos para instalar o ESPAsyncWebServidor biblioteca:

Clique aqui para baixar o ESPAsyncWebBiblioteca do servidor. Você deve ter
uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá
obter ESPAsyncWebPasta mestre do servidor
Renomeie sua pasta de ESPAsyncWebServidor-mestre para ESPAsyncWebServidor
Mova o ESPAsyncWebPasta do servidor para a pasta de bibliotecas de instalação do Arduino IDE

Instalando a biblioteca Async TCP para ESP32
O ESPAsyncWebServidor a biblioteca requer o AsyncTCP biblioteca para funcionar. Siga os próximos passos para instalar essa biblioteca:

Clique aqui para baixar a biblioteca AsyncTCP. Você deve ter uma pasta .zip na sua pasta Downloads
Descompacte a pasta .zip e você deverá obter a pasta AsyncTCP-master
Renomeie sua pasta de AsyncTCP-master para AsyncTCP
Mova a pasta AsyncTCP para a pasta de bibliotecas de instalação do Arduino IDE
Por fim, abra novamente o seu Arduino IDE

Código
Programaremos o ESP32 usando o Arduino IDE, então certifique-se de ter o complemento ESP32 instalado antes de prosseguir: (Se você já tiver feito esta etapa, pode pular para a próxima.)
Instalando o complemento ESP32 no Arduino IDE
Após instalar as bibliotecas necessárias, abra o código
Projeto_9_ESP32_DHT11_Web_Server.ino no IDE do Arduino.
Antes de enviar o código, não se esqueça de inserir suas credenciais de rede para que o ESP possa se conectar à sua rede local.Como o código funciona
Nos parágrafos seguintes, explicaremos como o código funciona. Continue lendo se quiser saber mais ou pule para a seção Demonstração para ver o resultado final.
Importando bibliotecas
Primeiro, importe as bibliotecas necessárias. O WiFi, ESPAsyncWebO servidor e o ESPAsyncTCP são necessários para construir o web servidor. As bibliotecas Adafruit_Sensor e DHT são necessárias para ler os sensores DHT11 ou DHT22.Definição de variáveis
Defina o GPIO ao qual o pino de dados DHT está conectado. Neste caso, ele está conectado ao GPIO 4.Em seguida, selecione o tipo de sensor DHT que você está usando. Em nosso exemploample, estamos usando o DHT22. Se você estiver usando outro tipo, você só precisa descomentar seu sensor e comentar todos os outros.

Instanciar um objeto DHT com o tipo e pino que definimos anteriormente.Crie um AsyncWebObjeto de servidor na porta 80.Ler funções de temperatura e umidade
Criamos duas funções: uma para ler a temperatura (readDHTTemperature()) e a outra para ler a umidade (readDHTHumidity()).Obter leituras do sensor é tão simples quanto usar Obter leituras do sensor é tão simples quanto usar os métodos readTemperature() e readHumidity() no objeto dht.Também temos uma condição que retorna dois traços (–) caso o sensor não consiga obter as leituras.As leituras são retornadas como tipo string. Para converter um float em uma string, use a função String()Por padrão, estamos lendo a temperatura em graus Celsius. Para obter a temperatura em graus Fahrenheit, comente a temperatura em Celsius e descomente a temperatura em Fahrenheit, para que você tenha o seguinte:Carregar o código
Agora, carregue o código para seu ESP32. Certifique-se de ter selecionado a placa e a porta COM corretas. Etapas de referência do código de upload.
Após o upload, abra o Serial Monitor a uma taxa de transmissão de 115200. Pressione o botão de reinicialização do ESP32. O endereço IP do ESP32 deve ser impresso no serial monitor.Demonstração
Abra um navegador e digite o endereço IP do ESP32. Seu web o servidor deve exibir as últimas leituras do sensor.
Observação: Seu navegador e o ESP32 devem estar conectados à mesma LAN.
Observe que as leituras de temperatura e umidade são atualizadas automaticamente, sem a necessidade de atualizar o web página.

Projeto_10_ESP32_OLED_Display

Este projeto mostra como usar o display OLED SSD0.96 de 1306 polegadas com ESP32 usando o Arduino IDE.
Apresentando o display OLED de 0.96 polegadas
O Tela OLED que usaremos neste tutorial é o modelo SSD1306: um display monocromático de 0.96 polegadas com 128×64 pixels, conforme mostrado na figura a seguir.O display OLED não requer luz de fundo, o que resulta em um contraste muito bom em ambientes escuros. Além disso, seus pixels consomem energia apenas quando estão ligados, então o display OLED consome menos energia quando comparado a outros displays.
Como o display OLED usa o protocolo de comunicação I2C, a fiação é muito simples. Você pode usar a tabela a seguir como referência.

Pino OLED	ESP32
Vinho	3.3V
Terra	Terra
SCL	GPIO22
Adventista do Sétimo Dia	GPIO21

esquemáticoInstalando a biblioteca OLED SSD1306 – ESP32
Existem várias bibliotecas disponíveis para controlar o display OLED com o ESP32.
Neste tutorial usaremos duas bibliotecas Adafruit: Biblioteca Adafruit_SSD1306 e Biblioteca Adafruit_GFX.
Siga os próximos passos para instalar essas bibliotecas.

Abra seu Arduino IDE e vá para Sketch > Include Library > Manage Libraries. O Library Manager deve abrir.
Digite “SSD1306” na caixa de pesquisa e instale a biblioteca SSD1306 da Adafruit.
Após instalar a biblioteca SSD1306 da Adafruit, digite “GFX” na caixa de pesquisa e instale a biblioteca.
Depois de instalar as bibliotecas, reinicie o IDE do Arduino.

Código
Após instalar as bibliotecas necessárias, abra o Project_10_ESP32_OLED_Display.ino no Arduino IDE.
Programaremos o ESP32 usando o Arduino IDE, então certifique-se de ter o complemento ESP32 instalado antes de prosseguir: (Se você já tiver feito esta etapa, pode pular para a próxima.)
Instalando o complemento ESP32 no Arduino IDEComo o código funciona
Importando bibliotecas
Primeiro, você precisa importar as bibliotecas necessárias. A biblioteca Wire para usar I2C e as bibliotecas Adafruit para escrever no display: Adafruit_GFX e Adafruit_SSD1306.Inicializar o display OLED
Então, você define a largura e a altura do seu OLED. Neste exemploample, estamos usando um display OLED de 128×64. Se estiver usando outros tamanhos, você pode alterar isso nas variáveis SCREEN_WIDTH e SCREEN_HEIGHT.Em seguida, inicialize um objeto de exibição com a largura e altura definidas anteriormente com o protocolo de comunicação I2C (&Wire).O parâmetro (-1) significa que seu display OLED não tem um pino RESET. Se seu display OLED tiver um pino RESET, ele deve ser conectado a um GPIO. Nesse caso, você deve passar o número do GPIO como um parâmetro.
Em setup(), inicialize o Serial Monitor em uma taxa de transmissão de 115200 para fins de depuração.Inicialize o display OLED com o método begin() da seguinte maneira:Este snippet também imprime uma mensagem no Monitor Serial, caso não consigamos nos conectar ao monitor.

Caso você esteja usando um display OLED diferente, pode ser necessário alterar o endereço OLED. No nosso caso, o endereço é 0x3C.Após inicializar o display, adicione um atraso de dois segundos para que o OLED tenha tempo suficiente para inicializar antes de escrever o texto:Limpar tela, definir tamanho da fonte, cor e escrever texto
Após inicializar a exibição, limpe o buffer de exibição com o método clearDisplay():

Antes de escrever o texto, você precisa definir o tamanho, a cor e onde o texto será exibido no OLED.
Defina o tamanho da fonte usando o método setTextSize():Defina a cor da fonte com o método setTextColor():
BRANCO define fonte branca e fundo preto.
Defina a posição onde o texto começa usando o método setCursor(x,y). Neste caso, estamos definindo o texto para começar nas coordenadas (0,0) – no canto superior esquerdo.Por fim, você pode enviar o texto para o display usando o método println(), da seguinte formaEntão, você precisa chamar o método display() para realmente exibir o texto na tela.

A biblioteca Adafruit OLED fornece métodos úteis para rolar texto facilmente.

startscrollright(0x00, 0x0F): rolar o texto da esquerda para a direita
startscrollleft(0x00, 0x0F): rolar o texto da direita para a esquerda
startscrolldiagright(0x00, 0x07): rolar o texto do canto inferior esquerdo para o canto superior direito startscrolldiagleft(0x00, 0x07): rolar o texto do canto inferior direito para o canto superior esquerdo

Carregar o código
Agora, carregue o código no seu ESP32. Etapas de referência para upload de código.
Após carregar o código, o OLED exibirá texto rolando.

Documentos / Recursos

Kit básico de iniciação LAFVIN ESP32 [pdf] Manual de Instruções
Kit de iniciação básico ESP32, ESP32, Kit de iniciação básico, Kit de iniciação

Referências

Manual do usuário

Lista de embalagem

Introdução ao ESP32

Placas de desenvolvimento ESP32

Carregar código de teste

Solução de problemas

Projeto 1 ESP32 Entradas Saídas

Demonstração

Projeto 2 ESP32 Entradas Analógicas

Encerrando

Projeto 3 ESP32 PWM (Saída Analógica)

Testando o Example

Projeto 4 ESP32 Sensor de movimento PIR

Projeto 5 ESP32 Switch Web Servidor

Como o código funciona

Estilizando o Web Página

Encerrando

Projeto 6 LED RGB Web Servidor

Projeto 7 ESP32 Relé Web Servidor

Projeto_8_Sincronização_do_Estado_de_Saída_ Web_Servidor

Como o código funciona

Projeto 9 ESP32 DHT11 Web Servidor

Projeto_10_ESP32_OLED_Display

Documentos / Recursos

Referências

Deixe um comentário

Cancelar resposta