Raspberry Pi Pico e Wegnology

Neste artigo, mostrarei como é simples e prático enviar e receber dados utilizando a plataforma Wegnology com MicroPython.

Criando sua conta:

Para começar, acesse *wegnology.io* e crie uma conta.

Configurando um Dispositivo:

Após criar sua conta, registre um novo dispositivo (Device) na plataforma e salve as credenciais fornecidas. Elas serão utilizadas no código que desenvolveremos a seguir.

Agora, vamos para a parte prática: o código!

Crie um arquivo e salve com o nome de: simple.py

Em seguida copie e cole a código abaixo:

import usocket as socket
import ustruct as struct
from ubinascii import hexlify

class MQTTException(Exception):
    pass

class MQTTClient:

    def __init__(self, client_id, server, port=0, user=None, password=None, keepalive=0,
                 ssl=False, ssl_params={}):
        if port == 0:
            port = 8883 if ssl else 1883
        self.client_id = client_id
        self.sock = None
        self.server = server
        self.port = port
        self.ssl = ssl
        self.ssl_params = ssl_params
        self.pid = 0
        self.cb = None
        self.user = user
        self.pswd = password
        self.keepalive = keepalive
        self.lw_topic = None
        self.lw_msg = None
        self.lw_qos = 0
        self.lw_retain = False

    def _send_str(self, s):
        self.sock.write(struct.pack("!H", len(s)))
        self.sock.write(s)

    def _recv_len(self):
        n = 0
        sh = 0
        while 1:
            b = self.sock.read(1)[0]
            n |= (b & 0x7f) << sh
            if not b & 0x80:
                return n
            sh += 7

    def set_callback(self, f):
        self.cb = f

    def set_last_will(self, topic, msg, retain=False, qos=0):
        assert 0 <= qos <= 2
        assert topic
        self.lw_topic = topic
        self.lw_msg = msg
        self.lw_qos = qos
        self.lw_retain = retain

    def connect(self, clean_session=True):
        self.sock = socket.socket()
        addr = socket.getaddrinfo(self.server, self.port)[0][-1]
        self.sock.connect(addr)
        if self.ssl:
            import ussl
            self.sock = ussl.wrap_socket(self.sock, **self.ssl_params)
        premsg = bytearray(b"\x10\0\0\0\0\0")
        msg = bytearray(b"\x04MQTT\x04\x02\0\0")

        sz = 10 + 2 + len(self.client_id)
        msg[6] = clean_session << 1
        if self.user is not None:
            sz += 2 + len(self.user) + 2 + len(self.pswd)
            msg[6] |= 0xC0
        if self.keepalive:
            assert self.keepalive < 65536
            msg[7] |= self.keepalive >> 8
            msg[8] |= self.keepalive & 0x00FF
        if self.lw_topic:
            sz += 2 + len(self.lw_topic) + 2 + len(self.lw_msg)
            msg[6] |= 0x4 | (self.lw_qos & 0x1) << 3 | (self.lw_qos & 0x2) << 3
            msg[6] |= self.lw_retain << 5

        i = 1
        while sz > 0x7f:
            premsg[i] = (sz & 0x7f) | 0x80
            sz >>= 7
            i += 1
        premsg[i] = sz

        self.sock.write(premsg, i + 2)
        self.sock.write(msg)
        #print(hex(len(msg)), hexlify(msg, ":"))
        self._send_str(self.client_id)
        if self.lw_topic:
            self._send_str(self.lw_topic)
            self._send_str(self.lw_msg)
        if self.user is not None:
            self._send_str(self.user)
            self._send_str(self.pswd)
        resp = self.sock.read(4)
        assert resp[0] == 0x20 and resp[1] == 0x02
        if resp[3] != 0:
            raise MQTTException(resp[3])
        return resp[2] & 1

    def disconnect(self):
        self.sock.write(b"\xe0\0")
        self.sock.close()

    def ping(self):
        self.sock.write(b"\xc0\0")

    def publish(self, topic, msg, retain=False, qos=0):
        pkt = bytearray(b"\x30\0\0\0")
        pkt[0] |= qos << 1 | retain
        sz = 2 + len(topic) + len(msg)
        if qos > 0:
            sz += 2
        assert sz < 2097152
        i = 1
        while sz > 0x7f:
            pkt[i] = (sz & 0x7f) | 0x80
            sz >>= 7
            i += 1
        pkt[i] = sz
        #print(hex(len(pkt)), hexlify(pkt, ":"))
        self.sock.write(pkt, i + 1)
        self._send_str(topic)
        if qos > 0:
            self.pid += 1
            pid = self.pid
            struct.pack_into("!H", pkt, 0, pid)
            self.sock.write(pkt, 2)
        self.sock.write(msg)
        if qos == 1:
            while 1:
                op = self.wait_msg()
                if op == 0x40:
                    sz = self.sock.read(1)
                    assert sz == b"\x02"
                    rcv_pid = self.sock.read(2)
                    rcv_pid = rcv_pid[0] << 8 | rcv_pid[1]
                    if pid == rcv_pid:
                        return
        elif qos == 2:
            assert 0

    def subscribe(self, topic, qos=0):
        assert self.cb is not None, "Subscribe callback is not set"
        pkt = bytearray(b"\x82\0\0\0")
        self.pid += 1
        struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, self.pid)
        #print(hex(len(pkt)), hexlify(pkt, ":"))
        self.sock.write(pkt)
        self._send_str(topic)
        self.sock.write(qos.to_bytes(1, "little"))
        while 1:
            op = self.wait_msg()
            if op == 0x90:
                resp = self.sock.read(4)
                #print(resp)
                assert resp[1] == pkt[2] and resp[2] == pkt[3]
                if resp[3] == 0x80:
                    raise MQTTException(resp[3])
                return

    # Wait for a single incoming MQTT message and process it.
    # Subscribed messages are delivered to a callback previously
    # set by .set_callback() method. Other (internal) MQTT
    # messages processed internally.
    def wait_msg(self):
        res = self.sock.read(1)
        self.sock.setblocking(True)
        if res is None:
            return None
        if res == b"":
            raise OSError(-1)
        if res == b"\xd0":  # PINGRESP
            sz = self.sock.read(1)[0]
            assert sz == 0
            return None
        op = res[0]
        if op & 0xf0 != 0x30:
            return op
        sz = self._recv_len()
        topic_len = self.sock.read(2)
        topic_len = (topic_len[0] << 8) | topic_len[1]
        topic = self.sock.read(topic_len)
        sz -= topic_len + 2
        if op & 6:
            pid = self.sock.read(2)
            pid = pid[0] << 8 | pid[1]
            sz -= 2
        msg = self.sock.read(sz)
        self.cb(topic, msg)
        if op & 6 == 2:
            pkt = bytearray(b"\x40\x02\0\0")
            struct.pack_into("!H", pkt, 2, pid)
            self.sock.write(pkt)
        elif op & 6 == 4:
            assert 0

    # Checks whether a pending message from server is available.
    # If not, returns immediately with None. Otherwise, does
    # the same processing as wait_msg.
    def check_msg(self):
        self.sock.setblocking(False)
        return self.wait_msg()

import network
import time
from simple import MQTTClient
import json
import random
from machine import Pin

# led onboard
led_status = Pin("LED", Pin.OUT)

# Configurações de Wi-Fi
SSID = "Rede Wi-Fi 2.4"
PASSWORD = "Senha do Wi-Fi"

# Configurações do Wegnolog
BROKER = "broker.app.wnology.io"
PORT = 1883
ACCESS_KEY = "Chave de Acesso"
ACCESS_SECRET = "Token"
DEVICE_ID = "ID do Device"

# Tópicos
TOPIC_PUBLISH = f"wnology/{DEVICE_ID}/state"
TOPIC_SUBSCRIBE = f"wnology/{DEVICE_ID}/command"

# Conecta ao Wi-Fi
def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(ssid, password)
    print("Conectando ao Wi-Fi...")
    while not wlan.isconnected():
        led_status.value(not led_status.value())
        time.sleep(1)
    print("Conectado:", wlan.ifconfig())

# Callback para mensagens recebidas
def message_callback(topic, msg):
    print(f"Mensagem recebida no tópico {topic}: {msg}")
    try:
        # Decodifica a mensagem para string e converte em JSON
        data = json.loads(msg.decode('utf-8'))

        # Verifica se a chave `payload` existe e extrai o valor
        if 'payload' in data:
            payload_value = data['payload']
            print(f"Valor do payload: {payload_value}")
            led_status.value(payload_value)
        else:
            print("Chave 'payload' não encontrada na mensagem.")

    except json.JSONDecodeError as e:
        print(f"Erro ao decodificar JSON: {e}")


# Publica dados no Wegnolog
def publish_data(client, topic, data):
    payload = json.dumps(data)
    client.publish(topic, payload)
    print(f"Dados enviados: {payload}")

# Função para gerar valores aleatórios de temperatura e umidade
def generate_temperature_humidity():
    temperature = round(random.uniform(-20.0, 60.0), 1)  # Temperatura entre -20.0°C e 35.0°C
    humidity = round(random.uniform(20.0, 100.0), 1)     # Umidade entre 20.0% e 100.0%
    return temperature, humidity

# Configuração principal
try:
    # Realiza a conexão com o Wi-Fi
    connect_wifi(SSID, PASSWORD)

    # Configura o cliente MQTT com Access Key e Secret
    client_id = DEVICE_ID  # Identificação do cliente MQTT
    client = MQTTClient(client_id, BROKER, user=ACCESS_KEY, password=ACCESS_SECRET, port=PORT)
    client.set_callback(message_callback)
    client.connect()

    # Assina o tópico de comandos
    client.subscribe(TOPIC_SUBSCRIBE)
    print(f"Assinado no tópico {TOPIC_SUBSCRIBE}")

    # Loop principal
    while True:
        # Publica um valor simulado (ex.: temperatura e umidade)
        temperatura, umidade = generate_temperature_humidity()
        publish_data(client, TOPIC_PUBLISH,{"data":{"temperatura" : temperatura, "umidade" : umidade}})

        # Aguarda mensagens
        client.check_msg()

        # Atraso antes do próximo envio
        time.sleep(10)

except Exception as e:
    print("Erro:", e)
finally:
    client.disconnect()
    print("Desconectado do MQTT.")

Dashboard:

Dashboard na plataforma Wegnology

Observação: O código da regra de negócio, deverá estar em um arquivo main.py e a biblioteca MQTTClient em outro arquivo simple.py

O arquivo simple.py deve ser transferido para o Microcontrolador Raspberry PI Pico W antes de testar a aplicação.

O código-fonte simula a geração de valores aleatórios de temperatura e umidade, que são enviados automaticamente para a plataforma Wegnology. Além disso, o dispositivo fica em modo de escuta para comandos enviados pela plataforma.

Ao clicar no botão Enviar Comando, é possível controlar o LED onboard do Raspberry Pi Pico, acendendo ou apagando-o conforme o comando recebido.

Essa interação em tempo real demonstra como é fácil integrar sensores e dispositivos com a plataforma Wegnology usando o Raspberry Pi Pico e MicroPython.

Nota Importante:

Este artigo ainda está em desenvolvimento. Em breve, adicionarei novas informações e exemplos mais detalhados para aprimorar a experiência de integração entre o Raspberry Pi Pico e a plataforma Wegnology. Fique atento para as próximas atualizações!

Python é legal!