I have to create a mini IoT Weather Station. I have $3$ types of code that will be run in Visual Studio Code.

First code: main.py

#MQTT subscribe and toggle LED

from machine import Pin,reset,unique$\_$id

from time import sleep

from ubinascii import hexlify

from umqttsimple import MQTTClient

from json import loads #change json data to python

client$\_$id $=$ hexlify$($unique$\_$id$())$

CLIENT$\_$NAME $=$ 'MAA$-$subscriber'

BROKER$\_$ADDR $=$ 'test.mosquitto.org'

apikey$=$'syira'

topic$=$f'gpioms$/\{$apikey$\}\text{'}$

# mqttc $=$ MQTTClient$($CLIENT$\_$NAME, BROKER$\_$ADDR, keepalive$=60)$

mqttc $=$ MQTTClient$($client$\_$id$,$ BROKER$\_$ADDR, keepalive$=60)$

mqttc$.$connect$()$

def ambil$\_$gpio$\_$data$($topic$,$ msg$)$:

try:

json$\_$data$=$msg$.$decode$()$

python$\_$data$=$loads$($json$\_$data$)$

print$($msg$)$

for data in python$\_$data:

state$=$data$[\text{'}$state$\text{'}]$

gpiono$=$data$[\text{'}$gpiono$\text{'}]$

led$=$Pin$($int$($gpiono$),$Pin.OUT$)$

if state$=="1"$:

led.on$()$

print$($f$"$gpio no $\{$gpiono$\}$ is on$")$

elif state$=="0"$:

led.off$()$

print$($f$"$gpio no $\{$gpiono$\}$ is off"$)$

except:

print$("$err$..$ there is some error"$)$

# mqtt subscription

mqttc$.$set$\_$callback$($ambil$\_$gpio$\_$data$)$

mqttc$.$subscribe$($topic$.$encode$())$

while True:

try:

mqttc$.$check$\_$msg$()$

print$(\text{'}.\text{'})$

except:

# print$(\text{'}$Network problem ke$?\text{'})$

reset$()$

print$()$

sleep$(10)$

Second code: umqttsimple.py

try:

import usocket as socket

except:

import 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 & $0$x$7$f$)<<$ sh

if not b & $0$x$80$:

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$"\backslash$x$10\backslash 0\backslash 0\backslash 0\backslash 0\backslash 0")$

msg $=$ bytearray$($b$"\backslash$x$04$MQTT$\backslash$x$04\backslash$x$02\backslash 0\backslash 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]|=0$xC$0$

if self.keepalive:

assert self.keepalive $<65536$

msg$[7]|=$ self.keepalive $>>8$

msg$[8]|=$ self.keepalive & $0$x$00$FF

if self.lw$\_$topic:

sz $+=2+$ len$($self$.$lw$\_$topic$)+2+$ len$($self$.$lw$\_$msg$)$

msg$[6]|=0$x$4|($self$.$lw$\_$qos & $0$x$1)<<3|($self$.$lw$\_$qos & $0$x$2)<<3$

msg$[6]|=$ self.lw$\_$retain $<<5$

i $=1$

while sz $>0$x$7$f:

premsg$[$i$]=($sz & $0$x$7$f$)|0$x$80$

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]==0$x$20$ and resp$[1]==0$x$02$

if resp$[3]!=0$:

raise MQTTException$($resp$[3])$

return resp$[2]$ & $1$

def disconnect$($self$)$:

self.sock.write$($b$"\backslash$xe$0\backslash 0")$

self.sock.close$()$

def ping$($self$)$:

self.sock.write$($b$"\backslash$xc$0\backslash 0")$

def publish$($self$,$ topic, msg$,$ retain$=$False, qos$=0)$:

pkt $=$ bytearray$($b$"\backslash$x$30\backslash 0\backslash 0\backslash 0")$

pkt$[0]|=$ qos $<<1|$ retain

sz $=2+$ len$($topic$)+$ l