Servidor da web ESP32 DHT11 Temperatura e umidade usando o Arduino IDE

Neste projeto aprenderá a construir um servidor Web ESP32 assíncrono com o DHT11 ou
DHT22 que exibe temperatura e umidade usando o Arduino IDE.

O servidor da Web que criaremos atualiza as leituras automaticamente, sem a necessidade

de atualizar a página da Web.

Com este projeto, você aprenderá:

Como ler temperatura e umidade dos sensores DHT;

Crie um servidor da Web assíncrono usando a biblioteca ESPAsyncWebServer ;
Atualize as leituras do sensor automaticamente, sem a necessidade de atualizar a página
da web.

Servidor da Web assíncrono

Para criar o servidor da Web, usaremos a biblioteca ESPAsyncWebServer que fornece uma
maneira fácil de criar um servidor da Web assíncrono. A criação de um servidor Web
assíncrono possui várias vantagens.

“Manipule 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 está cuidando do envio da resposta em segundo plano”;
“Mecanismo simples de processamento de modelos para manipular modelos”;
E muito mais.

Peças necessárias
ES32 DHT11 ou DHT22 Temperatura e umidade Esquema do circuito IDE do Arduino

Para concluir este tutorial, você precisa das seguintes partes:

Placa de desenvolvimento ESP32 (leia comparação das placas de desenvolvimento

ESP32 )
Sensor de temperatura e umidade DHT22 ou DHT11
Breadboard
Módulo relé opcoplado
Potenciômetro de 10k

Esquemático
Antes de prosseguir para o servidor da web, é necessário conectar o sensor DHT11 ou
DHT22 ao ESP32.Nesse caso, estamos conectando o pino de dados ao GPIO 27 , mas
você pode conectá-lo a qualquer outro pino digital.

Diagrama esquemático do circuito ESP32 DHT11 DHT22 de temperatura e umidade

Arduino IDE
(Este esquema usa a versão do módulo ESP32 DEVKIT V1 com 36 GPIOs - se você estiver
usando outro modelo, verifique a pinagem da placa que está usando.)

Nota: se você estiver usando um módulo com um sensor DHT, normalmente ele vem com
apenas três pinos. Os pinos devem ser rotulados para que você saiba como conectá-los.
Além disso, muitos desses módulos já vêm com um resistor pull up interno, portanto você
não precisa adicionar um ao circuito.

Instalando Bibliotecas
Você precisa instalar algumas bibliotecas para este projeto:

As bibliotecas DHT e Adafruit Unified Sensor Driver para ler no sensor DHT.
ESPAsyncWebServer e Async TCP para criar o servidor da Web assíncrono.
Siga as próximas instruções para instalar essas bibliotecas:

Instalando a biblioteca de sensores DHT

Para ler o sensor DHT usando o Arduino IDE, é necessário instalar a biblioteca de sensores
DHT . Siga as próximas etapas para instalar a biblioteca.

Você deve ter uma pasta .zip na pasta Downloads

Descompacte a pasta .zip e você deve obter biblioteca mestre DHT-Sensor- pasta
Renomeie sua pasta de DHT-sensor-biblioteca-mestre 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 unificado do sensor Adafruit

Você também precisa instalar a biblioteca Driver Adafruit Unified Sensor para trabalhar com
o sensor DHT. Siga as próximas etapas para instalar a biblioteca.

Você deve ter uma pasta .zip na pasta Downloads

Descompacte a pasta .zip e você deve obter a pasta Adafruit_sensor-master
Renomeie sua pasta de Adafruit_sensor-master para Adafruit_sensor
Move the Adafruit_sensor pasta de bibliotecas de instalação do Arduino IDE
Por fim, abra novamente o seu Arduino IDE

Instalando a biblioteca do ESPAsyncWebServer

Follow the next steps to install the ESPAsyncWebServer library:

a ESPAsyncWebServer library. You should have a .zip folder in your Downloads folder
Unzip the .zip folder and you should get ESPAsyncWebServer-master folder
Rename your folder from ESPAsyncWebServer-master to ESPAsyncWebServer
Move the ESPAsyncWebServer folder to your Arduino IDE installation libraries folder
Installing the Async TCP Library for ESP32

A biblioteca ESPAsyncWebServer requer que a biblioteca AsyncTCP funcione. Siga as

próximas etapas para instalar essa biblioteca:

Clique aqui para baixar a biblioteca AsyncTCP . Você deve ter uma pasta .zip na pasta
Downloads
Descompacte a pasta .zip e você deve 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
Denunciar este anúncio

Código
Vamos programar o ESP32 usando o Arduino IDE, portanto, certifique-se de ter o
complemento ESP32 instalado antes de continuar:

Instale a placa ESP32 no Arduino IDE (instruções para Windows, Mac e Linux)
Abra seu IDE do Arduino e copie o seguinte código.

/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/

// Import required libraries

#include "WiFi.h"
#include "ESPAsyncWebServer.h"
#include <Adafruit_Sensor.h>
#include <DHT.h>

// Replace with your network credentials

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

#define DHTPIN 27 // Digital pin connected to the DHT sensor

// Uncomment the type of sensor in use:

//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
DHT dht(DHTPIN, DHTTYPE);

// Create AsyncWebServer object on port 80

AsyncWebServer server(80);

String readDHTTemperature() {
// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
// Read temperature as Celsius (the default)
float t = dht.readTemperature();
// Read temperature as Fahrenheit (isFahrenheit = true)
//float t = dht.readTemperature(true);
// Check if any reads failed and exit early (to try again).
if (isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return "--";
}
else {
Serial.println(t);
return String(t);
}
}

String readDHTHumidity() {
// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
float h = dht.readHumidity();
if (isnan(h)) {
Serial.println("Failed to read from DHT sensor!");
return "--";
}
else {
Serial.println(h);
return String(h);
}
}

const char index_html[] PROGMEM = R"rawliteral(

<!DOCTYPE HTML><html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css"
integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLb
HG9Sr" crossorigin="anonymous">
<style>
html {
font-family: Arial;
 display: inline-block;
margin: 0px auto;
text-align: center;
}
h2 { font-size: 3.0rem; }
p { font-size: 3.0rem; }
.units { font-size: 1.2rem; }
.dht-labels{
font-size: 1.5rem;
vertical-align:middle;
padding-bottom: 15px;
}
</style>
</head>
<body>
<h2>ESP32 DHT Server</h2>
<p>
<i class="fas fa-thermometer-half" style="color:#059e8a;"></i>
<span class="dht-labels">Temperature</span>
<span id="temperature">%TEMPERATURE%</span>
<sup class="units">&deg;C</sup>
</p>
<p>
<i class="fas fa-tint" style="color:#00add6;"></i>
<span class="dht-labels">Humidity</span>
<span id="humidity">%HUMIDITY%</span>
<sup class="units">%</sup>
</p>
</body>
<script>
setInterval(function ( ) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("temperature").innerHTML = this.responseText;
}
};
xhttp.open("GET", "/temperature", true);
xhttp.send();
}, 10000 ) ;

setInterval(function ( ) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("humidity").innerHTML = this.responseText;
 }
};
xhttp.open("GET", "/humidity", true);
xhttp.send();
}, 10000 ) ;
</script>
</html>)rawliteral";

// Replaces placeholder with DHT values

String processor(const String& var){
//Serial.println(var);
if(var == "TEMPERATURE"){
return readDHTTemperature();
}
else if(var == "HUMIDITY"){
return readDHTHumidity();
}
return String();
}

void setup(){
// Serial port for debugging purposes
Serial.begin(115200);

dht.begin();

// Connect to Wi-Fi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi..");
}

// Print ESP32 Local IP Address

Serial.println(WiFi.localIP());

// Route for root / web page

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/html", index_html, processor);
});
server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readDHTTemperature().c_str());
});
server.on("/humidity", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readDHTHumidity().c_str());
});
 // Start server
server.begin();
}

void loop(){

}
Denunciar este anúncio

Ver código bruto

Insira suas credenciais de rede nas seguintes variáveis ​e o código funcionará

imediatamente.

const char* ssid = "REPLACE_WITH_YOUR_SSID";

const char* password = "REPLACE_WITH_YOUR_PASSWORD";
Denunciar este anúncio

Como o código funciona

Nos parágrafos seguintes, explicaremos como o código funciona. Continue lendo se quiser
aprender mais ou vá para a seção Demonstração para ver o resultado final.

Importando bibliotecas
Primeiro, importe as bibliotecas necessárias. O WiFi , ESPAsyncWebServer e
ESPAsyncTCP são necessários para construir o servidor web. O Adafruit_Sensor e as
bibliotecas DHT são necessárias para ler os sensores DHT11 ou DHT22.

#include "WiFi.h"
#include "ESPAsyncWebServer.h"
#include <ESPAsyncTCP.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
Definindo suas credenciais de rede
Insira suas credenciais de rede nas seguintes variáveis, para que o ESP32 possa se
conectar à sua rede local.

Denunciar este anúncio

const char* ssid = "REPLACE_WITH_YOUR_SSID";

const char* password = "REPLACE_WITH_YOUR_PASSWORD";
Definição de variáveis
Defina o GPIO ao qual o pino de dados DHT está conectado. Nesse caso, ele está
conectado ao GPIO 27 .

#define DHTPIN 27 // Digital pin connected to the DHT sensor

Em seguida, selecione o tipo de sensor DHT que você está usando. No nosso exemplo,
estamos usando o DHT22. Se você estiver usando outro tipo, basta descomentar o sensor e
comentar todos os outros.

#define DHTTYPE DHT22 // DHT 22 (AM2302)

Instancie um objeto DHT com o tipo e o pino que definimos anteriormente.

DHT dht(DHTPIN, DHTTYPE);

Crie um objeto AsyncWebServer na porta 80.

AsyncWebServer server(80);
Denunciar este anúncio

Leia as funções de temperatura e umidade

Criamos duas funções: uma para ler a temperatura ( readDHTTemperature () ) e a outra
para ler a umidade ( readDHTHumidity () ).

String readDHTTemperature() {
// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
// Read temperature as Celsius (the default)
float t = dht.readTemperature();
// Read temperature as Fahrenheit (isFahrenheit = true)
//float t = dht.readTemperature(true);
// Check if any reads failed and exit early (to try again).
if (isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return "--";
}
else {
Serial.println(t);
return String(t);
}
}
Obter leituras do sensor é tão simples quanto usar os métodos readTemperature () e
readHumidity () no objeto dht .

Denunciar este anúncio

float t = dht.readTemperature();
float h = dht.readHumidity();
Também temos uma condição que retorna dois traços (-), caso o sensor falhe nas leituras.

if (isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return "--";
}
As leituras são retornadas como tipo de sequência. Para converter um float em uma string,
use a função String () .

return String(t);
Por padrão, estamos lendo a temperatura em graus Celsius. Para obter a temperatura em
graus Fahrenheit, comente a temperatura em Celsius e remova o comentário da
temperatura em Fahrenheit, para obter o seguinte:

Denunciar este anúncio

//float t = dht.readTemperature();
// Read temperature as Fahrenheit (isFahrenheit = true)
float t = dht.readTemperature(true);
Construindo a página da Web
Prosseguindo para a página do servidor da web.

Página da web ESP32 DHT11 DHT22 Temperatura e umidade

Como você pode ver na figura acima, a página da web mostra um cabeçalho e dois
parágrafos. Há um parágrafo para exibir a temperatura e outro para exibir a umidade.
Existem também dois ícones para estilizar nossa página.

Vamos ver como esta página da web é criada.

Denunciar este anúncio

Todo o texto HTML com estilos incluídos é armazenado na variável index_html . Agora,
examinaremos o texto HTML e veremos o que cada parte faz.

A seguinte tag <meta> torna sua página da web responsiva em qualquer navegador.

<meta name="viewport" content="width=device-width, initial-scale=1">

A tag <link> é necessária para carregar os ícones no site de fontawesome.

<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css"

integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLb
HG9Sr" crossorigin="anonymous">
Estilos
Entre as tags <style> </style> , adicionamos CSS para estilizar a página da web.

<style>
html {
font-family: Arial;
display: inline-block;
margin: 0px auto;
text-align: center;
}
 h2 { font-size: 3.0rem; }
p { font-size: 3.0rem; }
.units { font-size: 1.2rem; }
.dht-labels{
font-size: 1.5rem;
vertical-align:middle;
padding-bottom: 15px;
}
</style>
Denunciar este anúncio

Basicamente, estamos configurando a página HTML para exibir o texto com a fonte Arial em
bloco sem margem e alinhada no centro.

html {
font-family: Arial;
display: inline-block;
margin: 0px auto;
text-align: center;
}
Definimos o tamanho da fonte para o cabeçalho ( h2 ), parágrafo ( p ) e as unidades (
.unidades ) das leituras.

h2 { font-size: 3.0rem; }
p { font-size: 3.0rem; }
.units { font-size: 1.2rem; }
Denunciar este anúncio

Os rótulos das leituras são estilizados conforme mostrado abaixo:

dht-labels{
font-size: 1.5rem;
vertical-align:middle;
padding-bottom: 15px;
}
Todas as tags anteriores devem estar entre as tags <head> e </head> . Essas tags são
usadas para incluir conteúdo que não é diretamente visível ao usuário, como as tags
<meta> , <link> e os estilos.

Corpo HTML
Dentro das tags <body> </body> é onde adicionamos o conteúdo da página da web.

As tags <h2> </h2> adicionam um cabeçalho à página da web. Nesse caso, o texto
“servidor ESP32 DHT”, mas você pode adicionar qualquer outro texto.

<h2>ESP32 DHT Server</h2>

Denunciar este anúncio

Então, existem dois parágrafos. Um para exibir a temperatura e o outro para exibir a
umidade. Os parágrafos são delimitados pelas tags <p> e </p> . O parágrafo para a
temperatura é o seguinte:

<p>
<i class="fas fa-thermometer-half" style="color:#059e8a;"</i>
<span class="dht-labels">Temperature</span>
<span id="temperature">%TEMPERATURE%</span>
<sup class="units">°C</sup>
</p>
E o parágrafo para a umidade está no seguinte trecho:

<p>
<i class="fas fa-tint" style="color:#00add6;"></i>
<span class="dht-labels">Humidity</span>
<span id="humidity">%HUMIDITY%</span>
<sup class="units">%</sup>
</p>
As tags <i> exibem os ícones fontawesome.

Como exibir ícones

Para escolher os ícones, acesse o site Font Awesome Icons .

Denunciar este anúncio

Site da Font Awesome Icons

Pesquise o ícone que você está procurando. Por exemplo, "termômetro".

Termômetro do site Font Awesome Icons

Clique no ícone desejado. Então, você só precisa copiar o texto HTML fornecido.

<i class="fas fa-thermometer-half">

Fonte impressionante ícones site termômetro metade
Para escolher a cor, basta passar o parâmetro style com a cor em hexadecimal, da seguinte
maneira:

<i class="fas fa-tint" style="color:#00add6;"></i>

Prosseguindo com o texto HTML…

A próxima linha grava a palavra "Temperatura" na página da web.

<span class="dht-labels">Temperature</span>
O texto TEMPERATURE entre os sinais% é um espaço reservado para o valor da
temperatura.
<span id="temperature">%TEMPERATURE%</span>
Isso significa que esse texto % TEMPERATURE% é como uma variável que será
substituída pelo valor real da temperatura do sensor DHT. Os espaços reservados no texto
HTML devem estar entre sinais de%.

Finalmente, adicionamos o símbolo de grau.

Denunciar este anúncio

<sup class="units">°C</sup>
As marcas <sup> < / sup> tornam o texto sobrescrito.

Usamos a mesma abordagem para o parágrafo de umidade, mas ele usa um ícone
diferente e o espaço reservado % HUMIDITY% .

<p>
<i class="fas fa-tint" style="color:#00add6;"></i>
<span class="dht-labels">Humidity</span>
<span id="humidity">%HUMIDITY%</span>
<sup class="units">%</sup>
</p>
Atualizações automáticas
Finalmente, há algum código JavaScript em nossa página da web que atualiza a
temperatura e a umidade automaticamente, a cada 10 segundos.

Os scripts no texto HTML devem estar entre as tags <script> </script> .

<script>
setInterval(function ( ) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("temperature").innerHTML = this.responseText;
}
};
xhttp.open("GET", "/temperature", true);
xhttp.send();
}, 10000 ) ;

setInterval(function ( ) {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("humidity").innerHTML = this.responseText;
 }
};
xhttp.open("GET", "/humidity", true);
xhttp.send();
}, 10000 ) ;
</script>
Denunciar este anúncio

Para atualizar a temperatura em segundo plano, temos uma função setInterval () que é
executada a cada 10 segundos.

Basicamente, ele faz um pedido no URL / temperature para obter a leitura mais recente da
temperatura.

xhttp.open("GET", "/temperature", true);

xhttp.send();
}, 10000 ) ;
Denunciar este anúncio

Quando recebe esse valor, ele atualiza o elemento HTML cujo ID é temperatura .

if (this.readyState == 4 && this.status == 200) {

document.getElementById("temperature").innerHTML = this.responseText;
}
Em resumo, esta seção anterior é responsável por atualizar a temperatura de forma
assíncrona. O mesmo processo é repetido para as leituras de umidade.

Importante: como o sensor DHT é muito lento para obter as leituras, se você planeja ter
vários clientes conectados a um ESP32 ao mesmo tempo, recomendamos aumentar o
intervalo de solicitação ou remover as atualizações automáticas.

Processador
Agora, precisamos criar a função processor () , que substituirá os espaços reservados em
nosso texto HTML pelos valores reais de temperatura e umidade.

Denunciar este anúncio

String processor(const String& var){

//Serial.println(var);
if(var == "TEMPERATURE"){
return readDHTTemperature();
}
else if(var == "HUMIDITY"){
return readDHTHumidity();
}
return String();
}
Quando a página da web é solicitada, verificamos se o HTML possui algum espaço
reservado. Se encontrar o espaço reservado % TEMPERATURE% , retornamos a
temperatura chamando a função readDHTTemperature () criada anteriormente.

if(var == "TEMPERATURE"){
return readDHTTemperature();
}
Denunciar este anúncio

Se o espaço reservado for % HUMIDITY% , retornamos o valor da umidade.

else if(var == "HUMIDITY"){

return readDHTHumidity();
}
configuração()
Na configuração (), inicialize o Serial Monitor para fins de depuração.

Serial.begin(115200);
Inicialize o sensor DHT.

dht.begin();
Conecte-se à sua rede local e imprima o endereço IP do ESP32.

WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi..");
}
Por fim, adicione as próximas linhas de código para manipular o servidor da web.

Denunciar este anúncio

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/html", index_html, processor);
});
server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readDHTTemperature().c_str());
});
server.on("/humidity", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/plain", readDHTHumidity().c_str());
});
Quando fazemos uma solicitação no URL raiz, enviamos o texto HTML armazenado na
variável index_html . Também precisamos passar a função do processador , que substituirá
todos os espaços reservados pelos valores corretos.
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
request->send_P(200, "text/html", index_html, processor);
});
Precisamos adicionar dois manipuladores adicionais para atualizar as leituras de
temperatura e umidade. Quando recebemos uma solicitação no URL / temperature , basta
enviar o valor atualizado da temperatura. É texto simples e deve ser enviado como um
caractere; portanto, usamos o método c_str () .

Denunciar este anúncio

server.on("/temperature", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/plain", readDHTTemperature().c_str());
});
O mesmo processo é repetido para a umidade.

server.on("/humidity", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/plain", readDHTHumidity().c_str());
});
Por fim, podemos iniciar o servidor.

server.begin();
Como este é um servidor da Web assíncrono, não precisamos escrever nada no loop () .

void loop(){

}
É assim que o código funciona.

Denunciar este anúncio

Carregar o código
Agora, faça o upload do código para o seu ESP32. Verifique se você selecionou a placa e a
porta corretas.

Após o upload, abra o Serial Monitor a uma taxa de transmissão de 115200. Pressione o
botão de reset ESP32. O endereço IP do ESP32 deve ser impresso no monitor serial.

Carregar o exemplo de código de esboço DHT11 DHT22 ESP32

Demonstração do Servidor Web
Abra um navegador e digite o endereço IP do ESP32. Seu servidor da web deve exibir as
últimas leituras do sensor.

Observe que as leituras de temperatura e umidade são atualizadas automaticamente sem a

necessidade de atualizar a página da web.
Denunciar este anúncio

Servidor da web ESP32 DHT11 / DHT22 - Temperatura e umidade usando a demonstração

do Arduino IDE
Solução de problemas
Se o sensor DHT não conseguir obter as leituras, leia o Guia de solução de problemas do
DHT para ajudá-lo a corrigir o problema.

Empacotando
Neste tutorial, mostramos como criar um servidor da Web assíncrono com o ESP32 para
exibir as leituras do sensor de um sensor DHT11 ou DHT22 e como atualizar as leituras
automaticamente

Sensor dht11

O Sensor de Umidade e Temperatura DHT11 é um sensor de

temperatura e umidade que permite fazer leituras de
temperaturas entre 0 a 50 Celsius e umidade entre 20 a 90%,
muito usado para projetos com Arduino.

O elemento sensor de temperatura é um termistor do tipo NTC

e o sensor de Umidade é do tipo HR202, o circuito interno faz a
leitura dos sensores e se comunica a um microcontrolador
através de um sinal serial de uma via. Confira a pinagem nas
imagens.

Especificações:
– Modelo: DHT11 (Datasheet)
– Faixa de medição de umidade: 20 a 90% UR
– Faixa de medição de temperatura: 0º a 50ºC
– Alimentação: 3-5VDC (5,5VDC máximo)
– Corrente: 200uA a 500mA, em stand by de 100uA a 150 uA
– Precisão de umidade de medição: ± 5,0% UR
– Precisão de medição de temperatura: ± 2.0 ºC
– Tempo de resposta: 2s
– Dimensões: 23 x 12 x 5mm (incluindo terminais)

ntrodução
Umidade é a quantidade de vapor de água na atmosfera.

A umidade relativa do ar é uma importante medida usada na

previsão do tempo, e indica a possibilidade de precipitação
chuva. A alta quantidade de vapor de água na atmosfera
favorece a ocorrência de chuvas. Já com a umidade do ar
baixa, é difícil chover.

A alta umidade durante dias quentes faz a sensação térmica

aumentar, ou seja, a pessoa tem a impressão de que está mais
calor, devido à redução da eficácia da transpiração da pele, e
assim reduzindo o resfriamento corporal. De acordo com a
OMS (Organização Mundial da Saúde), valores de umidade
abaixo de 20% oferecem risco à saúde, podendo provocar
desidratação nas pessoas.

O instrumento chamado de Higrômetro é usado para a

medição da umidade relativa presente na atmosfera. É
utilizado principalmente em estudos do clima, mas também em
locais fechados onde a presença de umidade excessiva ou
abaixo do normal poderia causar danos, por exemplo dentro
de museus , bibliotecas e em laboratórios.

Umidade – fonte : Wikipedia

Essas são algumas aplicações para os Sensores de Umidade e

Temperatura:
Estação Meteorológica,
Controle de irrigação para plantas,
Controle de umidade e temperatura em ambientes controlados,
Frigoríficos,
Data Centers,
Data loggers, etc.

Sensor DHT11
O sensor DHT11 é um dispositivo de baixo custo usado para
medição de umidade e temperatura do ar. O sensor de
umidade é capacitivo e o sensor de temperatura é um
termistor NTC, isto é um resistor sensível à variações de
temperatura. Dentro do sensor existe um microcontrolador
que faz as medições e transmite os valores no formato digital
através de um pino de saída. Segundo o fabricante, a
transmissão digital pode ser realizada através de um cabo de
até 20 metros.

OBS = longa exposição do sensor ao sol, poderá afetar a

performance do mesmo.

Especificações do sensor DHT11 (esses valores podem variar

dependendo do fabricante):

Faixa de umidade relativa = de 20 a 80 %

Precisão na umidade = ± 5 % RH
Resolução de umidade = 5 % RH
Faixa de temperatura = 0 a 50 °C
Precisão na temperatura = ± 2 % °C
Resolução na temperatura = 2 °C
Tempo de resposta = 2 segundos
Alimentação = de 3,5 V a 5 V
Consumo máximo de corrente = 2,5 mA
DHT11 Datasheet

Sensor DHT11 – pinout

VCC = 3,5 a 5V
DATA = comunicação de dados
NC = sem conexão
GND = terra

Sensor DHT22/AM2302
O Sensor DHT22 ou AM2302 também é usado para medição de
umidade e temperatura do ar. Só que com características
melhores do que o do DHt11. Tem maior precisão nas
medições e abrange uma faixa maior de temperatura e
umidade. Por isso ele custa um pouco mais caro.

Especificações do sensor DHT22 (esses valores podem variar

dependendo do fabricante) :

Faixa de umidade relativa = de 0 a 100 %

Precisão na umidade = ± 2% RH
Resolução de umidade = 0,1 % RH
Faixa de temperatura = -40 a 80 °C
Precisão na temperatura = ± 1 % °C
Resolução na temperatura = 0,1 °C
Tempo de resposta = < 5 segundos
Alimentação = de 3,3V a 5 V
Consumo máximo de corrente = 0,5 mA
Datasheet_DHT22/AM2302
Existem algumas limitações no tamanho do cabo do sensor.
Se a tensão de alimentação for de 3,3V, o cabo não pode
exceder um metro. Veja no datasheet. Longa exposição do
sensor ao sol, poderá afetar a performance do mesmo,
também.

Sensor DHT22/AM2302 – pinout

VCC = 3,3 a 5V
DATA = comunicação de dados
NC = sem conexão
GND = terra
Para os curiosos, encontrei essa imagem do sensor DHT22
aberto e sem a tampa. Fonte = How to Mechatronics.

Interface com os Sensores DHT

Após a alimentação de tensão dos Sensores DHT11 ou DHT22,
aguarde cinco segundos para o circuito se estabilizar. Um
capacitor de 100 nF é recomendado entre o pino VCC e o GND.
No pino de saída, deve ser usado também um resistor de
pullup (4,7K ohms). No caso do módulo sensor DHT11, esses
componentes não são necessários pois já estão montados na
placa.

A comunicação dos dados no barramento serial (único pino)

ocorre nos dois sentidos, isto é, do sensor para o
Microcontrolador e vice-versa.

O protocolo de comunicação pode ser dividido em três partes :

Requisição : para o sensor enviar os dados, ele deverá ser
requisitado,
Resposta : o sensor envia uma resposta depois de requisitado,
Leitura de dados: após a resposta do sensor, os dados são
enviado em 5 segmentos de 8 bits (40 bits).
Os dois primeiros bytes correspondem à umidade relativa na
forma integral e decimal. O terceiro e quarto byte formam a
temperatura em graus Celsius na forma integral e decimal. O
último byte é o checksum dos dados.

Se quiser saber mais sobre os sensores e os protocolos,

sugiro a leitura dos Datasheets e do documento abaixo :

Módulo sensor DHt11

Modulo Sensor DHT11 – pinout

Sensor DHT11 ou DHT22 com Arduino

A montagem dos Sensores DHT com Arduino é muito simples.
Como os fios de ligação são curtos, não conectei o capacitor
como recomendado. Se for usar cabos mais extensos, monte o
capacitor entre o VCC e o terra. Mas o resistor de pullup de 4,7
K ohms é necessário. O Diagrama Fritzing abaixo serve para
os dois sensores: DHT11 ou DHT22, já que eles têm a mesma
pinagem. Mas não se esqueça de configurar no programa, o
sensor usado. Já que existem algumas diferenças nos
protocolos de comunicação.
Considerando que o módulo DHT11 já tem o resistor de pullup
no pino de dados, nem esse resistor é necessário. A
alimentação recomendável é de 5 V.

Instalando a Biblioteca DHT Sensor

Tanto para o uso do Sensor DHT11 quanto para o DHT22, a
biblioteca que será usada é a da Adafruit. Ela segue os
padrões da IDE Arduino e é bem simples para usá-la.

Para instalar a nova Biblioteca DHT Sensor Library , clique em

:

Sketch > Incluir Biblioteca > Gerenciar Bibliotecas

Após abrir a janela do Gerenciador de Biblioteca, refine a

busca digitando DHT Sensor Library. Na biblioteca da
Adafruit, clique em More Info e depois em Instalar. Após
alguns segundos, ela será automaticamente instalada.
Lembre-se que o seu computador precisa estar conectado na
internet, para poder baixar a biblioteca. Após a instalação da
Biblioteca, é necessário que feche e abra novamente o
programa Arduino IDE.

Sketch Arduino – Sensor DHT

O programa também é bem simples. Fiz uma tradução do
exemplo da Biblioteca da Adafruit, para facilitar o
entendimento. O programa faz com que o Arduino se
comunique com o Sensor DHT, para realizar as leituras de
umidade e temperatura.

O mesmo programa poderá ser usado para os dois sensores

(DHT11 ou DHT22). Mas somente um sensor deverá ser usado
de cada vez. É necessário somente a definição no programa,
do sensor a ser usado.

Para usar o Sensor DHT11 , comente o Sensor DHT22 :

#define DHTTYPE DHT11 // Sensor DHT11

//#define DHTTYPE DHT22 // Sensor DHT22 ou AM2302

Ou para usar o Sensor DHT22, comente o Sensor DHT11 :

//#define DHTTYPE DHT11 // Sensor DHT11

#define DHTTYPE DHT22 // Sensor DHT22 ou AM2302

Sketch ArduinoDHT.ino

Potenciometro

Random Nerd Tutorials

Procurar Cardápio
ESP32 ADC - Leia valores analógicos com o Arduino IDE
Este artigo 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.

ESP32 ADC Leia valores analógicos com o Arduino IDE

Ler entradas analógicas com o ESP32 é tão fácil quanto usar a
função analogRead (GPIO) , que aceita como argumento, o
GPIO que você deseja ler.

Também temos outros tutoriais sobre como usar pinos

analógicos na placa ESP:

ESP8266 ADC - Leia valores analógicos com o Arduino IDE,

MicroPython e Lua
Leituras analógicas ESP32 com MicroPython
Assista o vídeo
Você pode assistir ao tutorial em vídeo ou continuar lendo
esta página para obter instruções escritas.

Denunciar este anúncio

Entradas Analógicas (ADC)

A leitura de um valor analógico com o ESP32 significa que
você pode medir diferentes níveis de tensão entre 0 V e 3,3 V.

A tensão medida é então atribuída a um valor entre 0 e 4095,

no qual 0 V corresponde a 0 e 3,3 V corresponde a 4095.
Qualquer tensão entre 0 V e 3,3 V receberá o valor
correspondente no meio.

Denunciar este anúncio

Entradas de leitura analógica ESP32 ADC Range Value

ADC é não linear
Idealmente, você esperaria um comportamento linear ao usar
os pinos do ESP32 ADC. No entanto, isso não acontece. O que
você terá é um comportamento, conforme mostrado no gráfico
a seguir:

ESP32 ESP32 ADC Leitura Analógica Entradas Faixa Valor

Comportamento
Ver fonte
Esse comportamento significa que seu ESP32 não é capaz de
distinguir 3,3 V de 3,2 V. Você obterá o mesmo valor para as
duas tensões: 4095.

O mesmo acontece com valores de tensão muito baixos: para

0 V e 0,1 V, você obtém o mesmo valor: 0. Você deve ter isso
em mente ao usar os pinos do ESP32 ADC.

Denunciar este anúncio

Há uma discussão no GitHub sobre esse assunto.

Função analogRead ()
Ler uma entrada analógica com o ESP32 usando o Arduino IDE
é tão simples quanto usar a função analogRead () . Ele aceita
como argumento o GPIO que você deseja ler:

analogRead(GPIO);
O ESP32 suporta medições em 18 canais diferentes. Apenas
15 estão disponíveis na placa DEVKIT V1 DOIT (versão com 30
GPIOs).

Pegue a pinagem da placa ESP32 e localize os pinos ADC. Eles

são destacados com uma borda vermelha na figura abaixo.
Pinos de ESP32 ADC GPIOs

Denunciar este anúncio

Saiba mais sobre os GPIOs do ESP32: Referência de pinagem

do ESP32 .

Esses pinos de entrada analógica têm resolução de 12 bits.

Isso significa que, quando você lê uma entrada analógica, seu
alcance pode variar de 0 a 4095.

Nota: Os pinos ADC2 não podem ser usados ​quando o Wi-Fi é

usado. Portanto, se você estiver usando Wi-Fi e tiver
problemas para obter o valor de um GPIO da ADC2, considere
usar um GPIO da ADC1, o que deve resolver seu problema.

Outras funções úteis

Existem outras funções mais avançadas para usar com os
pinos do ADC que podem ser úteis em outros projetos.

analogReadResolution (resolution) : defina os bits e a

resolução da amostra. Pode ser um valor entre 9 (0 - 511) e 12
bits (0 - 4095). O padrão é resolução de 12 bits.
analogSetWidth (width) : define os bits e a resolução da
amostra. Pode ser um valor entre 9 (0 - 511) e 12 bits (0 - 4095).
O padrão é resolução de 12 bits.
analogSetCycles (cycles) : defina o número de ciclos por
amostra. O padrão é 8. Intervalo: 1 a 255.
analogSetSamples (samples) : defina o número de amostras
no intervalo. O padrão é 1 amostra. Tem um efeito de aumentar
a sensibilidade.
analogSetClockDiv (atenuação) : defina o divisor para o
relógio ADC. O padrão é 1. Faixa: 1 a 255.
analogSetAttenuation (atenuação) : define a atenuação de
entrada para todos os pinos ADC. O padrão é ADC_11db .
Valores aceitos:
ADC_0db : define nenhuma atenuação (entrada de 1V = leitura
ADC de 1088).
ADC_2_5db : define uma atenuação de 1,34 (entrada 1V =
leitura ADC de 2086).
ADC_6db : define uma atenuação de 1,5 (entrada 1V = leitura
ADC de 2975).
ADC_11db : define uma atenuação de 3,6 (entrada 1V = leitura
ADC de 3959).
analogSetPinAttenuation (pino, atenuação) : define a
atenuação de entrada para o pino especificado. O padrão é
ADC_11db . Os valores de atenuação são os mesmos da
função anterior.
adcAttachPin (pino) : conecte um pino ao ADC (também limpa
qualquer outro modo analógico que possa estar ativado ).
Retorna resultado VERDADEIRO ou FALSO.
adcStart (pino ), adcBusy (pino) e resultadcEnd (pino) : inicia
uma conversão ADC no barramento do pino conectado.
Verifique se a conversão no barramento ADC do pino está em
execução no momento (retorna VERDADEIRO ou FALSO).
Obtenha o resultado da conversão: retorna um número inteiro
de 16 bits.
Denunciar este anúncio

Há um vídeo muito bom explicando essas funções que você

pode assistir aqui .

Ler valores analógicos de um potenciômetro com ESP32

Para ver como tudo se une, faremos um exemplo simples para
ler um valor analógico de um potenciômetro.

Denunciar este anúncio

Neste exemplo, você precisa das seguintes partes:

Placa ESP32 DOIT DEVKIT V1 (leia as melhores placas de

desenvolvimento ESP32 )
Potenciômetro
Breadboard
Jumper wires
Você pode usar os links anteriores ou ir diretamente para
MakerAdvisor.com/tools para encontrar todas as partes de
seus projetos pelo melhor preço!

Denunciar este anúncio

Esquemático
Conecte um potenciômetro ao seu ESP32. O pino do meio do
potenciômetro deve ser conectado ao GPIO 34. Você pode
usar o seguinte diagrama esquemático como referência.

Denunciar este anúncio

Ler valor do potenciômetro ESP32 Arduino IDE

Código
Vamos programar o ESP32 usando o Arduino IDE, portanto,
certifique-se de ter o complemento ESP32 instalado antes de
continuar:
Instruções do Windows - Placa ESP32 no Arduino IDE
Instruções para Mac e Linux - Placa ESP32 no Arduino IDE
Abra seu IDE do Arduino e copie o seguinte código.

Denunciar este anúncio

// Potentiometer is connected to GPIO 34 (Analog ADC1_CH6)

const int potPin = 34;

// variable for storing the potentiometer value

int potValue = 0;

void setup() {
Serial.begin(115200);
delay(1000);
}

void loop() {
// Reading potentiometer value
potValue = analogRead(potPin);
Serial.println(potValue);
delay(500);
}
Ver código bruto

Esse código simplesmente lê os valores do potenciômetro e

imprime esses valores no Serial Monitor.

No código, você começa definindo o GPIO ao qual o

potenciômetro está conectado. Neste exemplo, GPIO 34 .

const int potPin = 34;

Denunciar este anúncio
Na configuração () , inicialize uma comunicação serial com
uma taxa de transmissão de 115200.

Serial.begin(115200);
No loop () , use a função analogRead () para ler a entrada
analógica do potPin .

potValue = analogRead(potPin);
Por fim, imprima os valores lidos no potenciômetro no monitor
serial.

Serial.println(potValue);
Faça o upload do código fornecido para o seu ESP32.
Verifique se a placa direita e a porta COM estão selecionadas
no menu Ferramentas.

Testando o exemplo
Após fazer o upload do 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.

Denunciar este anúncio

Potenciômetro de leitura ESP32 analog

O valor máximo obtido é 4095 e o valor mínimo é 0.

Ler o potenciômetro ESP32 analogRead serial monitor Arduino

IDE demonstration
Empacotando
Neste artigo, você aprendeu a ler entradas analógicas usando
o ESP32 com o Arduino IDE. Em suma:
A placa ESP32 DEVKIT V1 DOIT (versão com 30 pinos) possui
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 IDE do Arduino, basta usar a função
analogRead () .
Os pinos do ESP32 ADC não têm um comportamento linear.
Você provavelmente não será capaz de distinguir entre 0 e
0,1V ou entre 3,2 e 3,3V. Você deve ter isso em mente ao usar
os pinos do ADC

Este módulo Relé 5V 8 canais é uma ótima opção para quem

precisa fazer vários acionamentos com a facilidade de ter tudo
em apenas uma só placa, de forma confiável, compacta e
robusta.

Com este módulo Relé 5V é possível acionar cargas de 220V

AC, como lâmpadas, equipamentos eletrônicos e motores com
o auxílio de um microcontrolador Arduino, PIC, ARM. Tudo
isso sem a necessidade de montar um circuito com
transistores, relés, conectores, leds e diodos.

Especificações:
– Modelo: SRD-05VDC-SL-C (Datasheet)
– Tensão de operação: 5VDC
– Permite controlar cargas de 220V AC
– Corrente típica de operação: 15~20mA
– LED indicador de status
– Pinagem: Normal Aberto, Normal Fechado e Comum
– Tensão de saída: (30 VDC a 10A) ou (250VAC a 10A)
– Furos de 3mm para fixação nas extremidades da placa
– Tempo de resposta: 5~10ms
– Ativo baixo (Aciona com GND)
– Dimensões: 135 x 52 x 20mm

Esp32

Conhecendo o ESP32 – Introdução (1)

Nesse tutorial, você conhecerá todas as informações básicas sobre

o Microcontrolador ESP32. Como é um chip com muitos recursos e
de certa forma complexo, a quantidade de material para ser
estudado é muito grande. Com essa base apresentada aqui,
poderá dar início ao aprendizado dele.

Em 2015, a empresa chinesa Espressif lançou o Microcontrolador

ESP8266. O produto foi uma inovação tecnológica na época, pois
já vinha com os circuitos de WIFI embutidos no próprio chip e com
preço bem acessível. O uso do ESP8266 foi muito difundido devido
à essas versatilidades. Com a bagagem tecnológica adquirida e
com a garantia do sucesso do ESP8266, a Espressif lançou em
2016 um outro Microcontrolador com mais recursos além do WIFI,
com Bluetooth também – o ESP32.

Esse são os tópicos do Tutorial – Conhecendo o ESP32 –

Introdução :
Características do Chip ESP32
Características dos Módulos ESP32
Placas de desenvolvimento ESP32
Links importantes de referência do ESP32

Características do Chip ESP32

Esse ESP32 é um super chip ! Ele possui dois
Microprocessadores Xtensa® 32-bit LX6 com até 600 DMIPS
(velocidade de processamento). A frequência do clock pode ser de
até 240 MHz, dependendo do modelo. A frequência mais comum é
160 MHz ( 10 vezes o clock do Arduino Uno).

memória ROM interna de 448K Bytes (para Boot e Core)

memória RAM estática interna de 520K Bytes
Memória externa (total 4) – suporte para até 16M Bytes Flash e
16M Bytes SRAM
1 K Bit de Fusíveis eletrônicos (para segurança e criptografia)
Real Time Clock com 16K Bytes de SRAM
Interface WIFI 802.11 b/g/n – 802.11 n (2.4 GHz), até 150 Mbps
Interface Bluetooth v4.2 BR/EDR e Bluetooth LE (low energy)
Dois grupos de Timers – 4 timers de 64 Bits
Aceleradores de hardware (criptografia) – AES, SHA, RSA e ECC
Alimentação VCC de 2,3V a 3,6V CC
Consumo de corrente max com WIFI – 240 mA
Periféricos do Chip ESP32

34 × Portas programáveis GPIOs

2 x Conversores ADC SAR 12-bits com até 18 canais
2 × Conversores DAC de 8-bits
10 × sensores de toque
Sensor de Temperatura
4 × interfaces SPI – clock até 40 MHz !
2 × interfaces I2S – clock até 40 MHz !
2 × interfaces I2C – até 5 Mbps
3 × interfaces seriais UART – até 5 Mbps !
1 Host (SD/eMMC/SDIO) para controle de SD Cards
1 Escravo (SDIO/SPI)
Interface Ethernet MAC (necessita acessório)
Interface CAN 2.0
Interface Infra-vermelho (Tx/Rx)
Controle de Motor PWM
Controle de LED PWM até 16 canais
Sensor interno Hall
ESP32 module Datasheet

Diagrama em Blocos do Chip ESP32

ESP32 Block diagram

ESP32 Chip pinout (visto por cima) 48 pinos

Características dos Módulos ESP32

A Espressif desenvolveu alguns tipos de mini-módulos com o Chip
ESP32 – dual core :

ESP-WROOM-32 , 32D e 32U (mais comum)

ESP32-WROVER , WROVER-I, B e ID
ESP32 – PICO-D4
Todos esses módulos possuem uma memória Flash de 4 MBytes,
onde fica armazenado o firmware (código). Os módulos mais
recentes da linha Wrover já vem com uma memória PSRAM( RAM
pseudo estática) de 8 MBytes.

Existem também outros modelos de módulos ESP32, mas com

single core, isto é, com um processador somente. Mas esses
modelos não são comuns aqui no Brasil.

Modelos de módulos ESP32

Módulo ESP32-Wroom-32

Dentro desse módulo temos o Microcontrolador (chip) ESP32, uma

memória Flash de 4M Bytes (FM25Q32), um cristal de Clock (40
MHz) e uma antena embutida. A frequência de 240 MHz é
sintetizada a partir do clock de 40 MHz.

Em relação ao módulo do ESP8266, dá para perceber que o

ESP32 tem muito mais portas (38 pinos no total – incluindo pinos
de I/O e de alimentação).

ESP32-Wroom-32 Datasheet

Pinagem do Módulo ESP32-Wroom-32 (para melhor

visualização, abra a figura em uma nova guia)
Placas de desenvolvimento ESP32
Quando a Espressif lançou o ESP8266, ela só vendia o módulo
sem regulador e sem interface USB-Serial. Isso dificultou para
muitos, o uso desse módulo. Para evitar o mesmo erro, a Espressif
lançou os módulos ESP32 e as placas de desenvolvimento
(Development Boards) também :

ESP32-PICO-KIT
ESP-WROVER-KIT
ESP-WROVER-KIT-VB
ESP32-DevKitC
ESP32-LyraTD-MSC
ESP32-LyraT
Placas de Desenvolvimento do ESP32

Link com mais informações sobre Módulos e Boards de ESP32

ESP32 complete platform

Alguns outros fabricantes, criaram as suas próprias versões de
Placas de Desenvolvimento :

ESP32 DevKit V1 da DOIT

ESP32 – Thing da SparkFun
ESP32 Feather Board da ADAFRUIT
FireBeetle ESP32 da DFRobot
WiPy 3.0 MycroPython da PYCOM
Os Boards mais comuns encontrados aqui no Brasil , usam os
módulos ESP-WROOM-32. Existem dois modelos de placas de
desenvolvimento ESP32 DevKit, uma placa com 30 pinos e a outra
com 38 pinos. As diferenças não são tão importantes, já que na
Placa de 30 pinos não tem disponíveis os pinos para interface com
o SD card ( SD0, SD1, SD2, SD3, CMD e CLK) . Não é
recomendável o uso desses pinos, já que são usados pela
memória Flash do módulo ESP32 !

Placa ESP32 na loja Eletrogate

Toda placa ESP32 DevKit já tem um regulador de 3,3V, um chip de

interface Serial-USB , um conector micro-USB, um LED e botões
de RESET (EN) e de LOAD (BOOT). Pode ser usada similarmente
como se fosse uma placa Arduino.

Usando o diagrama do site www.pighixxx.com, fiz um Pinout da

placa ESP32 DevKit (não foi fabricada pela ESPRESSIF) :

Pinagem da Placa ESP32 DevKit – (38 pinos)

(para melhor visualização, abra a figura em uma nova guia)

O diagrama abaixo é do circuito eletrônico da placa de

desenvolvimento ESP32-DevKit Versão 4 da Espressif.

Diagrama do Board ESP32 DevKit V4

(para melhor visualização, abra a figura em uma nova guia)

Essa placa ESP32 DEVKIT tem um regulador de 3,3V (corrente

max 1A) , que pode ser o chip AMS1117 -3.3. No Datasheet do
ESP32, esta especificado que a corrente fornecida para
alimentação de 3,3V deve ser no mínimo de 500 mA. Portanto
nunca conecte um outro módulo ou dispositivo que consuma mais
do que 0,5 A, para não sobrecarregar esse regulador interno.
Link do Datasheet do REG AMS1117-3.3

A alimentação dessa placa pode ser feita através do próprio

conector USB (5,0V) ou então através do pino 5V ou VIN , com
uma alimentação regulada de 5,0V . Apesar do Regulador
AMS1117 aceitar até 12V na entrada, recomendo que, se for
alimentar a placa através desse pino, use sempre uma fonte
regulada de 5V, pois assim nunca sobre-aquecerá o mesmo !
Evitando um possível defeito no regulador. Não recomendo que
use o pino 3V3 para alimentar a placa com 3,3V . Esse pino é a
saída do regulador de 3,3V e não a entrada. Mas no site da
ESPRESSIF, considera também que a alimentação possa ser
através do pino 3V3. Mas uma observação importante : as opções
de alimentação são mutuamente exclusivas, isto é, somente
poderá usar uma opção (USB, 5V ou 3,3V) . Não use mais de uma
opção, pois poderá danificar algum componente da placa. Não se
esqueça de conectar o GND da fonte no GND da placa.

O Chip da interface Serial-USB é o CP2102 da Silicon Labs. Ele

suporta USB 2.0 com velocidade de até 1 MBps (não suporta USB
3.0). Na placa ESP32 DEVKIT, a alimentação 3,3V do CP2102 é
feita através do regulador AMS1117. Consumo máximo de corrente
é de apenas 26 mA. O CP2102 possui um regulador interno de
3,3V, mas nessa placa esse regulador esta inoperante.

Link do Datasheet do CP2102

Link para download dos drivers do CP2102 para Windows,

Macintosh OSX, Linux e Android :

Link dos Drivers CP2102

Essa é a foto em alta definição da Placa ESP32 DEVKIT (38
pinos) :

(para melhor visualização, abra a figura em uma nova guia)

OBS: O pino G33 na parte superior da imagem esta identificado

incorretamente ! Esta escrito G23, mas o correto é G33 (entre os
pinos G25 e G32) .

Essa é a foto em alta definição da Placa ESP32 DEVKIT (30

pinos) :

(para melhor visualização, abra a figura em uma nova guia)

Botão de RST (ou EN) – dá um pulso LOW no pino EN , reset do

módulo ESP32.

Botão de BOOT – dá um pulso LOW no pino GPIO 0 – permite a

gravação do programa no ESP32.

Observação interessante : Os pinos DTR e RTS do Chip CP2102,

controlam o pino ENA (reset chip ESP32) e o pino GPIO0 (Load
program). Portanto, ao gravar um programa com a IDE Arduino,
não é necessário pressionar o botão de BOOT (Load). Muito
melhor do que no ESP8266 !
Links importantes de referência do ESP32
Conhecendo o ESP32 – Usando Arduino IDE (2)

ESPRESSIF – recursos do ESP32

Forum da ESPRESSIF para o ESP32

The Internet of Things with ESP32

Livros sobre ESP32