Projetos com Raspberry Pi Pico W: 15 ideias com Wi-Fi e Bluetooth
15 projetos com Raspberry Pi Pico W: servidor web, MQTT, relógio NTP, previsão do tempo, Telegram e BLE. Códigos em MicroPython, limites de memória e uma tabela Pico W vs ESP32.
Se você está procurando projetos com Raspberry Pi Pico W, esta lista traz 15 projetos realistas que vão do fácil ao difícil e exploram os recursos de Wi-Fi e Bluetooth da placa. Alguns exemplos: um servidor web que liga um LED pelo celular, um relógio NTP que pega a hora da internet, uma estação que publica dados de sensores por MQTT, um alarme que manda uma mensagem no Telegram quando uma porta abre e um sensor de temperatura BLE que você lê pelo celular. Todos os projetos rodam com o mesmo código no Pico W e no novo Pico 2 W.
Reunimos em uma tabela os componentes, o tipo de conexão e a dificuldade de cada projeto, e incluímos o código MicroPython completo dos cinco mais importantes. Depois disso, você encontra os limites de memória do Pico W no MicroPython, os erros mais comuns e uma tabela comparativa mostrando quais projetos ficam melhores no Pico W e quais no ESP32. Se esta é a primeira vez que você usa a placa, dê uma olhada antes em o que é Raspberry Pi Pico.

Pico W e Pico 2 W: qual é a diferença?
O Pico W é o Pico clássico com um chip sem fio Infineon CYW43439 a mais: ele oferece Wi-Fi de 2,4 GHz (802.11n) e Bluetooth 5.2 (Classic e BLE). O Pico 2 W combina o mesmo chip sem fio com o processador RP2350, mais potente; a RAM dobra e a memória flash sobe para 4 MB. A pinagem, o tamanho e a maior parte do código MicroPython são iguais nas duas placas. Como o chip sem fio usa alguns pinos internos, o LED integrado não fica mais no GP25, e sim no próprio chip sem fio, e você o controla com Pin("LED").
| Característica | Pico W | Pico 2 W |
|---|---|---|
| Processador | RP2040, 2 × Cortex-M0+, 133 MHz | RP2350, 2 × Cortex-M33 (ou RISC-V), 150 MHz |
| RAM | 264 KB | 520 KB |
| Flash | 2 MB | 4 MB |
| Sem fio | CYW43439: Wi-Fi 4 de 2,4 GHz, Bluetooth 5.2 | CYW43439: Wi-Fi 4 de 2,4 GHz, Bluetooth 5.2 |
| GPIO / ADC | 26 GPIO, 3 entradas analógicas (12 bits) | 26 GPIO, 3 entradas analógicas (12 bits) |
| LED integrado | Pin("LED") | Pin("LED") |
| Firmware MicroPython | RPI_PICO_W | RPI_PICO2_W |
Antes de começar: MicroPython e bibliotecas
- Grave o firmware certo: use o arquivo UF2 do MicroPython chamado RPI_PICO_W para o Pico W e RPI_PICO2_W para o Pico 2 W. O firmware do Pico comum não tem o módulo network, e o código de Wi-Fi falha com “no module named network”.
- Use o Thonny: no Thonny, escolha “MicroPython (Raspberry Pi Pico)” no canto inferior direito; ele executa o código, copia arquivos para a placa e sincroniza o relógio da placa com o do seu computador. Para os comandos básicos do MicroPython, veja o guia fundamentos de MicroPython.
- Instale pacotes extras com o mip: depois de conectar ao Wi-Fi, digite import mip; mip.install("umqtt.simple") ou mip.install("aioble") no Shell para baixar o pacote direto na placa. O menu Ferramentas > Gerenciar pacotes do Thonny faz a mesma coisa.
- Só 2,4 GHz: o Pico W não consegue entrar em redes de 5 GHz; se o seu roteador transmite as duas bandas com o mesmo nome, a conexão pode ficar instável.
- Alimentação: enquanto o Wi-Fi transmite, o pico de corrente pode passar de 100 mA. Use um bom cabo USB e um adaptador que forneça pelo menos 500 mA.
| Módulo | Para que serve | Já vem incluído? |
|---|---|---|
| network | Conexão Wi-Fi, ponto de acesso, busca de redes | Sim (no firmware W) |
| socket / asyncio | Servidor web, UDP, tarefas simultâneas | Sim |
| requests | Requisições HTTP e HTTPS, JSON | Sim |
| ntptime | Obter a hora pela internet | Sim |
| bluetooth | BLE de baixo nível | Sim |
| aioble | BLE fácil: serviços, características, advertising | Depende da versão; se não vier, mip.install("aioble") |
| umqtt.simple | Cliente MQTT | Depende da versão; se não vier, mip.install("umqtt.simple") |
O código de conexão Wi-Fi que você vai usar em todos os projetos
Salve o arquivo abaixo no Pico W pelo Thonny com o nome wifi.py. Assim, em todos os outros projetos basta escrever import wifi e wifi.connect(). O LED integrado pisca enquanto conecta e fica aceso depois de conectado; é o jeito mais fácil de ver o estado da conexão quando a placa não está ligada ao computador.
1# wifi.py: Pico W'ye bu adla kaydet / save it to the Pico W with this name
2import network, time
3from machine import Pin
4
5SSID = "AgAdi" # Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
6PASSWORD = "Sifre123" # Wi-Fi şifren / your Wi-Fi password
7led = Pin("LED", Pin.OUT) # Pico W ve Pico 2 W dahili LED / onboard LED
8
9
10def connect(timeout=20):
11 network.country("TR") # ülke kodu: kanal ve güç sınırları / country code
12 wlan = network.WLAN(network.STA_IF)
13 wlan.active(True)
14 if not wlan.isconnected():
15 wlan.connect(SSID, PASSWORD)
16 for _ in range(timeout * 2):
17 if wlan.status() < 0 or wlan.status() == 3:
18 break
19 led.toggle() # bağlanırken yanıp söner / blinks while connecting
20 time.sleep(0.5)
21 if wlan.status() != 3:
22 led.off()
23 raise RuntimeError("Wi-Fi hatasi / error: %d" % wlan.status())
24 led.on() # bağlandı / connected
25 print("IP:", wlan.ifconfig()[0], "RSSI:", wlan.status("rssi"), "dBm")
26 return wlanwlan.status() informa em que etapa a conexão está: 3 significa conectado com endereço IP, 1 conectando, −2 rede não encontrada, −3 senha errada e −1 falha por outro motivo. Assim que o código vê um valor abaixo de 0, ele para de esperar e mostra o erro com clareza. RSSI é a intensidade do sinal: −50 dBm é muito bom, −70 dBm é aceitável, e −80 dBm ou menos é uma conexão sujeita a quedas. A linha network.country("TR") ajusta os canais e a potência do chip sem fio às regras do país; se você estiver em outro lugar, use o código de duas letras do seu país (no Brasil, “BR”).
15 projetos com Raspberry Pi Pico W: tabela
| # | Projeto | Conexão | Componentes extras | Dificuldade |
|---|---|---|---|---|
| 1 | Conectar ao Wi-Fi e mostrar o estado no LED integrado | Wi-Fi | Nenhum | Fácil |
| 2 | Servidor web que controla um LED e um relé pelo celular | Wi-Fi, HTTP | LED, módulo relé | Fácil |
| 3 | Painel de temperatura atualizado ao vivo no navegador | Wi-Fi, HTTP + JSON | Sensor interno ou DHT22 | Médio |
| 4 | Relógio NTP que pega a hora da internet (com OLED) | Wi-Fi, NTP | OLED de 0,96" | Fácil |
| 5 | Modo ponto de acesso (AP) para controlar sem roteador | Wi-Fi AP | Nenhum | Médio |
| 6 | Scanner de redes Wi-Fi e medidor de sinal | Wi-Fi | OLED (opcional) | Fácil |
| 7 | Publicar dados de sensor por MQTT | Wi-Fi, MQTT | Sensor interno | Médio |
| 8 | Sensor que entra no Home Assistant por MQTT | Wi-Fi, MQTT | DHT22 | Médio |
| 9 | Display de previsão do tempo | Wi-Fi, HTTPS + JSON | OLED | Médio |
| 10 | Alerta no Telegram quando uma porta abre | Wi-Fi, HTTPS | Chave reed ou PIR | Médio |
| 11 | Troca de mensagens entre duas placas Pico W por UDP | Wi-Fi, UDP | Segundo Pico W, botão, LED | Médio |
| 12 | Registro de dados e gráficos no ThingSpeak | Wi-Fi, HTTP | Qualquer sensor | Fácil |
| 13 | Sensor de temperatura BLE lido pelo celular | BLE | Nenhum | Médio |
| 14 | Controle BLE de um LED ou servo pelo celular | BLE (serviço UART) | LED ou servo | Difícil |
| 15 | Teclado Bluetooth e controle para apresentações | BLE HID (Arduino IDE) | 2 botões | Difícil |
Nível 1: projetos de Wi-Fi e web (1–6)
O primeiro projeto é o próprio wifi.py acima; o LED piscando enquanto conecta e ficando aceso depois de conectado é um indicador pequeno, mas muito prático. No segundo projeto o Pico W vira um servidor web: quando você abre o endereço IP da placa no celular, os botões LIGAR e DESLIGAR da página enviam /on ou /off no endereço; o código lê isso e liga ou desliga o LED ou o relé. Um exemplo completo com socket e a ligação do relé estão no guia servidor web com Pico W. No terceiro projeto a página não recarrega sozinha; um pequeno JavaScript no navegador busca um JSON em /data a cada dois segundos, e o Pico W lê o sensor de temperatura interno (ADC4) ou um DHT22 e entrega o valor ali. Assim a página se atualiza ao vivo, sem piscar.
O quarto projeto é um relógio de mesa que pega a hora da internet. ntptime.settime() acerta o relógio interno da placa em UTC; para a Turquia basta somar três horas (para Brasília, subtrair três), enquanto em países com horário de verão você vai precisar calcular a regra no código. No quinto projeto o Pico W cria a própria rede em vez de entrar em um roteador: você conecta o celular à rede “PicoW” criada com network.WLAN(network.AP_IF) e abre a página de controle em 192.168.4.1; isso é muito útil no jardim ou na escola, onde não há roteador. O sexto projeto usa wlan.scan() para listar as redes próximas com seus canais e intensidades de sinal; leve o Pico W a diferentes cantos da casa e confira o RSSI para decidir onde instalar um sensor.
1import time, ntptime
2import wifi
3
4UTC_OFFSET = 3 * 3600 # Türkiye UTC+3; kendi saat dilimin / your own time zone
5wifi.connect()
6ntptime.settime() # dahili saati UTC'ye ayarla / set the internal clock to UTC
7
8while True:
9 t = time.localtime(time.time() + UTC_OFFSET)
10 print("%02d:%02d:%02d %02d.%02d.%04d" % (t[3], t[4], t[5], t[2], t[1], t[0]))
11 if t[4] == 0 and t[5] == 0: # her saat başı yeniden eşitle / resync every hour
12 try:
13 ntptime.settime()
14 except OSError:
15 pass
16 time.sleep(1)Nível 2: serviços de internet: MQTT, previsão do tempo, Telegram (7–12)
MQTT é a forma mais comum de dispositivos IoT se comunicarem: o Pico W envia a leitura para um tópico (topic) em um servidor broker, e o celular, o computador ou o Home Assistant inscrito nesse tópico recebe a mensagem na hora. Você não precisa saber o endereço IP da placa nem abrir portas no roteador. No sétimo projeto publicamos o sensor de temperatura interno a cada dez segundos; no oitavo, um sensor DHT22 que envia uma mensagem MQTT Discovery com a mesma lógica aparece sozinho no Home Assistant. A configuração do lado do Home Assistant está explicada no guia ESP32 com MQTT e Home Assistant e vale do mesmo jeito para o Pico W.
1import time
2from machine import ADC
3from umqtt.simple import MQTTClient
4import wifi
5
6BROKER = "test.mosquitto.org" # kendi broker'ın / your own broker
7TOPIC = b"bluegrays/picow/sicaklik"
8sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
9
10
11def read_temp():
12 volts = sensor.read_u16() * 3.3 / 65535
13 return 27 - (volts - 0.706) / 0.001721
14
15
16wifi.connect()
17client = MQTTClient("picow-bluegrays", BROKER, keepalive=60)
18client.connect()
19
20while True:
21 msg = "%.1f" % read_temp()
22 client.publish(TOPIC, msg.encode()) # her 10 sn yayınla / publish every 10 s
23 print("gonderildi / sent:", msg)
24 time.sleep(10)O nono projeto é um display de previsão do tempo: o Pico W usa requests para enviar uma requisição HTTPS a um serviço de meteorologia gratuito que não exige chave de API, pega a temperatura e o código do tempo na resposta JSON e escreve tudo no OLED. A memória importa aqui: para manter a resposta pequena, peça só os campos de que você precisa. O décimo projeto é um dos mais úteis em casa: quando uma chave reed na porta abre, o Pico W manda uma mensagem para o seu celular na hora, por meio de um bot do Telegram. Os passos para criar o bot e obter o token e o chat ID estão no guia bot do Telegram com ESP32; no final do mesmo guia há também uma versão mais avançada para o Pico W que aceita comandos.
1import time, requests
2from machine import Pin
3import wifi
4
5TOKEN = "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # BotFather token'ı / token from BotFather
6CHAT_ID = 123456789 # kendi Telegram ID'n / your Telegram ID
7URL = "https://api.telegram.org/bot%s/sendMessage" % TOKEN
8door = Pin(15, Pin.IN, Pin.PULL_UP) # reed röle -> GND; kapı açılınca 1 / reed switch, 1 when open
9
10
11def send(text):
12 try:
13 r = requests.post(URL, json={"chat_id": CHAT_ID, "text": text})
14 r.close() # belleği geri ver / free the memory
15 except OSError as e:
16 print("gonderilemedi / failed:", e)
17
18
19wifi.connect()
20last = door.value()
21while True:
22 now = door.value()
23 if now != last:
24 send("Kapi acildi / door opened" if now else "Kapi kapandi / door closed")
25 last = now
26 time.sleep_ms(100)No décimo primeiro projeto, duas placas Pico W na mesma rede trocam pacotes UDP: aperte um botão em uma e o LED da outra acende. O UDP funciona sem estabelecer conexão, por isso é muito rápido e cabe em poucas linhas, mas não garante a entrega; para comandos importantes, é um bom hábito esperar uma resposta curta de “recebi” do outro lado. No décimo segundo projeto as leituras são enviadas a cada 20 segundos, com uma requisição HTTP, para um serviço de IoT gratuito como o ThingSpeak; o serviço guarda os dados e desenha gráficos prontos no navegador. Lembre-se de que os planos gratuitos limitam a frequência de envio.
Nível 3: projetos com Bluetooth (13–15)
No MicroPython, o Bluetooth do Pico W é usado como BLE (Bluetooth Low Energy). Um dispositivo BLE oferece um ou mais serviços, e cada serviço contém características que podem ser lidas ou enviar notificações. No décimo terceiro projeto usamos o serviço padrão Environmental Sensing (0x181A) e a característica Temperature (0x2A6E), assim apps BLE genéricos como o nRF Connect mostram o valor direto em °C. O código depende do pacote aioble; se a sua placa não tiver, instale antes com o mip. Os conceitos de BLE são explicados em detalhes no guia ESP32 com Bluetooth e BLE.
1import asyncio, struct, bluetooth, aioble
2from machine import ADC
3
4ENV_SENSE = bluetooth.UUID(0x181A) # Environmental Sensing servisi / service
5TEMP_CHAR = bluetooth.UUID(0x2A6E) # Temperature karakteristiği / characteristic
6sensor = ADC(4)
7
8service = aioble.Service(ENV_SENSE)
9temp_char = aioble.Characteristic(service, TEMP_CHAR, read=True, notify=True)
10aioble.register_services(service)
11
12
13def read_temp():
14 volts = sensor.read_u16() * 3.3 / 65535
15 return 27 - (volts - 0.706) / 0.001721
16
17
18async def measure():
19 while True:
20 t = int(read_temp() * 100) # 0,01 °C birimi / unit of 0.01 °C
21 temp_char.write(struct.pack("<h", t), send_update=True)
22 await asyncio.sleep(2)
23
24
25async def advertise():
26 while True:
27 async with await aioble.advertise(
28 250_000, name="PicoW-Temp", services=[ENV_SENSE], appearance=768
29 ) as connection:
30 print("baglandi / connected:", connection.device)
31 await connection.disconnected(timeout_ms=None)
32
33
34async def main():
35 await asyncio.gather(measure(), advertise())
36
37
38asyncio.run(main())No décimo quarto projeto o Pico W imita um formato BLE muito usado chamado Nordic UART Service (NUS); textos como “on”, “off” ou “90” enviados de um app de terminal BLE no celular acendem o LED ou giram o servo no Pico W. O décimo quinto projeto é escrito na Arduino IDE: a biblioteca KeyboardBLE do core Raspberry Pi Pico/RP2040 de Earle Philhower faz o Pico W aparecer para computadores e celulares como um teclado Bluetooth. Depois de ativar a pilha Bluetooth no menu Ferramentas, você pode montar um controle com dois botões que avança e volta os slides em apresentações.
Limites de memória e estabilidade
A memória que o MicroPython pode usar no Pico W é só uma parte dos 264 KB de RAM da placa; o firmware, o driver de Wi-Fi e os buffers de rede usam o resto. Isso sobra para projetos simples, mas quando requisições HTTPS, respostas JSON grandes e páginas HTML longas se juntam, pode aparecer um MemoryError. Cada conexão HTTPS reserva temporariamente 30–50 KB para a criptografia, e uma resposta JSON de 20 KB ocupa memória duas vezes, primeiro como texto e depois como dicionário. A RAM em dobro do Pico 2 W alivia muito esse limite.
| Recurso | Pico W | Pico 2 W | Observação |
|---|---|---|---|
| RAM total | 264 KB | 520 KB | Parte dela é usada pelo firmware e pelo Wi-Fi |
| Memória livre na inicialização (gc.mem_free) | Cerca de 150–190 KB | Cerca de 400 KB ou mais | Varia com a versão; meça na sua placa |
| Flash / sistema de arquivos | 2 MB / cerca de 850 KB | 4 MB / mais de 2 MB | Código, HTML e arquivos de log ficam aqui |
| Uma conexão HTTPS | 30–50 KB temporários | 30–50 KB temporários | Libere com r.close() ao terminar |
| Wi-Fi e BLE juntos | Funciona, a memória fica ainda mais apertada | Roda com folga | Teste cada um sozinho primeiro, depois combine |
Pico W ou ESP32? Qual projeto combina com qual placa?
| Tipo de projeto | Pico W | ESP32 | Recomendação |
|---|---|---|---|
| Servidor web simples, controle de LED e relé | Faz com facilidade | Faz com facilidade | Qualquer um; Pico W se você está aprendendo MicroPython |
| Sensor MQTT e Home Assistant | Funciona bem | Muito bom, sem código com ESPHome | ESP32 |
| Câmera e transmissão de vídeo | Não disponível | Disponível com o ESP32-CAM | ESP32 |
| Sensor que funciona meses com bateria | A corrente em repouso continua alta no MicroPython | Nível de microampères com deep sleep | ESP32 |
| Áudio Bluetooth Classic (caixa de som A2DP) | Suporte limitado | Suportado no ESP32 clássico | ESP32 |
| Teclado BLE, controle remoto | Fácil com o arduino-pico | Fácil com bibliotecas | Qualquer um |
| WS2812B, temporização precisa, protocolos personalizados | Muito poderoso com PIO | Bom com RMT | Pico W |
| Medição analógica | 3 canais, ADC linear de 12 bits | Muitos canais, mas não linear; ADC2 inutilizável com o Wi-Fi ligado | Pico W se poucos canais bastam |
Resumindo: o Pico W é excelente para aprender MicroPython, para trabalhos de hardware que exigem temporização precisa e para projetos de rede simples; é bem documentado, estável e muito fácil de programar com o Thonny. Se você precisa de câmera, longa autonomia de bateria, áudio Bluetooth ou um ecossistema pronto como o ESPHome, o ESP32 é a melhor escolha. Se quiser comparar as versões para ESP32 de projetos como relógio de internet, servidor web e display de previsão do tempo, o guia relógio NTP com ESP32 é um bom ponto de partida.
Erros comuns e soluções
- ImportError: no module named 'network': a placa está com o firmware do Pico comum. Grave o arquivo UF2 RPI_PICO_W ou RPI_PICO2_W.
- O LED integrado não acende: foi usado Pin(25). No Pico W e no Pico 2 W, a forma correta é Pin("LED", Pin.OUT).
- wlan.status() retorna −2: rede não encontrada; confira o nome da rede, incluindo maiúsculas e minúsculas, e verifique se a banda de 2,4 GHz está ligada.
- OSError: [Errno 98] EADDRINUSE: a porta 80 continua ocupada depois de reiniciar o servidor web. Faça uma reinicialização suave com Ctrl+D ou use SO_REUSEADDR no socket.
- MemoryError: JSON ou HTML grandes encheram a memória. Diminua as respostas, use r.close() e gc.collect() e, se precisar, passe para um Pico 2 W.
- O código roda pelo computador, mas não com um adaptador: o arquivo não foi salvo como main.py, ou o código depende do relógio que o Thonny acertou. Dê ao arquivo o nome main.py e acerte o relógio você mesmo com o ntptime.
Depois de fazer esses 15 projetos, você terá usado Wi-Fi, HTTP, NTP, MQTT, UDP e BLE com o Pico W e criado a base para projetar seus próprios dispositivos IoT. No app BlueGrays você encontra esquemas do circuito e códigos passo a passo de projetos básicos com Pico, como piscar um LED, semáforo, controle de brilho de LED com PWM e ciclo de cores RGB, além de projetos com ESP32, como conexão Wi-Fi, relógio NTP e servidor web, para completar cada projeto também do lado do hardware.
Perguntas frequentes
O que dá para fazer com um Raspberry Pi Pico W?
Com um Pico W você pode montar servidores web controlados pelo celular, relógios NTP que pegam a hora da internet, sensores que enviam dados por MQTT, alarmes com alertas no Telegram e dispositivos que conversam com o celular por BLE. Graças aos 26 pinos GPIO, é fácil acrescentar sensores, relés, displays e LEDs. O código é escrito em MicroPython ou na Arduino IDE.
Qual é a diferença entre o Pico W e o Pico 2 W?
Os dois usam o mesmo chip de Wi-Fi e Bluetooth CYW43439. O Pico 2 W tem o processador RP2350, mais rápido, o dobro de RAM (520 KB) e 4 MB de flash. A pinagem é idêntica e a maior parte do código MicroPython roda sem alterações.
O Pico W conecta a uma rede Wi-Fi de 5 GHz?
Não, o Pico W e o Pico 2 W só se conectam a redes de 2,4 GHz. Se o seu roteador transmite as duas bandas com o mesmo nome, a conexão pode ficar instável; dar um nome próprio à banda de 2,4 GHz ou testar com o ponto de acesso de 2,4 GHz do celular costuma resolver.
Por que o LED integrado do Pico W não funciona com Pin(25)?
No Pico W, o GP25 é usado como linha de seleção do chip sem fio, e o LED integrado passou para o próprio chip sem fio. A forma correta é Pin("LED", Pin.OUT). Ela funciona do mesmo jeito no Pico clássico, no Pico W e no Pico 2 W.
O Bluetooth do Pico W é suportado no MicroPython?
Sim, o MicroPython suporta BLE no Pico W. O módulo bluetooth de baixo nível já vem no firmware e, para um uso mais fácil, o pacote aioble pode ser instalado com o mip. Recursos como áudio Bluetooth Classic, porém, não são suportados no MicroPython.
Para um projeto IoT, é melhor o Pico W ou o ESP32?
Para aprender MicroPython, fazer projetos de rede simples e trabalhos que exigem temporização precisa, o Pico W é uma ótima escolha. Se você precisa de câmera, meses de autonomia de bateria, áudio Bluetooth ou um ecossistema pronto como o ESPHome, o ESP32 é mais indicado. Os dois dão conta com folga de projetos simples de servidor web e MQTT.
Projetos para montar depois desta leitura
Ver todos os projetos
Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
O primeiro projeto da série Raspberry Pi Pico! Fazemos o LED verde integrado piscar para verificar se a placa funciona — um primeiro experimento no estilo clássico "Hello World". SEM componentes externos, apenas o Pico e um cabo USB. O código foi escrito em MicroPython (a linguagem com suporte oficial da Raspberry Pi Foundation). Aprenda a usar a classe machine.Pin, o modo Pin.OUT, os métodos led.on()/off() e time.sleep() no Thonny IDE.

Raspberry Pi Pico: controle de LED externo (protoboard)
O próximo passo depois do LED integrado do Pico: conectar um LED externo na protoboard e controlá-lo pelo pino GP14. Você aprende a usar qualquer pino GPIO do Pico como saída, a polaridade do LED (terminal longo = ânodo/+, terminal curto = cátodo/–) e por que um resistor limitador de corrente (220Ω) é indispensável. Sem o resistor, passa corrente demais pelo LED e ele pode queimar.

Raspberry Pi Pico: semáforo (3 LEDs em sequência)
Simulamos um semáforo real com LEDs vermelho, amarelo e verde — o primeiro projeto com 3 LEDs da série Pico! Verde por 4 segundos: "siga"; amarelo por 1,5 segundo: "prepare-se"; vermelho por 3 segundos: "pare"; e vermelho+amarelo por 1 segundo: "saída" (padrão de semáforo europeu). Aprenda definição de funções (def all_off()), lógica de máquina de estados (sequência) e sincronização de vários GPIOs.

Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
O LED não só pisca — ele respira! Com o PWM (modulação por largura de pulso) do Raspberry Pi Pico, o brilho do LED aumenta e diminui lentamente, como a luz de um MacBook em repouso. Aprenda a usar a classe machine.PWM, duty_u16() (brilho de 16 bits, de 0–65535), frequência PWM (freq(1000) — 1.000 ciclos de ligar/desligar por segundo, sem cintilação visível), laços com passos usando range() (crescentes e decrescentes) e saída semelhante à analógica em um pino digital.

Ciclo de cores com LED RGB no Raspberry Pi Pico (PWM de 3 canais)
Um LED, milhões de cores! Um LED RGB guarda, na verdade, três LEDs: vermelho, verde e azul. Com os 3 canais PWM do Pico, você ajusta o brilho de cada um e as cores se misturam: vermelho + verde = amarelo, verde + azul = ciano, os três = branco. O LED passa por 8 cores, meio segundo cada, e você aprende a usar vários canais PWM, criar uma função com def set_color(...) e converter valores de 8 para 16 bits (x257), a mesma ideia usada nas telas.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

Hora exata pela internet com ESP32 e NTP
O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

