Raspberry Pi Pico W MQTT: sensor e controle de LED com umqtt
Como usar MQTT com o Raspberry Pi Pico W? Instale o umqtt no MicroPython, use um broker grátis, publique a temperatura, assine um tópico para o LED e conecte ao Home Assistant.
MQTT no Raspberry Pi Pico W é o jeito mais leve e mais comum de colocar sua placa na internet, enviar dados de sensores e receber comandos a distância. Com a biblioteca umqtt.simple do MicroPython, o Pico W se conecta a um broker MQTT com poucas linhas de código, publica a temperatura que mede em um tópico e assina outro tópico para que mensagens “ON” ou “OFF” recebidas acendam ou apaguem um LED. Você não precisa montar um servidor web, abrir uma porta no roteador nem decorar o endereço IP da placa; celular, computador e Home Assistant conversam com a sua placa pelo mesmo broker.
Neste guia, primeiro você vai entender a lógica e os conceitos básicos do MQTT. Depois vai instalar a biblioteca umqtt, conectar a um broker público grátis, publicar a cada dez segundos o valor lido do sensor de temperatura integrado do Pico W e controlar o LED integrado a distância. Por fim, vai fazer o código se recuperar sozinho quando a conexão Wi-Fi ou com o broker cair, e adicionar a placa ao Home Assistant com o MQTT Discovery sem escrever uma única linha de YAML.

O que é MQTT e como funciona?
MQTT (Message Queuing Telemetry Transport) é um protocolo de mensagens do tipo publicar/assinar (publish/subscribe), criado para dispositivos com pouca largura de banda e capacidade de processamento limitada. No meio do sistema fica um servidor chamado broker. Os dispositivos não se conectam diretamente entre si; cada um abre uma conexão TCP com o broker (porta 1883 sem criptografia, 8883 com TLS). Quando um dispositivo publica uma mensagem em um tópico como “bluegrays/picow/temperature”, o broker a repassa para todos que assinam esse tópico. Assim, o Pico W nunca precisa saber quem vai ler a mensagem; um app de celular, um datalogger e o Home Assistant podem receber os mesmos dados ao mesmo tempo. O cabeçalho fixo de um pacote MQTT tem só 2 bytes, por isso ele gasta muito menos dados e energia do que requisições HTTP.
| Conceito | Significado | Exemplo |
|---|---|---|
| Broker | O servidor que recebe as mensagens e as distribui aos assinantes | Mosquitto, HiveMQ, EMQX |
| Client (cliente) | Qualquer dispositivo ou app que se conecta ao broker | Pico W, celular, Home Assistant |
| Topic (tópico) | O endereço para onde a mensagem é enviada, separado por / | bluegrays/picow/sicaklik (tópico para os dados de temperatura) |
| Publish (publicar) | Enviar uma mensagem para um tópico | Enviar o valor “23.4” |
| Subscribe (assinar) | Escutar as mensagens que chegam em um tópico | bluegrays/picow/led (tópico para controlar o LED) |
| QoS | Garantia de entrega: 0 no máximo uma vez, 1 pelo menos uma vez, 2 exatamente uma vez | O umqtt.simple suporta 0 e 1 |
| Retain (reter) | O broker guarda a última mensagem e a envia na hora para novos assinantes | Último estado do LED |
| Last Will (LWT) | Uma mensagem que o broker publica se o dispositivo cair inesperadamente | "offline" |
| Keepalive | O intervalo máximo, em segundos, entre pacotes enviados pelo cliente | 60 |
Os tópicos funcionam como caminhos de pastas e diferenciam maiúsculas de minúsculas. Ao assinar, você pode usar dois curingas: + substitui um único nível (“casa/+/temperatura” pega tanto “casa/sala/temperatura” quanto “casa/cozinha/temperatura”), enquanto # cobre todos os níveis restantes e só pode ser usado no final (“casa/#”). Não é possível usar curingas ao publicar. Evitar espaços e caracteres acentuados (não ASCII) nos nomes dos tópicos reduz a chance de problemas entre clientes diferentes.
O que você precisa e ligações do Pico W
- Raspberry Pi Pico W ou Pico 2 W: não dá para usar MQTT com um Pico comum, que não tem o chip sem fio.
- Firmware MicroPython: o arquivo .uf2 feito para a versão W. Os passos de instalação estão explicados em O que é o Raspberry Pi Pico?.
- Thonny ou outro editor de MicroPython, e um cabo micro USB que transmita dados.
- Uma rede Wi-Fi de 2,4 GHz: o Pico W não se conecta a redes de 5 GHz.
- Um cliente MQTT: o MQTT Explorer no computador ou um app de painel MQTT no celular para os testes.
- Opcional: um LED externo e um resistor de 220 Ω, um sensor externo como DHT22 ou BME280, um módulo relé.
| Componente | Ligação no Pico W | Observação |
|---|---|---|
| LED integrado | Pin("LED") | Controlado pelo chip sem fio, não pelo GP25 |
| Sensor de temperatura integrado | ADC(4) | Não precisa de fios; mede a temperatura do próprio chip |
| LED externo | GP15 → 220 Ω → ânodo do LED, cátodo → GND | Pin(15, Pin.OUT) no código |
| Pino de dados do DHT22 | GP16 (VCC → 3V3, GND → GND) | Lido com o módulo dht do MicroPython |
| IN do módulo relé | GP14 | Escolha um módulo que possa ser acionado com 3,3 V |
| Pinos reservados para o chip sem fio | GPIO23, 24, 25, 29 | Não saem para fora da placa, não podem ser usados para outra coisa |
Instalando a biblioteca umqtt
- Segure o botão BOOTSEL enquanto conecta a placa ao computador e copie o arquivo .uf2 do MicroPython para a versão W na unidade RPI-RP2 que aparecer.
- No Thonny, escolha MicroPython (Raspberry Pi Pico) como interpretador no canto inferior direito e digite from umqtt.simple import MQTTClient no shell. Se não aparecer erro, a biblioteca já veio com o firmware e você não precisa instalar nada.
- Se aparecer um ImportError, conecte a placa à sua rede Wi-Fi com o código abaixo e baixe a biblioteca direto da internet com o mip.
- Outra opção: no Thonny, abra Ferramentas > Gerenciar pacotes, busque micropython-umqtt.simple e instale.
- Depois da instalação, você deve ver o arquivo /lib/umqtt/simple.py no sistema de arquivos do Pico.
1import network
2import time
3import mip
4
5wlan = network.WLAN(network.STA_IF)
6wlan.active(True)
7wlan.connect("WIFI_ADIN", "WIFI_SIFREN") # kendi ağ bilgilerin / your network credentials
8
9while not wlan.isconnected():
10 print("Baglaniyor... / Connecting...")
11 time.sleep(1)
12
13print("IP:", wlan.ifconfig()[0])
14mip.install("umqtt.simple") # /lib/umqtt/simple.py olarak kurulur / installed as /lib/umqtt/simple.py
15mip.install("umqtt.robust") # isteğe bağlı / optionalEscolhendo um broker MQTT grátis
Para começar, você não precisa montar seu próprio servidor. Várias empresas mantêm brokers públicos para testes; eles não pedem usuário nem senha, então você conecta a placa e envia sua primeira mensagem em poucos minutos. Para um projeto permanente, instalar o Mosquitto em um Raspberry Pi em casa, em um computador antigo ou no Home Assistant é o caminho mais confiável: seus dados ficam dentro de casa, e os dispositivos da rede local continuam trocando mensagens mesmo se a internet cair.
| Broker | Endereço | Porta | Observação |
|---|---|---|---|
| Broker público da HiveMQ | broker.hivemq.com (endereço do broker) | 1883 (TCP) | Sem cadastro, aberto a todos |
| Servidor de teste Eclipse Mosquitto | test.mosquitto.org (endereço do broker) | 1883 (sem criptografia), 8883 (TLS) | Sem cadastro, aberto a todos |
| Broker público da EMQX | broker.emqx.io | 1883 (TCP), 8883 (TLS) | Sem cadastro, aberto a todos |
| Complemento Mosquitto do Home Assistant | Endereço IP local do Home Assistant | 1883 | Exige usuário e senha |
| Seu próprio servidor Mosquitto | Endereço IP do seu Raspberry Pi ou computador | 1883 | Controle total, funciona na rede local |
Passo a passo: publicar a temperatura, assinar o LED
O programa abaixo faz quatro tarefas ao mesmo tempo: conecta à sua rede Wi-Fi, conecta ao broker com um ID de cliente exclusivo, assina o tópico bluegrays/picow/led e publica a cada dez segundos o valor do sensor de temperatura integrado no tópico bluegrays/picow/sicaklik. Se chegar “ON” no tópico do LED, o LED acende; se chegar “OFF”, ele apaga, e o novo estado é informado em um tópico separado com a flag retain. Se você salvar o arquivo no Pico com o nome main.py pelo Thonny, o programa começa sozinho toda vez que a placa for ligada.
1import network
2import time
3import machine
4import binascii
5from machine import Pin, ADC
6from umqtt.simple import MQTTClient
7
8SSID = "WIFI_ADIN" # Wi-Fi ağ adın / your Wi-Fi name
9PASSWORD = "WIFI_SIFREN" # Wi-Fi şifren / your Wi-Fi password
10BROKER = "broker.hivemq.com" # ücretsiz genel broker / free public broker
11PORT = 1883
12MQTT_USER = None # Home Assistant için kullanıcı / user for Home Assistant
13MQTT_PASS = None # Home Assistant için şifre / password for Home Assistant
14
15CLIENT_ID = b"picow-" + binascii.hexlify(machine.unique_id()) # benzersiz kimlik / unique client id
16TOPIC_TEMP = b"bluegrays/picow/sicaklik"
17TOPIC_LED = b"bluegrays/picow/led"
18TOPIC_LED_STATE = b"bluegrays/picow/led/durum"
19TOPIC_STATUS = b"bluegrays/picow/durum"
20PUBLISH_MS = 10000 # 10 saniyede bir yayınla / publish every 10 s
21
22led = Pin("LED", Pin.OUT) # Pico W dahili LED / Pico W onboard LED
23sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
24wlan = network.WLAN(network.STA_IF)
25client = None
26pending_state = None # bildirilecek LED durumu / LED state to report
27
28
29def read_temp():
30 voltage = sensor.read_u16() * 3.3 / 65535
31 return 27 - (voltage - 0.706) / 0.001721
32
33
34def wifi_connect():
35 wlan.active(True)
36 if wlan.isconnected():
37 return
38 wlan.connect(SSID, PASSWORD)
39 for _ in range(20): # en fazla 20 saniye bekle / wait up to 20 s
40 if wlan.isconnected():
41 print("IP:", wlan.ifconfig()[0])
42 return
43 time.sleep(1)
44 raise OSError("Wi-Fi baglanamadi / Wi-Fi failed")
45
46
47def on_message(topic, msg):
48 global pending_state
49 print("Mesaj / Message:", topic, msg)
50 if topic == TOPIC_LED:
51 if msg == b"ON":
52 led.on()
53 pending_state = b"ON"
54 elif msg == b"OFF":
55 led.off()
56 pending_state = b"OFF"
57
58
59def mqtt_connect():
60 c = MQTTClient(CLIENT_ID, BROKER, port=PORT, user=MQTT_USER,
61 password=MQTT_PASS, keepalive=60)
62 c.set_callback(on_message)
63 c.set_last_will(TOPIC_STATUS, b"offline", retain=True) # koparsa broker yayınlar / broker sends it on drop
64 try:
65 c.connect()
66 except Exception:
67 try:
68 c.sock.close() # yarım kalan soketi kapat / close the half-open socket
69 except Exception:
70 pass
71 raise
72 c.subscribe(TOPIC_LED)
73 c.publish(TOPIC_STATUS, b"online", retain=True)
74 return c
75
76
77def reconnect():
78 global client
79 delay = 2
80 while True:
81 if client:
82 try:
83 client.sock.close()
84 except Exception:
85 pass
86 try:
87 wifi_connect()
88 client = mqtt_connect()
89 print("MQTT bagli / connected")
90 return
91 except Exception as e:
92 print("Tekrar denenecek / retrying:", e)
93 time.sleep(delay)
94 delay = min(delay * 2, 60) # üstel bekleme / exponential backoff
95
96
97reconnect()
98last_pub = time.ticks_add(time.ticks_ms(), -PUBLISH_MS) # ilk yayın hemen / first publish right away
99
100while True:
101 try:
102 client.check_msg() # gelen mesaj var mı? / any incoming message?
103 if pending_state:
104 client.publish(TOPIC_LED_STATE, pending_state, retain=True)
105 pending_state = None
106 if time.ticks_diff(time.ticks_ms(), last_pub) >= PUBLISH_MS:
107 last_pub = time.ticks_ms()
108 temp = "{:.1f}".format(read_temp())
109 client.publish(TOPIC_TEMP, temp.encode())
110 print("Yayinlandi / Published:", temp)
111 except Exception as e:
112 print("Baglanti koptu / Connection lost:", e)
113 reconnect()
114 time.sleep_ms(100)| Parte do código | O que faz |
|---|---|
| CLIENT_ID (ID do cliente) | Gera um ID exclusivo para cada placa com machine.unique_id(); dois dispositivos que se conectam com o mesmo ID derrubam um ao outro no broker |
| read_temp() (leitura da temperatura) | Converte o valor do ADC(4) em tensão e depois em graus Celsius com a fórmula 27 - (V - 0,706) / 0,001721 |
| set_last_will() (mensagem de último desejo) | Faz o broker escrever “offline” no tópico de status se a conexão cair inesperadamente; precisa ser executada antes da chamada connect() |
| subscribe() (assinar) | Começa a escutar o tópico do LED; é chamada de novo a cada nova conexão |
| check_msg() (verificar mensagens) | Chama a função on_message se uma mensagem chegou; caso contrário, retorna sem esperar |
| pending_state (estado pendente) | Em vez de publicar dentro do callback, deixa o estado em uma variável e o laço principal faz a publicação |
| ticks_diff() (diferença de tempo) | Mede dez segundos sem ficar parado em sleep, assim os comandos do LED são tratados sem atraso |
| reconnect() (reconectar) | Tenta de novo a conexão Wi-Fi e MQTT em intervalos de 2, 4, 8 … até 60 segundos |
Depois de rodar o programa, conecte ao mesmo broker com o MQTT Explorer no computador e assine o tópico bluegrays/picow/#. Você deve ver um valor de temperatura chegando a cada dez segundos e “online” no tópico de status. Para testar o LED, publique ON em letras maiúsculas no tópico bluegrays/picow/led; o LED verde da placa acende na hora e a mensagem recebida aparece no shell do Thonny. Se as ferramentas de cliente do Mosquitto estiverem instaladas, você pode fazer o mesmo pela linha de comando com mosquitto_pub -h broker.hivemq.com -t bluegrays/picow/led -m ON. Como o sensor integrado mede a temperatura do próprio chip, a leitura pode ficar alguns graus diferente da temperatura ambiente; para medir o ambiente de verdade, ligue um sensor externo como o DHT11/DHT22 ou o BME280 e ajuste a read_temp() de acordo.
Reconectando automaticamente quando a conexão cai
O maior inimigo de um dispositivo IoT funcionando em casa são as quedas de conexão: o roteador reinicia, o sinal Wi-Fi enfraquece ou o broker entra em manutenção. O umqtt.simple não se recupera sozinho nesse caso; ele lança um OSError na próxima chamada de publish() ou check_msg(). O bloco try/except do programa captura esse erro e chama a função reconnect(). A função primeiro fecha o socket antigo, reconecta o Wi-Fi se ele tiver caído e depois refaz do zero a conexão MQTT e a assinatura. Depois de cada tentativa sem sucesso, o tempo de espera dobra (2, 4, 8, 16, 32, 60 segundos); isso se chama recuo exponencial (exponential backoff) e evita que você inunde o broker com dezenas de tentativas por segundo.
O valor de keepalive também importa. No código definimos 60 segundos; pelas regras do MQTT, o broker fecha a conexão se nenhum pacote chegar do cliente durante 1,5 vez esse período (ou seja, 90 segundos). Como publicamos a cada dez segundos, isso não é problema. Mas se você aumentar o intervalo de publicação para, digamos, cinco minutos, vai precisar adicionar chamadas regulares de client.ping(); o umqtt.simple não envia o pacote de ping automaticamente. Graças à mensagem Last Will, mesmo que a placa seja desligada da tomada, o broker escreve “offline” no tópico de status quando o período de keepalive acaba, e o Home Assistant mostra o dispositivo como “Indisponível”.
- Guarde os dados do Wi-Fi e a senha do broker em um arquivo separado secrets.py; não compartilhe esse arquivo quando for compartilhar seu código.
- Para mais estabilidade, configure um watchdog com machine.WDT(timeout=8000) e chame wdt.feed() regularmente no laço principal; se o programa travar em algum ponto, a placa reinicia sozinha. Nesse caso, mantenha as esperas dentro da reconnect() abaixo de 8 segundos ou alimente o watchdog durante a espera.
- Publique a medição em intervalos definidos, e não a cada ciclo do laço; para reduzir oscilações momentâneas, tire a média de várias leituras (filtragem de dados de sensores).
- Use retain em tópicos onde o último valor importa, como o estado do LED; não envie mensagens com retain para tópicos de comando, senão a placa vai reaplicar o comando antigo toda vez que reconectar.
- Se a conexão cair com frequência, tente desligar o modo de economia de energia do chip sem fio com wlan.config(pm=0xa11140); isso reduz a latência, mas aumenta o consumo de corrente.
Conectando o Pico W ao Home Assistant
- No Home Assistant, instale e inicie o complemento Mosquitto broker em Configurações > Complementos.
- Em Configurações > Pessoas, crie um usuário separado para o Pico W (por exemplo, “pico”); o nome e a senha desse usuário são usados na conexão MQTT.
- Em Configurações > Dispositivos e serviços, configure a integração MQTT descoberta.
- Troque o valor de BROKER no código pelo endereço IP local do Home Assistant (por exemplo, 192.168.1.50) e coloque o usuário e a senha nas variáveis MQTT_USER e MQTT_PASS.
- Adicione a função ha_discovery() abaixo ao seu código e chame-a como ha_discovery(c) depois da linha subscribe() dentro de mqtt_connect().
- Em poucos segundos, um novo dispositivo chamado “Pico W” aparece na lista de dispositivos, com um sensor de temperatura e um interruptor do LED.
1import json
2import binascii
3import machine
4
5DEVICE_ID = "picow_" + binascii.hexlify(machine.unique_id()).decode()
6DEVICE = {
7 "identifiers": [DEVICE_ID],
8 "name": "Pico W",
9 "manufacturer": "Raspberry Pi",
10 "model": "Pico W",
11}
12
13
14def ha_discovery(c):
15 temp_cfg = {
16 "name": "Sicaklik",
17 "unique_id": DEVICE_ID + "_temp",
18 "state_topic": "bluegrays/picow/sicaklik",
19 "unit_of_measurement": "°C",
20 "device_class": "temperature",
21 "availability_topic": "bluegrays/picow/durum",
22 "device": DEVICE,
23 }
24 led_cfg = {
25 "name": "LED",
26 "unique_id": DEVICE_ID + "_led",
27 "command_topic": "bluegrays/picow/led",
28 "state_topic": "bluegrays/picow/led/durum",
29 "payload_on": "ON",
30 "payload_off": "OFF",
31 "availability_topic": "bluegrays/picow/durum",
32 "device": DEVICE,
33 }
34 base = DEVICE_ID.encode()
35 # JSON'u bytes olarak gönder (°C çok baytlıdır) / send JSON as bytes (°C is multi-byte)
36 c.publish(b"homeassistant/sensor/" + base + b"/temp/config",
37 json.dumps(temp_cfg).encode(), retain=True)
38 c.publish(b"homeassistant/switch/" + base + b"/led/config",
39 json.dumps(led_cfg).encode(), retain=True)
40
41# mqtt_connect() içinde subscribe() satırından sonra çağır / call after subscribe() in mqtt_connect()
42# ha_discovery(c)Por padrão, o Home Assistant escuta os tópicos que começam com o prefixo homeassistant/. Quando o Pico W envia uma configuração em JSON para esses tópicos com a flag retain, o Home Assistant cria as entidades automaticamente: a configuração sensor mostra a temperatura como um valor que pode virar gráfico, enquanto a configuração switch adiciona um interruptor liga/desliga à interface. Quando você toca no interruptor, o Home Assistant publica “ON” ou “OFF” no command_topic, a placa muda o LED e escreve o novo estado no state_topic; assim o interruptor da interface sempre mostra o estado real. O campo availability_topic usa a mensagem Last Will para deixar as entidades em cinza quando a placa fica offline. Se quiser ver a mesma estrutura no lado do ESP32, confira ESP32 MQTT e Home Assistant.
Ideias de projetos com Pico W e MQTT
- Painel de temperatura e umidade dos cômodos: coloque um Pico W e um DHT22 em cada cômodo e acompanhe a casa toda em uma única tela com tópicos como casa/sala/temperatura.
- Lâmpada com controle remoto: acione um módulo relé no lugar do LED e ligue e desligue a lâmpada pelo Home Assistant.
- Aviso para regar as plantas: publique o valor do sensor de umidade do solo e envie uma notificação para o celular com uma automação quando a terra secar.
- Alarme de movimento: publique uma mensagem no tópico casa/corredor/movimento quando o sensor PIR for acionado.
- Termômetro de aquário: meça a temperatura da água com um DS18B20 e envie uma mensagem de alerta com retain quando um limite for ultrapassado.
- Compare com uma interface web: controle o mesmo LED também com um servidor web no Pico W e veja a diferença entre os dois métodos.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| ImportError: no module named 'umqtt' (módulo não encontrado) | A biblioteca não está no firmware | mip.install("umqtt.simple") ou o gerenciador de pacotes do Thonny |
| O Wi-Fi não conecta de jeito nenhum | Rede de 5 GHz, senha errada ou sinal fraco | Use uma rede de 2,4 GHz, imprima wlan.status(), aproxime a placa do roteador |
| OSError durante o connect() | Não foi possível resolver o endereço do broker ou não há conexão de rede | Verifique primeiro wlan.isconnected() e escreva corretamente o nome do broker e a porta |
| MQTTException: 4 ou 5 | Usuário ou senha errados, sem autorização | Confira o usuário e a senha do Home Assistant |
| A conexão cai depois de uns 90 segundos | Nenhum pacote é enviado durante o período de keepalive | Publique regularmente ou adicione client.ping() |
| As mensagens nunca chegam | check_msg() não é chamada no laço ou set_callback() foi esquecida | Chame set_callback() antes de subscribe() e use check_msg() no laço |
| A comparação sempre dá falso | Tópico e mensagem chegam como bytes e você compara com str | Use constantes bytes como b"ON" |
| Duas placas ficam derrubando uma à outra | O mesmo CLIENT_ID está sendo usado | Gere um ID exclusivo com machine.unique_id() |
Depois que o MQTT está configurado, cada novo sensor ou saída que você adiciona à placa é só um novo tópico; a infraestrutura continua a mesma. Primeiro rode o programa deste guia com o LED e o sensor de temperatura integrados, depois amplie com um relé e sensores externos. Se quiser reforçar o básico de LEDs, botões e PWM no MicroPython, você encontra o esquema do circuito e o código de cada passo nos projetos de Raspberry Pi Pico do app BlueGrays.
Perguntas frequentes
Posso usar MQTT com um Raspberry Pi Pico comum?
Não. Um Pico comum não tem Wi-Fi nem Ethernet, então não consegue se conectar diretamente a um broker. Para MQTT você precisa do Pico W ou do Pico 2 W, que têm o chip sem fio. Um Pico comum só entra na rede com um módulo Wi-Fi ou Ethernet externo, o que deixa a montagem bem mais complicada.
Qual é a diferença entre umqtt.simple e umqtt.robust?
O umqtt.simple é um cliente bem pequeno que faz as operações básicas do MQTT, como conectar, publicar e assinar, e lança um erro quando a conexão cai. O umqtt.robust é construído sobre ele e tenta reconectar automaticamente quando há erros. Porém, ele não renova as assinaturas sozinho, então você ainda precisa chamar subscribe() de novo depois de reconectar.
Qual é o melhor broker MQTT grátis?
Para testes, broker.hivemq.com, test.mosquitto.org e broker.emqx.io são brokers públicos que não exigem cadastro e funcionam na porta 1883. Como são abertos a todos, envie para eles apenas dados de teste. Para uma instalação permanente e segura, instalar o Mosquitto em um Raspberry Pi em casa ou no Home Assistant é a melhor opção grátis.
Como adiciono o Pico W ao Home Assistant?
Instale o complemento Mosquitto broker e a integração MQTT no Home Assistant e crie um usuário separado para o Pico W. Conecte a placa ao endereço IP do Home Assistant com esse usuário e publique uma configuração de discovery com retain em tópicos que começam com homeassistant/. O Home Assistant então cria o sensor e o interruptor automaticamente.
Por que a conexão MQTT do meu Pico W fica caindo?
A causa mais comum é nenhum pacote ser enviado dentro do período de keepalive; o umqtt.simple não envia o pacote de ping automaticamente, então você precisa de um client.ping() ou de uma publicação regular. Sinal Wi-Fi fraco, o roteador reiniciando e um segundo dispositivo usando o mesmo ID de cliente também causam quedas. Escrever o código para capturar OSError e reconectar resolve todos esses casos.
Posso usar TLS (porta 8883) com MQTT no Pico W?
Sim. Você pode fazer uma conexão criptografada na porta 8883 com o parâmetro ssl da biblioteca umqtt.simple; nas versões atuais do MicroPython, você passa para esse parâmetro um contexto criado com ssl.SSLContext. O handshake TLS pode levar alguns segundos no RP2040 e aumenta o uso de RAM. Brokers na nuvem, como o HiveMQ Cloud, normalmente exigem conexão TLS.
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: LED controlado por botão (enquanto pressionado)
Primeiro projeto de entrada com o Pico — leitura de botão! O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. O grande passo depois das animações com LEDs: entrada de sinais do mundo para o Pico. Aprenda a usar Pin.IN (modo de entrada), Pin.PULL_UP (pull-up interno — padrão para botões) e a leitura com button.value(). LED no GP14, botão no GP2. Pressionado = LOW (0), solto = HIGH (1) — essa lógica invertida confunde no início, mas é padrão da indústria.

Raspberry Pi Pico: ligar e desligar LED com botão
Botão + LED — próximo nível! Ao contrário do projeto básico de botão, não é preciso manter o botão pressionado. Pressione e solte → LED aceso. De novo → LED apagado (alternância). O circuito é o mesmo (LED no GP14, botão no GP2), mas o código muda bastante. Aprenda detecção de borda (o instante da queda 1→0), rastreamento de estado e debounce (filtro de repique). led.toggle() alterna o estado em uma linha. Base para projetos interativos com botões (seletor de modo, IRQ, clique duplo).

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.

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

