Tutorial Completo: Programação do ESP32

com MicroPython

Índice

1. Introdução
2. Materiais Necessários
3. Instalação e Configuração do MicroPython no ESP32
4. Configuração do Thonny IDE
5. Primeiros Passos com MicroPython
6. Controle de GPIOs
7. Comunicação Serial
8. PWM e Controle de Motores
9. Sensores Analógicos
10. WiFi e Conexão com Internet
11. Projetos Práticos
12. Solução de Problemas

Introdução

O ESP32 é um microcontrolador poderoso com WiFi e Bluetooth integrados, perfeito para

projetos IoT. O MicroPython é uma implementação leve do Python 3 para microcontroladores,
tornando a programação acessível e divertida.

Vantagens do MicroPython no ESP32:

Sintaxe simples e intuitiva

REPL interativo para testes rápidos
Gerenciamento automático de memória
Bibliotecas para periféricos comuns
Ideal para prototipagem rápida

Materiais Necessários
Hardware:
Placa ESP32 (qualquer modelo: DOIT ESP32 DevKit V1, NodeMCU-32S, etc.)
Cabo USB (micro-USB)
LEDs, resistores (220Ω-1kΩ)
Botões/pushbuttons
Protoboard e jumpers
Sensores diversos (opcional)

Software:
Thonny IDE (última versão)
Driver USB-Serial (CP210x ou CH340, dependendo da placa)

Instalação e Configuração do MicroPython no ESP32

Passo 1: Instalar os drivers USB

# Para chips CP210x (mais comum)

Windows: Baixe de [Link]
drivers
Linux: Geralmente já incluso
macOS: Incluso ou via Homebrew

Passo 2: Baixar o firmware MicroPython

1. Acesse [Link]/download/esp32/
2. Baixe a versão mais recente (arquivo .bin)

Passo 3: Instalar o [Link]

# Instalar via pip

pip install esptool

# Verificar instalação
[Link] version

Passo 4: Apagar a memória flash

 # Substitua COM3 pela porta correta
# Windows:
[Link] --port COM3 erase_flash

# Linux/macOS:
[Link] --port /dev/ttyUSB0 erase_flash

Passo 5: Gravar o firmware

# Windows:
[Link] --chip esp32 --port COM3 write_flash -z 0x1000
caminho_para_firmware.bin

# Linux/macOS:
[Link] --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000
caminho_para_firmware.bin

Configuração do Thonny IDE

Instalação

# Baixe de [Link]
Windows: Instalador .exe
Linux: sudo apt install thonny # ou via pip
macOS: .pkg installer

Configuração Inicial
1. Abra o Thonny

2. Configure o interpretador:

Menu: Run → Configure interpreter

Selecione "MicroPython (ESP32)"
Escolha a porta correta (COM3, /dev/ttyUSB0, etc.)
Clique em "Install or update firmware" se necessário

3. Verifique a conexão:

Abra o shell (View → Shell)

 Deve aparecer >>> indicando REPL ativo
Digite: print("Hello ESP32!")

Primeiros Passos com MicroPython

Hello World e Blink

# Seu primeiro programa

print("Olá, ESP32!")

# Blink básico
from machine import Pin
import time

led = Pin(2, [Link]) # GPIO2 geralmente tem LED interno

while True:
[Link](1) # Liga LED
[Link](0.5)
[Link](0) # Desliga LED
[Link](0.5)

Entendendo o REPL

# REPL - Read-Eval-Print Loop

# Testes rápidos sem precisar salvar

>>> import machine

>>> [Link]() # Mostra frequência do processador
>>> import esp
>>> esp.flash_size() # Tamanho da flash
>>> help('modules') # Lista módulos disponíveis

Controle de GPIOs

Configuração Básica de Pinos

 from machine import Pin
import time

# Configuração de saída
led_vermelho = Pin(15, [Link])
led_verde = Pin(16, [Link])

# Configuração de entrada com pull-up

botao = Pin(0, [Link], Pin.PULL_UP)

# Controle básico
led_vermelho.on() # Liga
led_vermelho.off() # Desliga
led_verde.toggle() # Inverte estado

# Leitura de botão
if [Link]() == 0: # PULL_UP: 0 = pressionado
print("Botão pressionado!")

Interrupções (IRQ)

from machine import Pin

import time

contador = 0

def botao_pressionado(pin):
global contador
contador += 1
print(f"Botão pressionado {contador} vezes")

# Configurar interrupção
botao = Pin(0, [Link], Pin.PULL_UP)
[Link](trigger=Pin.IRQ_FALLING, handler=botao_pressionado)

# Loop principal
while True:
[Link](1)

Comunicação Serial

UART
 from machine import UART
import time

# Configurar UART
uart = UART(1, baudrate=9600, tx=17, rx=16)

# Enviar dados
[Link]("Hello Serial!\n")

# Receber dados
if [Link]():
dados = [Link]()
print(dados)

I2C - Comunicação com sensores

from machine import Pin, I2C

import time

# Configurar I2C
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=100000)

# Escanear dispositivos
dispositivos = [Link]()
print("Dispositivos I2C:", [hex(addr) for addr in dispositivos])

# Exemplo com sensor BMP280 (pressão/temperatura)

import bmp280 # Biblioteca externa
sensor = bmp280.BMP280(i2c)
temperatura = [Link]
pressao = [Link]

SPI
 from machine import Pin, SPI
import time

# Configurar SPI
spi = SPI(1, baudrate=1000000, polarity=0, phase=0,
sck=Pin(18), mosi=Pin(23), miso=Pin(19))
cs = Pin(5, [Link])

# Comunicação
[Link](0)
[Link](b'comando')
dados = [Link](10)
[Link](1)

PWM e Controle de Motores

LED com efeito fade

from machine import Pin, PWM

import time

# Configurar PWM no pino 2

led = PWM(Pin(2), freq=1000)

# Efeito fade
while True:
for duty in range(0, 1024):
[Link](duty)
time.sleep_ms(2)
for duty in range(1023, -1, -1):
[Link](duty)
time.sleep_ms(2)

Controle de servo motor

 from machine import Pin, PWM
import time

# Servo no pino 13
servo = PWM(Pin(13), freq=50) # 50Hz para servo

def set_servo_angle(angle):
# Converter ângulo (0-180) para duty cycle (40-115)
duty = int(40 + (angle * 75 / 180))
[Link](duty)

# Testar movimento
for angulo in range(0, 181, 30):
set_servo_angle(angulo)
[Link](1)

Sensores Analógicos

Leitura de potenciômetro

from machine import Pin, ADC

import time

# Configurar ADC
pot = ADC(Pin(34))
[Link](ADC.ATTN_11DB) # Leitura até 3.6V
[Link](ADC.WIDTH_12BIT) # Resolução 12 bits (0-4095)

while True:
valor = [Link]()
voltagem = valor * 3.3 / 4095
print(f"Valor ADC: {valor}, Voltagem: {voltagem:.2f}V")
[Link](0.5)

Sensor de temperatura interno

 import esp32
import time

while True:
temp = esp32.raw_temperature() # Em Celsius
print(f"Temperatura interna: {temp}°C")
[Link](1)

WiFi e Conexão com Internet

Conectar ao WiFi

import network
import time

def conectar_wifi(ssid, senha):

wlan = [Link](network.STA_IF)
[Link](True)

if not [Link]():
print("Conectando ao WiFi...")
[Link](ssid, senha)

# Aguardar conexão
timeout = 10
while not [Link]() and timeout > 0:
[Link](1)
timeout -= 1
print(".", end="")

if [Link]():
print("\nConectado!")
print("IP:", [Link]()[0])
return wlan
else:
print("Falha na conexão")
return None

# Usar
wifi = conectar_wifi("SeuWiFi", "SuaSenha")

Cliente HTTP simples

 import urequests
import network

# Após conectar ao WiFi

response = [Link]("[Link]
print("Status:", response.status_code)
print("Resposta:", [Link])
[Link]()

# POST request
dados = {"nome": "ESP32", "valor": 123}
response = [Link]("[Link] json=dados)
print([Link]())

Servidor Web básico

 import network
import socket

# Configurar WiFi
wlan = [Link](network.STA_IF)
[Link](True)
[Link]("SSID", "senha")

# Aguardar conexão
while not [Link]():
pass

print("Conectado! IP:", [Link]()[0])

# Criar servidor
addr = [Link]('[Link]', 80)[0][-1]
s = [Link]()
[Link](addr)
[Link](1)

print("Servidor rodando...")

while True:
cl, addr = [Link]()
request = [Link](1024)

html = """<!DOCTYPE html>

<html>
<head><title>ESP32 Web Server</title></head>
<body>
<h1>Olá do ESP32!</h1>
<p>Você está conectado ao servidor web.</p>
</body>
</html>"""

[Link]('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')

[Link](html)
[Link]()

Projetos Práticos

Projeto 1: Estação Meteorológica

from machine import Pin, I2C, ADC
import dht
import time
import network
import urequests

# Sensores
dht_sensor = dht.DHT22(Pin(4))
luminosidade = ADC(Pin(34))
[Link](ADC.ATTN_11DB)

# Conectar WiFi
def conecta_wifi():
wlan = [Link](network.STA_IF)
[Link](True)
[Link]("SSID", "senha")

while not [Link]():

[Link](1)
return [Link]()[0]

# Loop principal
ip = conecta_wifi()
print(f"IP: {ip}")

while True:
try:
# Ler sensores
dht_sensor.measure()
temp = dht_sensor.temperature()
umid = dht_sensor.humidity()
luz = [Link]()

# Mostrar dados
print(f"Temperatura: {temp}°C")
print(f"Umidade: {umid}%")
print(f"Luminosidade: {luz}")

# Enviar para serviço web (exemplo)

dados = {
"temp": temp,
"umid": umid,
"luz": luz
}

# Descomentar para enviar

# response = [Link]("[Link] json=dados)
 # [Link]()

[Link](10)

except Exception as e:
print("Erro:", e)
[Link](5)

Projeto 2: Controle Remoto via Web

from machine import Pin, PWM
import network
import socket
import json

# Atuadores
led = Pin(2, [Link])
servo = PWM(Pin(13), freq=50)
rele = Pin(15, [Link])

# Configurar WiFi AP
ap = [Link](network.AP_IF)
[Link](True)
[Link](essid="ESP32-Control", authmode=network.AUTH_WPA_WPA2_PSK,
password="12345678")

print("AP IP:", [Link]()[0])

# Servidor web
def web_page():
html = """
<!DOCTYPE html>
<html>
<head>
<title>ESP32 Control</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
button { padding: 10px 20px; margin: 5px; font-size: 16px; }
.on { background-color: #4CAF50; color: white; }
.off { background-color: #f44336; color: white; }
</style>
</head>
<body>
<h1>Controle ESP32</h1>
<h2>LED</h2>
<button class="on" onclick="fetch('/led/on')">Ligar</button>
<button class="off" onclick="fetch('/led/off')">Desligar</button>

<h2>Servo</h2>
<input type="range" min="0" max="180"
onchange="fetch('/servo/'+[Link])">

<h2>Relé</h2>
<button class="on" onclick="fetch('/rele/on')">Ligar</button>
<button class="off" onclick="fetch('/rele/off')">Desligar</button>
</body>
</html>
 """
return html

s = [Link](socket.AF_INET, socket.SOCK_STREAM)
[Link](('', 80))
[Link](5)

while True:
conn, addr = [Link]()
request = [Link](1024).decode()

# Processar comandos
if '/led/on' in request:
[Link]()
elif '/led/off' in request:
[Link]()
elif '/servo/' in request:
angulo = int([Link]('/servo/')[1].split()[0])
[Link](int(40 + angulo * 75 / 180))
elif '/rele/on' in request:
[Link]()
elif '/rele/off' in request:
[Link]()

response = web_page()
[Link]('HTTP/1.1 200 OK\n')
[Link]('Content-Type: text/html\n')
[Link]('Connection: close\n\n')
[Link](response)
[Link]()

Solução de Problemas

Problemas Comuns e Soluções

1. Não consigo conectar ao ESP32

Verifique drivers USB instalados

Tente outra porta USB
Reinicie o ESP32 (botão EN/RST)

2. Erro ao gravar firmware

 # Tente modos alternativos
[Link] --port COM3 --baud 115200 write_flash -z 0x1000 [Link]
[Link] --port COM3 --before default_reset --after hard_reset
write_flash -z 0x1000 [Link]

3. Bootloop ou travamentos

# Acessar modo seguro

# Pressione e segure BOOT/FLASH enquanto reinicia

# Ou tente reflash completo

[Link] --port COM3 erase_flash
[Link] --port COM3 write_flash -z 0x1000 [Link]

4. Erro de memória

# Verificar memória disponível

import gc
gc.mem_free()
gc.mem_alloc()

# Forçar coleta de lixo

[Link]()

Dicas de Otimização

# Desativar WiFi quando não usado

[Link](False)

# Usar deep sleep para economia de energia

from machine import deepsleep
# deepsleep(10000) # 10 segundos

# Gerenciar memória eficientemente

@[Link] # Decorator para código mais rápido
def funcao_critica():
pass

Recursos Adicionais
Bibliotecas Úteis
[Link]: Cliente MQTT para IoT
urequests: Cliente HTTP simples
ujson: Manipulação JSON
ds18x20: Sensor temperatura DS18B20
neopixel: LEDs endereçáveis

Documentação Oficial
MicroPython ESP32
ESP32 Datasheet
Thonny IDE

Conclusão

Parabéns! Você agora tem uma base sólida para programar o ESP32 com MicroPython.
Comece com projetos simples e aumente gradualmente a complexidade. A comunidade
MicroPython é muito ativa e existem inúmeras bibliotecas disponíveis para sensores e
atuadores.

Próximos passos sugeridos:

Explore IoT com MQTT

Integre com serviços cloud (AWS IoT, Google Cloud)
Crie projetos com display OLED
Desenvolva sistemas de automação residencial
Experimente com comunicação Bluetooth

Lembre-se: a prática é fundamental para o aprendizado. Divirta-se programando seu ESP32!