Pico W vs Pico 2 W para MQTT: Desempenho, Memória e TLS do RP2040 vs RP2350

Pico W vs Pico 2 W é uma decisão rápida para a maioria dos projetos MQTT, mas vale entender os motivos antes de comprar uma gaveta cheia de placas. As duas têm o mesmo formato, a mesma pinagem e o mesmo chip Wi-Fi Infineon CYW43439; a diferença está no microcontrolador. Esta comparação explica o que a troca do RP2040 pelo RP2350 muda para dispositivos conectados, especialmente em memória e TLS, e traz um pequeno script para medir a diferença na sua própria rede.

A resposta curta

Para novos projetos MQTT, escolha o Pico 2 W. Ele tem cerca do dobro de RAM e flash, núcleos Cortex-M33 mais rápidos com unidade de ponto flutuante e recursos de segurança em hardware, rodando o mesmo código MicroPython do Pico W quase sem alterações. Continue usando o Pico W quando já tiver estoque, um projeto validado ou um sensor muito simples que publica via MQTT puro em uma rede confiável, onde a folga extra traz pouco benefício.

Especificações do Pico W vs Pico 2 W

Os números principais vêm dos datasheets publicados pela Raspberry Pi; consulte a documentação oficial do Pico para os detalhes completos e as erratas atuais.

O que as diferenças significam para dispositivos MQTT

O Wi-Fi é o mesmo

Como as duas placas usam o CYW43439 pela mesma interface do tipo SPI, o alcance do Wi-Fi, as bandas suportadas (somente 2,4 GHz) e a vazão de rede são praticamente idênticos. Um Pico 2 W não vai conectar de mais longe nem a uma rede de 5 GHz. Se seus problemas com MQTT são de intensidade de sinal, uma placa nova não vai resolvê-los; a posição da antena e do access point, sim.

A folga de memória é o maior ganho prático

Em um Pico W rodando MicroPython, o heap disponível após o boot é confortável para MQTT puro, mas fica apertado quando você adiciona TLS, manipulação de JSON, alguns drivers de sensor e leituras em buffer. Só uma sessão TLS precisa de dezenas de kilobytes para seus buffers, e a fragmentação pode causar erros ENOMEM mesmo quando a memória livre total parece suficiente.

O Pico 2 W praticamente dobra a SRAM. Na prática, isso significa:

• Conexões TLS que falham de forma intermitente com erros de memória em um Pico W geralmente simplesmente funcionam.
• Você pode guardar mais leituras em buffer enquanto está offline e publicá-las quando o broker voltar a ficar acessível.
• Payloads JSON maiores e mais topics por dispositivo deixam de ser uma preocupação.

A flash também dobra, de 2 MB para 4 MB, o que deixa mais espaço para bibliotecas MicroPython, arquivos de certificado, logs e esquemas de atualização over-the-air.

Tempo de handshake TLS

No RP2040, todo handshake TLS roda inteiramente em software nos núcleos Cortex-M0+, que não têm as instruções que tornam rápida a aritmética de números grandes. O handshake é claramente perceptível e, em um dispositivo a bateria que reconecta a cada despertar, é um custo real de tempo e energia.

Os núcleos Cortex-M33 do RP2350 rodam em clock mais alto, executam com mais eficiência por ciclo e incluem instruções DSP, então as operações de chave pública do handshake terminam mais rápido. O RP2350 também tem um acelerador SHA-256 e um gerador de números aleatórios verdadeiro. Se o seu firmware usa o hardware SHA-256 depende de como a biblioteca TLS foi compilada, mas a melhoria da CPU por si só já encurta os handshakes. Em vez de confiar nos números de outra pessoa, meça na sua própria rede com o script abaixo.

Recursos de segurança

O Pico W não tem secure boot nem armazenamento protegido de chaves, então qualquer pessoa com acesso físico pode ler a flash, incluindo senhas de Wi-Fi e credenciais MQTT. O Pico 2 W adiciona boot assinado e memória programável uma única vez (OTP) capaz de guardar chaves, além do Arm TrustZone para separar código confiável. Esses recursos exigem configuração deliberada pelo SDK em C e não são ativados por padrão pelo MicroPython, mas fazem diferença real em produtos implantados onde os dispositivos podem ser roubados ou adulterados.

Compatibilidade de software

Seu código MicroPython do Pico W quase sempre roda sem mudanças no Pico 2 W depois de gravar o firmware RPI_PICO2_W. As APIs network, machine.Pin("LED"), umqtt.simple e ssl são as mesmas. Para o sensor de temperatura interno, use machine.ADC(machine.ADC.CORE_TEMP) em vez de um número de canal fixo, para manter a portabilidade. O SDK C/C++ 2.x e o core Arduino-Pico suportam os dois chips.

Uma observação de hardware: o silício inicial do RP2350 tinha uma errata documentada (E9) que afeta entradas GPIO dependentes de resistores pull-down internos. Revisões posteriores do chip resolvem isso. Se o seu projeto depende de pull-downs internos, leia as erratas atuais do datasheet do RP2350 e use resistores externos quando recomendado.

Faça o benchmark das duas placas você mesmo

Este script MicroPython roda em qualquer uma das placas. Ele informa a frequência da CPU, a memória livre e o tempo de uma conexão MQTT pura e de uma conexão MQTT com TLS ao broker.connectmq.com. Copie antes o isrgrootx1.der para a placa, como descrito no nosso guia de Pico W MQTT TLS.

# bench.py - compara tempos de conexão MQTT no Pico W e no Pico 2 W
import time, gc, ssl, network, machine, os, ubinascii
from umqtt.simple import MQTTClient

WIFI_SSID = "YOUR_WIFI_SSID"
WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"
BROKER = "broker.connectmq.com"
CID = "bench-" + ubinascii.hexlify(machine.unique_id()).decode()
RUNS = 5

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(WIFI_SSID, WIFI_PASSWORD)
while not wlan.isconnected():
    time.sleep(0.2)

print("Board:", os.uname().machine)
print("CPU freq:", machine.freq() // 1_000_000, "MHz")
gc.collect()
print("Free heap:", gc.mem_free(), "bytes")
print("RSSI:", wlan.status("rssi"), "dBm")

ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ctx.verify_mode = ssl.CERT_REQUIRED
with open("isrgrootx1.der", "rb") as f:
    ctx.load_verify_locations(cadata=f.read())


def timed_connect(port, use_tls):
    gc.collect()
    c = MQTTClient(CID, BROKER, port=port, keepalive=30, ssl=ctx if use_tls else None)
    t0 = time.ticks_ms()
    c.connect()
    dt = time.ticks_diff(time.ticks_ms(), t0)
    c.publish("connectmq/demo/bn4q7d/bench", "%s %d" % ("tls" if use_tls else "tcp", dt))
    c.disconnect()
    return dt


for label, port, tls in (("Plain TCP 1883", 1883, False), ("TLS 8883", 8883, True)):
    times = []
    for _ in range(RUNS):
        times.append(timed_connect(port, tls))
        time.sleep(1)
    times.sort()
    print(label, "connect ms - min:", times[0], "median:", times[len(times) // 2], "max:", times[-1])

Rode nas duas placas, na mesma rede e no mesmo local, e compare as medianas. Os números de TCP puro mostram a linha de base da sua rede; a diferença entre TCP e TLS mostra o custo criptográfico em cada chip. O script também publica cada resultado no servidor MQTT público, para você acompanhar as duas placas lado a lado:

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

Mantenha o número de execuções moderado. O servidor público permite 10 mensagens por segundo por cliente, e reconexões rápidas repetidas não são uma carga de trabalho realista de qualquer forma.

Qual placa para cada projeto MQTT

A última linha lembra que a família Pico não é a única opção. Nossa comparação ESP32 vs Raspberry Pi Pico W mostra quando um ESP32 se encaixa melhor, e o guia de Pico W a bateria com MQTT aprofunda o orçamento de energia.

Conectando qualquer uma das placas a um broker de produção

Seja qual for a placa escolhida, o lado do broker é o mesmo. Para testes, use o broker.connectmq.com de forma anônima com um client ID único. Para implantações reais, crie um broker privado no ConnectMQ e use usuário, senha e client ID gerados via TLS na porta 8883. Como o certificado é da Let's Encrypt, o mesmo arquivo de certificado raiz funciona nas duas placas. O código passo a passo de uma primeira conexão está no nosso tutorial de MQTT com Raspberry Pi Pico W, e o tutorial de MQTT com Raspberry Pi, mais amplo, cobre as placas de tamanho completo que muitas vezes atuam como gateways ao lado dos dispositivos Pico.

Um broker MQTT gerenciado cuida de disponibilidade, certificados e limites de conexão, para que seu esforço vá para o firmware do dispositivo. No plano Serverless gratuito do ConnectMQ você tem até 25 conexões, QoS até 1 e mensagens de até 256 KB, o que é mais que suficiente para uma frota de placas Pico em desenvolvimento.

Conecte suas placas Pico ao ConnectMQ

Cadastre-se em app.connectmq.com no plano Serverless gratuito, sem cartão de crédito. Crie um broker, grave em qualquer uma das placas o build MicroPython correspondente e use o explorador de topics ao vivo do portal para acompanhar seu Pico W e seu Pico 2 W reportando em tempo real.

Perguntas frequentes

O Pico 2 W é compatível com o código do Pico W?

Na maior parte, sim. Depois de gravar o build MicroPython RPI_PICO2_W, o código de Wi-Fi, GPIO, umqtt.simple e TLS roda sem mudanças. Use machine.ADC(machine.ADC.CORE_TEMP) para o sensor de temperatura interno e mantenha a portabilidade.

O Pico 2 W tem Wi-Fi melhor que o Pico W?

Não. Os dois usam o mesmo chip CYW43439 com Wi-Fi 2,4 GHz e Bluetooth 5.2, então alcance e vazão são praticamente iguais. As melhorias estão no microcontrolador.

O TLS é mais rápido no Pico 2 W?

Sim, os núcleos Cortex-M33 do RP2350 completam o handshake mais rápido que os núcleos Cortex-M0+ do RP2040. Rode o script de benchmark deste artigo nas duas placas para ver a diferença na sua rede.

Devo atualizar um projeto existente com Pico W?

Só se você estiver atingindo limites de memória, precisar de reconexões mais rápidas com TLS ou precisar de secure boot. Um projeto Pico W funcionando em uma rede confiável tem pouco a ganhar com a troca.