Raspberry Pi Pico W MQTT com MicroPython: Publique Dados de Sensores e Receba Comandos

Projetos Raspberry Pi Pico W MQTT são um ótimo primeiro passo no hardware conectado: a placa custa pouco, o MicroPython é fácil de ler e o MQTT oferece uma forma leve de enviar leituras para a nuvem e receber comandos de volta. Neste tutorial você vai gravar o MicroPython, instalar a biblioteca umqtt.simple, publicar a temperatura interna do Pico W em um broker a cada dez segundos, acionar o LED da placa a partir do seu computador e fazer tudo sobreviver a desconexões do Wi-Fi e do broker.

O que você precisa

Nenhum sensor extra é necessário. O RP2040 tem um sensor de temperatura interno no canal 4 do ADC, perfeito para validar o caminho dos dados antes de ligar hardware de verdade. Se você ainda está escolhendo entre placas, nossa comparação ESP32 vs Raspberry Pi Pico W e o guia Pico W vs Pico 2 W cobrem os prós e contras.

Passo 1: grave o MicroPython

1. Baixe o arquivo UF2 mais recente do MicroPython para o Raspberry Pi Pico W (nome da placa RPI_PICO_W) na página de downloads do MicroPython ou na documentação de MicroPython do Raspberry Pi. A build do Pico comum não tem suporte a Wi-Fi, então escolha a variante W.
2. Segure o botão BOOTSEL enquanto conecta a placa ao USB. Ela aparece como uma unidade chamada RPI-RP2.
3. Copie o arquivo UF2 para a unidade. A placa reinicia no MicroPython automaticamente.
4. Abra o Thonny, escolha MicroPython (Raspberry Pi Pico) como interpretador no canto inferior direito, e você deve ver o prompt >>>.

Digite import network no prompt. Se funcionar sem erro, você está com a build com Wi-Fi.

Passo 2: instale o umqtt.simple

O MicroPython distribui o umqtt.simple como um pacote da micropython-lib, e não em todas as builds de firmware. Instale-o quando a placa já conseguir acessar a internet, usando o mip a partir do REPL depois de conectar ao Wi-Fi:

import network, time, mip
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("YOUR_WIFI_SSID", "YOUR_WIFI_PASSWORD")
while not wlan.isconnected():
    time.sleep(0.5)
mip.install("umqtt.simple")

Como alternativa, a partir do seu computador com a placa conectada por USB:

pip install mpremote
mpremote mip install umqtt.simple

O Thonny também tem Tools → Manage packages, onde você pode procurar por umqtt.simple. Qualquer um dos três métodos coloca a biblioteca em /lib na placa.

Passo 3: planeje topics e client ID

Todo cliente MQTT precisa de um client ID único e não vazio. O Pico W tem um ID de placa único que podemos usar, então duas placas rodando o mesmo código nunca entram em conflito. Para os topics, usamos um prefixo de demonstração com uma string aleatória escolhida por você:

O servidor MQTT público gratuito em broker.connectmq.com aceita conexões anônimas na porta 1883, mas tudo o que é publicado nele fica visível para qualquer pessoa que assine. Use um prefixo único e envie apenas dados de teste.

Passo 4: o programa Raspberry Pi Pico W MQTT completo

Salve como main.py na placa para que ele rode no boot. Altere as credenciais do Wi-Fi e substitua pw7c3e pela sua própria string.

# main.py - exemplo Raspberry Pi Pico W MQTT (MicroPython + umqtt.simple)
import time
import network
import machine
import ubinascii
import rp2
from umqtt.simple import MQTTClient

WIFI_SSID = "YOUR_WIFI_SSID"
WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"
COUNTRY = "GB"                      # código do seu país com duas letras (BR no Brasil)

BROKER = "broker.connectmq.com"
PORT = 1883
PREFIX = "connectmq/demo/pw7c3e/pico1"
CLIENT_ID = "pico-" + ubinascii.hexlify(machine.unique_id()).decode()

PUBLISH_INTERVAL_MS = 10_000
KEEPALIVE_S = 60

led = machine.Pin("LED", machine.Pin.OUT)
sensor = machine.ADC(4)


def read_temperature():
    # Sensor interno do RP2040: 27 C a 0,706 V, inclinação -1,721 mV/C
    voltage = sensor.read_u16() * 3.3 / 65535
    return round(27 - (voltage - 0.706) / 0.001721, 2)


def connect_wifi():
    rp2.country(COUNTRY)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.config(pm=0xA11140)        # desativa a economia de energia para um link responsivo
    if not wlan.isconnected():
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        for _ in range(30):
            if wlan.isconnected():
                break
            led.toggle()
            time.sleep(0.5)
    if not wlan.isconnected():
        raise OSError("Wi-Fi connection failed, status %d" % wlan.status())
    print("Wi-Fi connected:", wlan.ifconfig()[0])
    led.off()


def on_message(topic, msg):
    topic = topic.decode()
    msg = msg.decode().strip().upper()
    print("Received", topic, msg)
    if topic == PREFIX + "/led/set":
        if msg in ("ON", "1"):
            led.on()
        elif msg in ("OFF", "0"):
            led.off()
        client.publish(PREFIX + "/led/state", "ON" if led.value() else "OFF", retain=True)


def connect_mqtt():
    c = MQTTClient(CLIENT_ID, BROKER, port=PORT, keepalive=KEEPALIVE_S)
    c.set_last_will(PREFIX + "/status", "offline", retain=True, qos=1)
    c.set_callback(on_message)
    c.connect()
    c.publish(PREFIX + "/status", "online", retain=True, qos=1)
    c.subscribe(PREFIX + "/led/set", qos=1)
    print("MQTT connected as", CLIENT_ID)
    return c


client = None


def main():
    global client
    connect_wifi()
    client = connect_mqtt()
    last_publish = time.ticks_ms() - PUBLISH_INTERVAL_MS
    last_ping = time.ticks_ms()

    while True:
        client.check_msg()                         # trata os comandos recebidos
        now = time.ticks_ms()

        if time.ticks_diff(now, last_publish) >= PUBLISH_INTERVAL_MS:
            temp = read_temperature()
            payload = '{"value": %s, "unit": "C"}' % temp
            client.publish(PREFIX + "/temperature", payload)
            print("Published", payload)
            last_publish = now
            last_ping = now

        elif time.ticks_diff(now, last_ping) >= (KEEPALIVE_S // 2) * 1000:
            client.ping()                          # mantém a sessão viva
            last_ping = now

        time.sleep_ms(100)


while True:
    try:
        main()
    except OSError as e:
        print("Connection problem:", e, "- retrying in 5 s")
        try:
            if client:
                client.disconnect()
        except Exception:
            pass
        time.sleep(5)

Clique em Run no Thonny ou reinicie a placa. O shell deve mostrar o endereço do Wi-Fi, a conexão MQTT e uma publicação a cada dez segundos.

Como o programa funciona

• Client ID único. O machine.unique_id() é lido do chip de flash, então cada placa recebe automaticamente seu próprio ID.
• Last Will. Se o Pico sumir sem uma desconexão limpa, o broker publica offline no topic de status em nome dele. Combinado com a mensagem retained online, qualquer assinante consegue ver se o dispositivo está no ar.
• Loop não bloqueante. O check_msg() retorna imediatamente quando não há nada para ler, então o loop pode publicar por temporizador e ainda reagir aos comandos do LED em cerca de um décimo de segundo.
• Pings de keepalive. O umqtt.simple não envia pings automaticamente. Sem as chamadas a ping(), uma conexão silenciosa seria encerrada pelo broker após o intervalo de keepalive.
• Reconexão. Qualquer erro de socket gera um OSError; o loop externo espera cinco segundos e recomeça, incluindo o Wi-Fi, se necessário.

Passo 5: teste a partir do seu computador

Acompanhe tudo o que o Pico publica:

mosquitto_sub -h broker.connectmq.com -p 1883 -i laptop-pw7c3e -v -t "connectmq/demo/pw7c3e/#"

Acione o LED:

mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-pw7c3e -t "connectmq/demo/pw7c3e/pico1/led/set" -m "ON"
mosquitto_pub -h broker.connectmq.com -p 1883 -i cmd-pw7c3e -t "connectmq/demo/pw7c3e/pico1/led/set" -m "OFF"

O LED deve acompanhar, e o assinante mostra o novo estado. Desconecte o Pico e, depois do período de keepalive, o assinante recebe offline pelo Last Will.

Solução de problemas

O sensor interno também é sensível à tensão de referência exata, então as leituras podem errar alguns graus. Para este tutorial não há problema; para medições reais, ligue um DS18B20, BME280 ou SHT31.

Da demonstração à produção

O servidor público é compartilhado e aberto, então dispositivos de produção devem se conectar com credenciais próprias e TLS. No ConnectMQ, crie um broker no portal e copie o usuário, a senha e o client ID gerados. Os client IDs ficam vinculados às credenciais emitidas, então use exatamente o valor YOUR_CLIENT_ID do portal em vez do ID derivado da placa e passe user="YOUR_USERNAME" e password="YOUR_PASSWORD" para o MQTTClient. Depois migre para a porta 8883 com verificação de certificado, o que é explicado passo a passo em Pico W MQTT com TLS. Para projetos alimentados por bateria, veja Pico W com bateria e MQTT.

Um broker MQTT gerenciado como o ConnectMQ também oferece ferramentas em torno do dispositivo: o cliente MQTT no navegador e o explorador de topics ao vivo do portal permitem conferir os topics do Pico sem instalar nada, e regras de alerta por limite podem sinalizar uma temperatura fora da faixa. Para mais projetos com Raspberry Pi, incluindo as placas de tamanho completo, comece pelo tutorial MQTT com Raspberry Pi.

Conecte seu Pico W ao ConnectMQ

Cadastre-se em app.connectmq.com no plano Serverless gratuito, sem cartão de crédito. Crie um broker, copie as credenciais para o main.py, e o seu Pico W estará falando com um broker privado em poucos minutos. As 25 conexões do plano gratuito dão conta de uma prateleira inteira de placas Pico W.

Perguntas frequentes

Qual biblioteca MQTT devo usar no Pico W?

O umqtt.simple da micropython-lib é a escolha padrão para MicroPython. Ele é pequeno, suporta QoS 0 e 1, Last Will, retained messages e TLS, e é instalado com o mip.

O Raspberry Pi Pico W suporta MQTT com TLS?

Sim. O módulo ssl do MicroPython funciona no Pico W, e o umqtt.simple consegue se conectar à porta 8883 com verificação de certificado, embora o handshake demore visivelmente mais do que em chips com aceleração criptográfica.

Por que meu Pico W se desconecta do broker MQTT depois de um minuto?

O umqtt.simple não envia pings de keepalive sozinho. Chame client.ping() regularmente, pelo menos uma vez por intervalo de keepalive, ou publique com frequência suficiente para manter a conexão ativa.

Posso usar o Pico W com Arduino em vez de MicroPython?

Sim. O core Arduino-Pico suporta o Wi-Fi do Pico W, e bibliotecas como a PubSubClient funcionam com ele. O MicroPython costuma ser mais rápido para prototipar, enquanto C/C++ oferece mais controle sobre memória e temporização.