Guias · 11 min de leitura

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.

Placa microcontroladora Raspberry Pi Pico
Placa Raspberry Pi Pico. Para MQTT você precisa da versão W, com o chip sem fio (Pico W ou Pico 2 W); nenhum módulo Wi-Fi extra é necessário.

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.

ConceitoSignificadoExemplo
BrokerO servidor que recebe as mensagens e as distribui aos assinantesMosquitto, HiveMQ, EMQX
Client (cliente)Qualquer dispositivo ou app que se conecta ao brokerPico 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ópicoEnviar o valor “23.4”
Subscribe (assinar)Escutar as mensagens que chegam em um tópicobluegrays/picow/led (tópico para controlar o LED)
QoSGarantia de entrega: 0 no máximo uma vez, 1 pelo menos uma vez, 2 exatamente uma vezO 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"
KeepaliveO intervalo máximo, em segundos, entre pacotes enviados pelo cliente60

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é.
ComponenteLigação no Pico WObservação
LED integradoPin("LED")Controlado pelo chip sem fio, não pelo GP25
Sensor de temperatura integradoADC(4)Não precisa de fios; mede a temperatura do próprio chip
LED externoGP15 → 220 Ω → ânodo do LED, cátodo → GNDPin(15, Pin.OUT) no código
Pino de dados do DHT22GP16 (VCC → 3V3, GND → GND)Lido com o módulo dht do MicroPython
IN do módulo reléGP14Escolha um módulo que possa ser acionado com 3,3 V
Pinos reservados para o chip sem fioGPIO23, 24, 25, 29Não saem para fora da placa, não podem ser usados para outra coisa
No Pico comum, o LED integrado fica ligado ao GP25, mas no Pico W o GP25 é usado na linha de comunicação do chip sem fio. Se você escrever Pin(25) nessa placa, o LED não acende e você ainda pode atrapalhar a comunicação Wi-Fi. Para o LED integrado, use sempre Pin("LED", Pin.OUT). Se for ligar um LED externo, escolha o valor do resistor para 3,3 V com a calculadora de resistor para LED.

Instalando a biblioteca umqtt

  1. 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.
  2. 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.
  3. 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.
  4. Outra opção: no Thonny, abra Ferramentas > Gerenciar pacotes, busque micropython-umqtt.simple e instale.
  5. Depois da instalação, você deve ver o arquivo /lib/umqtt/simple.py no sistema de arquivos do Pico.
Python
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ı / optional
O umqtt.robust é uma pequena camada construída sobre o umqtt.simple: se a conexão cair durante uma publicação ou enquanto espera mensagens, ele tenta reconectar automaticamente. Porém, com sessão limpa (clean session), ele não renova as assinaturas sozinho. Neste guia, nós mesmos escrevemos a reconexão; assim também conseguimos tratar os casos em que a conexão Wi-Fi cai e refazer as assinaturas toda vez.

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

BrokerEndereçoPortaObservação
Broker público da HiveMQbroker.hivemq.com (endereço do broker)1883 (TCP)Sem cadastro, aberto a todos
Servidor de teste Eclipse Mosquittotest.mosquitto.org (endereço do broker)1883 (sem criptografia), 8883 (TLS)Sem cadastro, aberto a todos
Broker público da EMQXbroker.emqx.io1883 (TCP), 8883 (TLS)Sem cadastro, aberto a todos
Complemento Mosquitto do Home AssistantEndereço IP local do Home Assistant1883Exige usuário e senha
Seu próprio servidor MosquittoEndereço IP do seu Raspberry Pi ou computador1883Controle total, funciona na rede local
Brokers públicos são abertos a todos: outra pessoa pode assinar o seu tópico ou enviar mensagens para ele. Adicione um prefixo exclusivo aos nomes dos tópicos (por exemplo, suas iniciais e alguns dígitos aleatórios), não envie senhas nem informações pessoais e não controle dispositivos reais, como fechaduras ou tomadas, por um broker público.

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.

MicroPython
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ódigoO 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

  1. No Home Assistant, instale e inicie o complemento Mosquitto broker em Configurações > Complementos.
  2. 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.
  3. Em Configurações > Dispositivos e serviços, configure a integração MQTT descoberta.
  4. 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.
  5. 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().
  6. Em poucos segundos, um novo dispositivo chamado “Pico W” aparece na lista de dispositivos, com um sensor de temperatura e um interruptor do LED.
MicroPython
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

SintomaCausa provávelSolução
ImportError: no module named 'umqtt' (módulo não encontrado)A biblioteca não está no firmwaremip.install("umqtt.simple") ou o gerenciador de pacotes do Thonny
O Wi-Fi não conecta de jeito nenhumRede de 5 GHz, senha errada ou sinal fracoUse 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 redeVerifique primeiro wlan.isconnected() e escreva corretamente o nome do broker e a porta
MQTTException: 4 ou 5Usuário ou senha errados, sem autorizaçãoConfira o usuário e a senha do Home Assistant
A conexão cai depois de uns 90 segundosNenhum pacote é enviado durante o período de keepalivePublique regularmente ou adicione client.ping()
As mensagens nunca chegamcheck_msg() não é chamada no laço ou set_callback() foi esquecidaChame set_callback() antes de subscribe() e use check_msg() no laço
A comparação sempre dá falsoTópico e mensagem chegam como bytes e você compara com strUse constantes bytes como b"ON"
Duas placas ficam derrubando uma à outraO mesmo CLIENT_ID está sendo usadoGere um ID exclusivo com machine.unique_id()
Na hora de depurar, teste a cadeia parte por parte: wlan.isconnected() retorna True no shell? Uma mensagem que você publica pelo MQTT Explorer aparece no Pico? A publicação do Pico chega ao MQTT Explorer? Com esses três passos você descobre em minutos se o problema está no Wi-Fi, no broker ou no código. Para dicas gerais de Wi-Fi, o checklist de ESP32 não conecta ao Wi-Fi vale em grande parte também para o Pico W.

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.

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: LED controlado por botão (enquanto pressionado)
PI-9Iniciante
Premium

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.

11
Raspberry Pi Pico: ligar e desligar LED com botão
PI-10Iniciante

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

10
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
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