Guias · 11 min de leitura

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.

Placa microcontroladora Raspberry Pi Pico
A família Raspberry Pi Pico: os modelos W trazem o chip sem fio CYW43439 e a antena na ponta da placa, enquanto a pinagem continua a mesma.

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ísticaPico WPico 2 W
ProcessadorRP2040, 2 × Cortex-M0+, 133 MHzRP2350, 2 × Cortex-M33 (ou RISC-V), 150 MHz
RAM264 KB520 KB
Flash2 MB4 MB
Sem fioCYW43439: Wi-Fi 4 de 2,4 GHz, Bluetooth 5.2CYW43439: Wi-Fi 4 de 2,4 GHz, Bluetooth 5.2
GPIO / ADC26 GPIO, 3 entradas analógicas (12 bits)26 GPIO, 3 entradas analógicas (12 bits)
LED integradoPin("LED")Pin("LED")
Firmware MicroPythonRPI_PICO_WRPI_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óduloPara que serveJá vem incluído?
networkConexão Wi-Fi, ponto de acesso, busca de redesSim (no firmware W)
socket / asyncioServidor web, UDP, tarefas simultâneasSim
requestsRequisições HTTP e HTTPS, JSONSim
ntptimeObter a hora pela internetSim
bluetoothBLE de baixo nívelSim
aiobleBLE fácil: serviços, características, advertisingDepende da versão; se não vier, mip.install("aioble")
umqtt.simpleCliente MQTTDepende 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.

MicroPython
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 wlan

wlan.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”).

Como a senha do Wi-Fi e os tokens ficam escritos no código, apague essas linhas antes de compartilhar o arquivo. Um jeito mais organizado é guardar os dados secretos em um arquivo separado, secrets.py, e deixar só esse arquivo de fora ao compartilhar. Além disso, não coloque metal, pilhas ou feixes de fios acima ou abaixo da área da antena da placa (a ponta oposta à porta USB); o sinal fica bem mais fraco.

15 projetos com Raspberry Pi Pico W: tabela

#ProjetoConexãoComponentes extrasDificuldade
1Conectar ao Wi-Fi e mostrar o estado no LED integradoWi-FiNenhumFácil
2Servidor web que controla um LED e um relé pelo celularWi-Fi, HTTPLED, módulo reléFácil
3Painel de temperatura atualizado ao vivo no navegadorWi-Fi, HTTP + JSONSensor interno ou DHT22Médio
4Relógio NTP que pega a hora da internet (com OLED)Wi-Fi, NTPOLED de 0,96"Fácil
5Modo ponto de acesso (AP) para controlar sem roteadorWi-Fi APNenhumMédio
6Scanner de redes Wi-Fi e medidor de sinalWi-FiOLED (opcional)Fácil
7Publicar dados de sensor por MQTTWi-Fi, MQTTSensor internoMédio
8Sensor que entra no Home Assistant por MQTTWi-Fi, MQTTDHT22Médio
9Display de previsão do tempoWi-Fi, HTTPS + JSONOLEDMédio
10Alerta no Telegram quando uma porta abreWi-Fi, HTTPSChave reed ou PIRMédio
11Troca de mensagens entre duas placas Pico W por UDPWi-Fi, UDPSegundo Pico W, botão, LEDMédio
12Registro de dados e gráficos no ThingSpeakWi-Fi, HTTPQualquer sensorFácil
13Sensor de temperatura BLE lido pelo celularBLENenhumMédio
14Controle BLE de um LED ou servo pelo celularBLE (serviço UART)LED ou servoDifícil
15Teclado Bluetooth e controle para apresentaçõesBLE HID (Arduino IDE)2 botõesDifí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.

Python
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.

MicroPython
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.

MicroPython
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.

MicroPython
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.

RecursoPico WPico 2 WObservação
RAM total264 KB520 KBParte dela é usada pelo firmware e pelo Wi-Fi
Memória livre na inicialização (gc.mem_free)Cerca de 150–190 KBCerca de 400 KB ou maisVaria com a versão; meça na sua placa
Flash / sistema de arquivos2 MB / cerca de 850 KB4 MB / mais de 2 MBCódigo, HTML e arquivos de log ficam aqui
Uma conexão HTTPS30–50 KB temporários30–50 KB temporáriosLibere com r.close() ao terminar
Wi-Fi e BLE juntosFunciona, a memória fica ainda mais apertadaRoda com folgaTeste cada um sozinho primeiro, depois combine
Três regras evitam problemas de memória: feche toda resposta do requests com r.close() quando terminar, chame import gc; gc.collect() antes de laços grandes e envie páginas HTML longas em pedaços, em vez de um texto gigante. Colocar print(gc.mem_free()) em pontos-chave também mostra quanta memória cada linha usa. Ao combinar projetos (por exemplo, servidor web, MQTT e leitura de sensor ao mesmo tempo), escreva cada tarefa como uma tarefa asyncio separada; se você usar await asyncio.sleep() em vez de chamadas longas de time.sleep(), as outras continuam rodando enquanto uma espera a resposta da rede.

Pico W ou ESP32? Qual projeto combina com qual placa?

Tipo de projetoPico WESP32Recomendação
Servidor web simples, controle de LED e reléFaz com facilidadeFaz com facilidadeQualquer um; Pico W se você está aprendendo MicroPython
Sensor MQTT e Home AssistantFunciona bemMuito bom, sem código com ESPHomeESP32
Câmera e transmissão de vídeoNão disponívelDisponível com o ESP32-CAMESP32
Sensor que funciona meses com bateriaA corrente em repouso continua alta no MicroPythonNível de microampères com deep sleepESP32
Áudio Bluetooth Classic (caixa de som A2DP)Suporte limitadoSuportado no ESP32 clássicoESP32
Teclado BLE, controle remotoFácil com o arduino-picoFácil com bibliotecasQualquer um
WS2812B, temporização precisa, protocolos personalizadosMuito poderoso com PIOBom com RMTPico W
Medição analógica3 canais, ADC linear de 12 bitsMuitos canais, mas não linear; ADC2 inutilizável com o Wi-Fi ligadoPico 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.

Ver todos os projetos
Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
PI-1Iniciante

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.

5.0(1)
10
Raspberry Pi Pico: controle de LED externo (protoboard)
PI-2Iniciante

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.

4.5(2)
7
Raspberry Pi Pico: semáforo (3 LEDs em sequência)
PI-4Iniciante

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.

4.0(1)
12
Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
PI-14Iniciante

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.

4
Ciclo de cores com LED RGB no Raspberry Pi Pico (PWM de 3 canais)
PI-15Iniciante

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.

6
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

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.

4.4(21)
38
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

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.

4.5(13)
22
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26