Tag Archives: micropython

Compilation, Software

ESP32 – MicroPython compiling for ESP32

2018-08-08 admin

We begin now a series of articles about the Espressif ESP32 MCU

ESP32 Wifi-Bluetooth Module

After having analyzed in the previous articles MicroPython for ESP8266, in this we start to treat MicroPython on ESP32.

The following shows how to generate the MicroPython image from the source code for the ESP32 board.

The operating system is Debian 9, previously encountered for the esptool and Adafruit-ampy utilities

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp32 folder

mkdir Micropython
cd Micropython
mkdir esp32
cd esp32

mkdir Micropython

cd Micropython

mkdir esp32

cd esp32

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP32 are available at the link

MicroPython esp32

Clone the repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Go into micropython/ports/esp32 folder

cd micropython/ports/esp32

1	cd micropython/ports/esp32

Run

make

make

The command releases the git hash for the supported espidf

At the time of our compilation the result is as follows

sviluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make
Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.
The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.
See README.md for installation instructions.
Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e
Makefile:34: *** ESPIDF not set.  Stop.

sviluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make

Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.

The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.

See README.md for installation instructions.

Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e

Makefile:34: *** ESPIDF not set. Stop.

Go into /home/sviluppo/Micropython/esp32 folder and clone ESPIDF

git clone https://github.com/espressif/esp-idf.git
cd esp-idf

1 2	git clone https://github.com/espressif/esp-idf.git cd esp-idf

Checkout with the hash obtained above

git checkout 3ede9f011b50999b0560683f9419538c066dd09e

1	git checkout 3ede9f011b50999b0560683f9419538c066dd09e

Run

git submodule update --init

1	git submodule update --init

We follow the instructions at the link

Cross compiler

to install the cross compiler; install the prerequisites for building

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

1	sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

Download the cross compiler

cd /home/sviluppo/Micropython/esp32
wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1 2	cd /home/sviluppo/Micropython/esp32 wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Create the esp folder under /home/sviluppo/Micropython/esp32

cd /home/sviluppo/Micropython/esp32
mkdir esp
cd esp

cd /home/sviluppo/Micropython/esp32

mkdir esp

cd esp

Unpack the cross compiler in esp

tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1	tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Add the binary folder of the cross compiler to the PATH envinronment variable

export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

Go into the following folder

/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

1	/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

and create the makefile file with the following code inside

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf
#PORT = /dev/ttyUSB0
#FLASH_MODE = qio
#FLASH_SIZE = 4MB
#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf

#PORT = /dev/ttyUSB0

#FLASH_MODE = qio

#FLASH_SIZE = 4MB

#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

Go into the micropython folder available in /home/sviluppo/Micropython/esp32

cd micropython

1	cd micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

make -C mpy-cross
git submodule init lib/berkeley-db-1.xx
git submodule update

make -C mpy-cross

git submodule init lib/berkeley-db-1.xx

git submodule update

Finally we can build the ESP32 firmware with the following commands

cd ports/esp32
make

1 2	cd ports/esp32 make

The firmware is generated under ports/esp32/build with the name firmware.bin.

Proceed to load the firmware with the commands

make erase

1	make erase

In our case, the firmware upload was successful with the command

make deploy

1	make deploy

It is also possible to load the firmware.bin image with the commands

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600  write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

where /dev/ttyXXX is replaced with the actual serial port to which we connect the ESP32 board.

In the next article we’ll compile the nodemcu firmware for ESP32

ESP32 – Nodemcu firmware compiling

Compilation, Software

MicroPython – MicroPython compiling for ESP8266 with additional modules

2018-07-04 admin

After the firmware build of the MicroPython firmware for esp8266 in the previous article

MicroPython – MicroPython compiling for ESP8266

we now show how build a module inside the firmware; this option optimizes the module execution and minimizes the size of the same on the device; the module is frozen into the firmware.

With the firmware compiled with the defaults, the following modules are available, listed in the REPL console with the command

help('modules')

1	help('modules')

Now let’s try to compile the firmware with the mqtt modules already inside. For this purpose, the module sources are copied to the umqtt folder under modules

micropython/ports/esp8266/modules/umqtt/simple.py
micropython/ports/esp8266/modules/umqtt/robust.py

1 2	micropython/ports/esp8266/modules/umqtt/simple.py micropython/ports/esp8266/modules/umqtt/robust.py

We proceed to recompile the firmware. From micropython/ports/esp8266 we run the following commands

make clean
make

1 2	make clean make

We can see from the compilation log, that these modules are placed in the frozen state

After uploading this firmware we obtain the following list of modules inside the firmware

It is also possible to create the firmware with the modules not compiled and optimized, by copying the sources in the scripts folder under esp8266; in the specific case the sources must be placed as shown below

micropython/ports/esp8266/scripts/umqtt/simple.py
micropython/ports/esp8266/scripts/umqtt/robust.py

1 2	micropython/ports/esp8266/scripts/umqtt/simple.py micropython/ports/esp8266/scripts/umqtt/robust.py

The modules are always visible in the firmware, but not optimized, so if you need some module it is convenient to copy it on the device during the coding and in the last phase of the project compile the firmware with the frozen modules.

Compilation, Software

MicroPython – MicroPython compiling for ESP8266

2018-06-25 admin

After using in some examples the MicroPython firmware on the ESP8266 board

MicroPython – Nodes examples with DHT11, Relay and MQTT

this article shows how to generate the MicroPython firmware for the ESP8266 board.

The operating system used for this task is Debian 9, already encountered when we analyzed the esptool utility

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp8266 folder

mkdir Micropython
cd Micropython
mkdir esp8266
cd esp8266

mkdir Micropython

cd Micropython

mkdir esp8266

cd esp8266

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP8266 are available at the link

MicroPython esp8266

Clone the repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Download the cross compiler, as described here

Cross compiler

As indicated in the link above, download the source of the cross compiler always from the folder esp8266

git clone --recursive  https://github.com/pfalcon/esp-open-sdk

1	git clone --recursive https://github.com/pfalcon/esp-open-sdk

Install the prerequisites for building

sudo apt-get install make unrar-free autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python-dev python python-serial sed git unzip bash help2man wget bzip2 libtool-bin

1	sudo apt-get install make unrar-free autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python-dev python python-serial sed git unzip bash help2man wget bzip2 libtool-bin

Proceed to the build of the cross compiler with the following commands

cd esp-open-sdk
make STANDALONE=y |& tee make0.log

1 2	cd esp-open-sdk make STANDALONE=y \|& tee make0.log

At the end of the build add the binary folder of the cross compiler to the PATH envinronment variable

export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

Go into the micropython folder available under ~/Micropython/esp8266

cd ~/Micropython/esp8266/micropython

1	cd ~/Micropython/esp8266/micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

make -C mpy-cross

1	make -C mpy-cross

Finally we can build the ESP8266 firmware with the following commands

cd ports/esp8266
make axtls
make

cd ports/esp8266

make axtls

make

The firmware is generated under ports/esp8266/build folder with the name firmware_combined.bin.

Proceed to load the firmware with the command

esptool.py --port /dev/ttyXXX erase_flash

1	esptool.py --port /dev/ttyXXX erase_flash

where /dev/ttyXXX is repalced with the actual serial port to which we connect the ESP8266 board.

In our case, the firmware upload was successful with the command

make PORT=/dev/ttyUSB0 deploy

1	make PORT=/dev/ttyUSB0 deploy

It is also possible to load the firmware_combined.bin image with the command

esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

1	esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

In the next article we’ll analyze how to build the MicroPython firmware adding into the image additional MicroPython modules

MicroPython – MicroPython compiling for ESP8266 with additional modules

Development, Software

MicroPython – Nodes examples with DHT11, Relay and MQTT

2018-06-16 admin

In a series of articles seen previously on Mqtt, Beaglebone and ESP8266

Mqtt with Beaglebone and ESP8266 – Articles List

we have created the infrastructure for managing the ESP8266 nodes .

In this article we program the two ESP8266 nodes using MicroPython instead of Nodemcu and Lua.

The infrastructure remains identical; on the Beaglebone there is Mqtt Mosquitto Server and Freeboard for the management of the mqtt topics, visualization and interaction.

The ESP8266 node examples with relay and DHT11 sensor use the umqtt MicroPython libraries, available on the site

umqtt simple

In the following examples, only the umqtt simple is used; in the code several delays have been inserted to allow the board to manage the messages and not run into errors; in the case the Mqtt server is not available the code restarts the board.

Below the code used for these examples.

Node with DHT11 sensor

boot.py: code executed at startup

#This file is executed on every boot (including wake-boot from deepsleep)
import esp
#esp.osdebug(None)
#Connects to the wifi AP providing a hostname, AP Name and passord
def do_connect():
    import network
    
    sta_if = network.WLAN(network.STA_IF)
    if not sta_if.isconnected():
        print('connecting to network...')
        sta_if.active(True)
		#Sets the device hostname
        sta_if.config(dhcp_hostname='ESP_ROOM1')
        print(sta_if.config('dhcp_hostname'))
		#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD
        sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')
        while not sta_if.isconnected():
            pass
    
    print('network config:', sta_if.ifconfig())
    
#Imports various modules for network, webrepl and garbage collector	
import gc
import webrepl
import network

do_connect()
webrepl.start()
gc.collect()

#This file is executed on every boot (including wake-boot from deepsleep)

import esp

#esp.osdebug(None)

#Connects to the wifi AP providing a hostname, AP Name and passord

def do_connect():

import network

sta_if = network.WLAN(network.STA_IF)

if not sta_if.isconnected():

print('connecting to network...')

sta_if.active(True)

#Sets the device hostname

sta_if.config(dhcp_hostname='ESP_ROOM1')

print(sta_if.config('dhcp_hostname'))

#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD

sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')

while not sta_if.isconnected():

pass

print('network config:', sta_if.ifconfig())

#Imports various modules for network, webrepl and garbage collector

import gc

import webrepl

import network

do_connect()

webrepl.start()

gc.collect()

umqtt/simple.py: mqtt library

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

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

dht11.py: module for reading the temperature and humidity on the GPIO2

#Module to read temperature and humidity with dht11 sensor
import dht
import machine
TPin=2 #GPIO Pin
def temperatura():
  
  d=dht.DHT11(machine.Pin(TPin))

  d.measure()

  temperatura=d.temperature()
  umidita=d.humidity()

  print(d.temperature())
  print(d.humidity())
  return temperatura,umidita

#Module to read temperature and humidity with dht11 sensor

import dht

import machine

TPin=2 #GPIO Pin

def temperatura():

d=dht.DHT11(machine.Pin(TPin))

d.measure()

temperatura=d.temperature()

umidita=d.humidity()

print(d.temperature())

print(d.humidity())

return temperatura,umidita

main.py: code executed after boot

exec(open('./client_mqtt.py').read(),globals())

1	exec(open('./client_mqtt.py').read(),globals())

client_mqtt.py: Main module for node management

#Import module from library umqtt.simple
from umqtt.simple import MQTTClient
#Import Pin definition for esp8266
from machine import Pin
#Import time and machine libraries
import time
import machine
#Import dht11 module
import dht11


#Mosquitto server
#INSERT YOUR MQTT SERVER IP
server="MQTT SERVER IP"




#Define di timeouts
timeouts=2

#Define the topics
ttopic=b"home/room1/temperature" #Temperature Topic
htopic=b"home/room1/humidity" #Humidity Topic
stopic=b"home/room1/status"  #Status Topic
ctopic=b"home/room1/command" #Command Topic   
mtopic=b"home/room1/monitor"#Monitor Topic

#Send status to status topic
def send_status(message):
  c.publish(stopic, message)  


#Sets the sleep mode
def esp_sleep(secondi):
  rtc=machine.RTC()
  rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
  send_status("Sensor going to sleep now")
  time.sleep(timeouts)
  send_mstatus("Sensor going to sleep now")
  
  rtc.alarm(rtc.ALARM0,secondi*1000)
  machine.deepsleep()
  


#Send status to status monitor topic
def send_mstatus(message):
  c.publish(mtopic, message)  
 

# Received messages from subscriptions will be delivered to this callback
def sub_cb(topic, msg):
    if topic == b"home/room1/command":
     
      if msg == b"Restart":
        send_status("Restarting")
        time.sleep(timeouts)
        machine.reset()
      elif msg == b"":
        send_status("Command not valid") 
        
      else:
        i=len(msg)
        dato=msg[:5]
        if dato== b"Sleep":

          tsleep=int(msg[6:i])

          
          if tsleep is not None:
            if tsleep >= 1:
              
              esp_sleep(tsleep)
              
            else:
              send_status("Sleep command error")  
            
          else:
            send_status("Command not valid")
                                 
        else: 
          send_status("Command not valid")
             
    else:
      print("Other command")

      
    
   
#Connects to the various topics 
def connetti():
  while True:
    try:
      c.connect()

      c.subscribe(ttopic)
      c.subscribe(htopic)
      c.subscribe(ctopic)
      c.subscribe(stopic)
      c.subscribe(mtopic)
      send_status("Sensor Ready Again")
      time.sleep(3*timeouts) 
      break
    except:
      #If it is not able to connect to mosquitto restart the device
     
      time.sleep(5*timeouts)
      machine.reset()  
    finally:
      time.sleep(5)
     
      
#Publish to different topics (temp and hum) 
def pubblica(topic,message): 
 c.publish(topic, message) 
  
#Define the mqtt client. callback method and connects to mqtt    
c = MQTTClient("room1", server)
c.set_callback(sub_cb)
connetti()


#Variables to manage the monitor and when send the temperature
monitor=False
inviatemp=True

#Main iteration 
while True:
  try:
    if monitor == True:          
      #Send status to monitor topic  
      send_mstatus("Sensor Ready")      
      #Sleep the esp8266 otherwise we get errors as it is not able to process quickly the requests
      time.sleep(5*timeouts)
      monitor=False
    elif monitor==False:
      monitor=True 
      
    #check the messages from topics    
    # Non-blocking wait for message
    try:  
      c.check_msg()
    except:
       time.sleep(5*timeouts)
       machine.reset()
    
    temp,hum=dht11.temperatura()
    
      
    #Turns temp into a string
    temperatura=str(temp)
    
    #Sleep the esp8266 otherwise we get errors as it is not able to process quickly the requests  
    time.sleep(5*timeouts)    

    #Turns hum into a string
    umidita=str(hum)
    
    #Check if to send temperature or humidity values to the topics
    if inviatemp == True:
      
      pubblica(ttopic,temperatura) 
      inviatemp=False
    else:  
      pubblica(htopic,umidita) 
      inviatemp=True
    
    time.sleep(10*timeouts)
    
    #Finally clause at the end of the try to catch other incoming messages from topics
  finally:
    time.sleep(5*timeouts)
    
    try:  
      c.check_msg()
    except:
      
      time.sleep(10*timeouts)
      machine.reset()
   
  
    
c.disconnect()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

#Import module from library umqtt.simple

from umqtt.simple import MQTTClient

#Import Pin definition for esp8266

from machine import Pin

#Import time and machine libraries

import time

import machine

#Import dht11 module

import dht11

#Mosquitto server

#INSERT YOUR MQTT SERVER IP

server="MQTT SERVER IP"

#Define di timeouts

timeouts=2

#Define the topics

ttopic=b"home/room1/temperature" #Temperature Topic

htopic=b"home/room1/humidity" #Humidity Topic

stopic=b"home/room1/status" #Status Topic

ctopic=b"home/room1/command" #Command Topic

mtopic=b"home/room1/monitor"#Monitor Topic

#Send status to status topic

def send_status(message):

c.publish(stopic, message)

#Sets the sleep mode

def esp_sleep(secondi):

rtc=machine.RTC()

rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)

send_status("Sensor going to sleep now")

time.sleep(timeouts)

send_mstatus("Sensor going to sleep now")

rtc.alarm(rtc.ALARM0,secondi*1000)

machine.deepsleep()

#Send status to status monitor topic

def send_mstatus(message):

c.publish(mtopic, message)

# Received messages from subscriptions will be delivered to this callback

def sub_cb(topic, msg):

if topic == b"home/room1/command":

if msg == b"Restart":

send_status("Restarting")

time.sleep(timeouts)

machine.reset()

elif msg == b"":

send_status("Command not valid")

else:

i=len(msg)

dato=msg[:5]

if dato== b"Sleep":

tsleep=int(msg[6:i])

if tsleep is not None:

if tsleep >= 1:

esp_sleep(tsleep)

else:

send_status("Sleep command error")

else:

send_status("Command not valid")

else:

send_status("Command not valid")

else:

print("Other command")

#Connects to the various topics

def connetti():

while True:

try:

c.connect()

c.subscribe(ttopic)

c.subscribe(htopic)

c.subscribe(ctopic)

c.subscribe(stopic)

c.subscribe(mtopic)

send_status("Sensor Ready Again")

time.sleep(3*timeouts)

break

except:

#If it is not able to connect to mosquitto restart the device

time.sleep(5*timeouts)

machine.reset()

finally:

time.sleep(5)

#Publish to different topics (temp and hum)

def pubblica(topic,message):

c.publish(topic, message)

#Define the mqtt client. callback method and connects to mqtt

c = MQTTClient("room1", server)

c.set_callback(sub_cb)

connetti()

#Variables to manage the monitor and when send the temperature

monitor=False

inviatemp=True

#Main iteration

while True:

try:

if monitor == True:

#Send status to monitor topic

send_mstatus("Sensor Ready")

#Sleep the esp8266 otherwise we get errors as it is not able to process quickly the requests

time.sleep(5*timeouts)

monitor=False

elif monitor==False:

monitor=True

#check the messages from topics

# Non-blocking wait for message

try:

c.check_msg()

except:

time.sleep(5*timeouts)

machine.reset()

temp,hum=dht11.temperatura()

#Turns temp into a string

temperatura=str(temp)

#Sleep the esp8266 otherwise we get errors as it is not able to process quickly the requests

time.sleep(5*timeouts)

#Turns hum into a string

umidita=str(hum)

#Check if to send temperature or humidity values to the topics

if inviatemp == True:

pubblica(ttopic,temperatura)

inviatemp=False

else:

pubblica(htopic,umidita)

inviatemp=True

time.sleep(10*timeouts)

#Finally clause at the end of the try to catch other incoming messages from topics

finally:

time.sleep(5*timeouts)

try:

c.check_msg()

except:

time.sleep(10*timeouts)

machine.reset()

c.disconnect()

riavvia.py: service code to restart the module from uPyCraft

#Module to reboot the device running it
import machine
machine.reset()

#Module to reboot the device running it

import machine

machine.reset()

Node with relay

boot.py: code executed at startup

#This file is executed on every boot (including wake-boot from deepsleep)
import esp
#esp.osdebug(None)
#Connects to the wifi AP providing a hostname, AP Name and passord
def do_connect():
    import network
    
    sta_if = network.WLAN(network.STA_IF)
    if not sta_if.isconnected():
        print('connecting to network...')
        sta_if.active(True)
		#Sets the device hostname
        sta_if.config(dhcp_hostname='ESP_RELAY1')
        print(sta_if.config('dhcp_hostname'))
		#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD
        sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')
        while not sta_if.isconnected():
            pass
    
    print('network config:', sta_if.ifconfig())
    
#Imports various modules for network, webrepl and garbage collector	
import gc
import webrepl
import network

do_connect()
webrepl.start()
gc.collect()

#This file is executed on every boot (including wake-boot from deepsleep)

import esp

#esp.osdebug(None)

#Connects to the wifi AP providing a hostname, AP Name and passord

def do_connect():

import network

sta_if = network.WLAN(network.STA_IF)

if not sta_if.isconnected():

print('connecting to network...')

sta_if.active(True)

#Sets the device hostname

sta_if.config(dhcp_hostname='ESP_RELAY1')

print(sta_if.config('dhcp_hostname'))

#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD

sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')

while not sta_if.isconnected():

pass

print('network config:', sta_if.ifconfig())

#Imports various modules for network, webrepl and garbage collector

import gc

import webrepl

import network

do_connect()

webrepl.start()

gc.collect()

umqtt/simple.py: mqtt library

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

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

- main.py: code executed after boot
exec(open('./client_mqtt.py').read(),globals())

1

exec(open('./client_mqtt.py').read(),globals())
- client_mqtt.py: Main module for node management

#Import module from library umqtt.simple
from umqtt.simple import MQTTClient
#Import Pin definition for esp8266
from machine import Pin
#Import time and machine libraries
import time
import machine



#Mosquitto server
#INSERT YOUR MQTT SERVER IP
server="MQTT SERVER IP"


#ESP Pin for the relay
Rpin = Pin(5, Pin.OUT, value=0) #Relay Pin


#Define di timeouts
timeouts=2
#Define the topics

stopic=b"home/relay1/status"  #Status Topic
ctopic=b"home/relay1/command" #Command Topic   
mtopic=b"home/relay1/monitor"#Monitor Topic


#Send status to status topic
def send_status(message):  
  c.publish(stopic, message)  

#Send status to status monitor topic 
def send_mstatus(message):  
  c.publish(mtopic, message) 
   
#Sets the sleep mode  
def esp_sleep(secondi):
  rtc=machine.RTC()
  rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
  send_status("Relay going to sleep now")
  time.sleep(timeouts)
  send_mstatus("Relay going to sleep now")
  time.sleep(timeouts)
  rtc.alarm(rtc.ALARM0,secondi*1000)
  machine.deepsleep()
  


  
#Send relay status and turn it ON
def relay_on():
  send_status("Relay ON")
  Rpin.on()    
#Send relay status and turn it OFF   
def relay_off():
  send_status("Relay OFF")
  Rpin.off() 
 #Check the relay status and send it to the status topic
def relay_status():
  if Rpin.value() == 0:
    send_status("Relay OFF")
    
  else:
    send_status("Relay ON")
   

# Received messages from subscriptions will be delivered to this callback
def sub_cb(topic, msg):
    if topic == b"home/relay1/command":
 
      if msg == b"Restart":
        send_status("Restarting")
        time.sleep(timeouts)
        machine.reset()
      elif msg == b"":
        send_status("Command not valid")
       
      elif msg == b"ON":
        relay_on()
      
      elif msg == b"OFF":
        relay_off() 
      
      elif msg == b"Status":
        relay_status() 
        
      else:
        i=len(msg)
        
        dato=msg[:5]
        if dato== b"Sleep":
         
          tsleep=int(msg[6:i])
         
          
          if tsleep is not None:
            if tsleep >= 1:
              
              esp_sleep(tsleep)
              
            else:
              send_status("Sleep command error")  
            
          else:
            send_status("Command not valid")
                                 
        else: 
          send_status("Command not valid")
             
    else:
      print("Other command")      
     
      
    
   
#Connects to the various topics     
def connetti():
  try:  
    c.connect()   
    c.subscribe(ctopic)  
    time.sleep(3*timeouts)
    c.subscribe(stopic)
    time.sleep(3*timeouts)  
    c.subscribe(mtopic)  
    time.sleep(3*timeouts)
    send_status("Relay Ready Again")  
    time.sleep(3*timeouts)
  except:
       #If it is not able to connect to mosquitto restart the device
      time.sleep(5*timeouts)
      machine.reset()
    
   
  
#Define the mqtt client. callback method and connects to mqtt      
c = MQTTClient("relay1", server)
c.set_callback(sub_cb)
connetti()

#Variables to manage the monito
monitor=False

#Main iteration 
while True:  
  try:    
    if monitor == True:        #Send status to monitor topic      
      send_mstatus("Relay Ready")      
      time.sleep(timeouts)      
      monitor=False    
    elif monitor==False:      
      monitor=True           
    #check the messages from topics        # Non-blocking wait for message   
    try:  
      c.check_msg()
    except:
      
       time.sleep(5*timeouts)
       machine.reset()
    
        
    time.sleep(5*timeouts)    
          
  #Finally clause at the end of the try to catch other incoming messages from topics      
  finally:    
    time.sleep(timeouts) 
     
    try:  
      c.check_msg()
    except:
      time.sleep(5*timeouts)
      machine.reset()
      
             
c.disconnect()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

#Import module from library umqtt.simple

from umqtt.simple import MQTTClient

#Import Pin definition for esp8266

from machine import Pin

#Import time and machine libraries

import time

import machine

#Mosquitto server

#INSERT YOUR MQTT SERVER IP

server="MQTT SERVER IP"

#ESP Pin for the relay

Rpin = Pin(5, Pin.OUT, value=0) #Relay Pin

#Define di timeouts

timeouts=2

#Define the topics

stopic=b"home/relay1/status" #Status Topic

ctopic=b"home/relay1/command" #Command Topic

mtopic=b"home/relay1/monitor"#Monitor Topic

#Send status to status topic

def send_status(message):

c.publish(stopic, message)

#Send status to status monitor topic

def send_mstatus(message):

c.publish(mtopic, message)

#Sets the sleep mode

def esp_sleep(secondi):

rtc=machine.RTC()

rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)

send_status("Relay going to sleep now")

time.sleep(timeouts)

send_mstatus("Relay going to sleep now")

time.sleep(timeouts)

rtc.alarm(rtc.ALARM0,secondi*1000)

machine.deepsleep()

#Send relay status and turn it ON

def relay_on():

send_status("Relay ON")

Rpin.on()

#Send relay status and turn it OFF

def relay_off():

send_status("Relay OFF")

Rpin.off()

#Check the relay status and send it to the status topic

def relay_status():

if Rpin.value() == 0:

send_status("Relay OFF")

else:

send_status("Relay ON")

# Received messages from subscriptions will be delivered to this callback

def sub_cb(topic, msg):

if topic == b"home/relay1/command":

if msg == b"Restart":

send_status("Restarting")

time.sleep(timeouts)

machine.reset()

elif msg == b"":

send_status("Command not valid")

elif msg == b"ON":

relay_on()

elif msg == b"OFF":

relay_off()

elif msg == b"Status":

relay_status()

else:

i=len(msg)

dato=msg[:5]

if dato== b"Sleep":

tsleep=int(msg[6:i])

if tsleep is not None:

if tsleep >= 1:

esp_sleep(tsleep)

else:

send_status("Sleep command error")

else:

send_status("Command not valid")

else:

send_status("Command not valid")

else:

print("Other command")

#Connects to the various topics

def connetti():

try:

c.connect()

c.subscribe(ctopic)

time.sleep(3*timeouts)

c.subscribe(stopic)

time.sleep(3*timeouts)

c.subscribe(mtopic)

time.sleep(3*timeouts)

send_status("Relay Ready Again")

time.sleep(3*timeouts)

except:

#If it is not able to connect to mosquitto restart the device

time.sleep(5*timeouts)

machine.reset()

#Define the mqtt client. callback method and connects to mqtt

c = MQTTClient("relay1", server)

c.set_callback(sub_cb)

connetti()

#Variables to manage the monito

monitor=False

#Main iteration

while True:

try:

if monitor == True: #Send status to monitor topic

send_mstatus("Relay Ready")

time.sleep(timeouts)

monitor=False

elif monitor==False:

monitor=True

#check the messages from topics # Non-blocking wait for message

try:

c.check_msg()

except:

time.sleep(5*timeouts)

machine.reset()

time.sleep(5*timeouts)

#Finally clause at the end of the try to catch other incoming messages from topics

finally:

time.sleep(timeouts)

try:

c.check_msg()

except:

time.sleep(5*timeouts)

machine.reset()

c.disconnect()

riavvia.py: service code to restart the module from uPyCraft

#Module to reboot the device running it
import machine
machine.reset()

#Module to reboot the device running it

import machine

machine.reset()

Below is the filesystem on ESP8266 for the relays sample

By accessing Freeboard we have the same informations obtained with Nodemcu and LUA on ESP8266 nodes

Below are the screens with MQTT Dashboard installed on an Android smartphone, with the possibility to check the status of the relay, read the sensor parameters, restart and sleep the two nodes

Here are the links to download the two examples

DHT11 sensor sample

Relay sample

In the next article we will compile the MicroPython firmware for ESP8266

MicroPython – MicroPython compiling for ESP8266

Development, Software

MicroPython – MicroPython program structure

2018-06-02 admin

After reviewing various development tools for MicroPython in previous articles

MicroPython – Development tools Ampy – Eric

MicroPython IDE uPyCraft

in this article we briefly describe the main features of MicroPython. In particular, we examine the documentation relating to the ESP8266, but the concepts can also be extended to the other boards.

The documentation on the ESP8266 soc and MicroPython is available at the link

ESP8266 MicroPython Documentation

At the link we can find all the informations necessary to implement the code on the card and the features of MicroPython as well as the differences compared to Python.

Here are the main points for coding in MicroPython:

MicroPython has a REPL (Read Evaluate Print Loop) console through the serial port to which the device is connected on which we can give the various MicroPython commands interactively.

The REPL console can also be accessed via connection to the IP address of the device by enabling the WEBREPL (Web Browser Interactive prompt) console

WebREPL Documentation

importing the webrepl package, enabling it and starting it at each device restart. To access the configured device, we can use the link

WEBREPL Access

or locally cloning it from github

git clone https://github.com/micropython/webrepl

1	git clone https://github.com/micropython/webrepl

At the start of the device the system runs boot.py and after main.py.

The MicroPython libraries are available on the github at the link

MicroPython libraries

Additional packages

The additional modules can be downloaded from the link of the libraries presented above or downloaded with the upip utility (Package Manager) from the REPL console if available in the Python Package Index (PyPI) repository

PYPI

as described below

upip

Below is a simple example that connects to the router and allows us to access the MicroPython console with the browser and WEBREPL.

boot.py code

#This file is executed on every boot (including wake-boot from deepsleep)
import esp
#esp.osdebug(None)
#Connects to the wifi AP providing a hostname, AP Name and passord
def do_connect():
    import network
    
    sta_if = network.WLAN(network.STA_IF)
    if not sta_if.isconnected():
        print('connecting to network...')
        sta_if.active(True)
		#Sets the device hostname
        sta_if.config(dhcp_hostname='ESP_TEST')
        print(sta_if.config('dhcp_hostname'))
		#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD
        sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')
        while not sta_if.isconnected():
            pass
    
    print('network config:', sta_if.ifconfig())
    
#Imports various modules for network, webrepl and garbage collector	
import gc
import webrepl
import network

do_connect()
webrepl.start()
gc.collect()

#This file is executed on every boot (including wake-boot from deepsleep)

import esp

#esp.osdebug(None)

#Connects to the wifi AP providing a hostname, AP Name and passord

def do_connect():

import network

sta_if = network.WLAN(network.STA_IF)

if not sta_if.isconnected():

print('connecting to network...')

sta_if.active(True)

#Sets the device hostname

sta_if.config(dhcp_hostname='ESP_TEST')

print(sta_if.config('dhcp_hostname'))

#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD

sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')

while not sta_if.isconnected():

pass

print('network config:', sta_if.ifconfig())

#Imports various modules for network, webrepl and garbage collector

import gc

import webrepl

import network

do_connect()

webrepl.start()

gc.collect()

At the first access it is required to enable webrepl to be executed in the REPL console with the command

import webrepl_setup

1	import webrepl_setup

we can activate the service and the access password.

The procedure generates the webrepl_cfg.py file on the device.

After setting up and restarting, we access the web console by opening the locally cloned webrepl.html file with a browser

Pressing connect and after entering the password ,set in the initial setup, we access the console

Now we install from the WEBREPL console, for example, the stat module using upip

import upip 
upip.install("micropython-stat")

1 2	import upip upip.install("micropython-stat")

To paste commands execute Ctrl+A e Ctrl+V

In this case the package was taken from the PYPI repository, unpacked and installed on the device.

We have noticed that some modules, although available on the repository, give an error during installation with upip; these modules are installed directly without using the upip utility,but by downloading the library from the site listed above and transferring the code to the device.

Here is the link of the code shown above

Webreplsample

Another option available is to build the firmware with the required modules.

In the next article we will examine examples similar to what was done with LUA on ESP8266 in previous articles

MicroPython – Nodes examples with DHT11, Relay and MQTT

Development, Installation, Software

Micropython – Development tools Ampy – Eric

2018-05-29 admin

After the uPyCraft intallation in the previous article

MicroPython – IDE MicroPython uPyCraft

let’s now look at other tools available for the development in MicroPython for various platforms.

This article shows the operations to be performed on Windows and Linux.

First Python package to install is Ampy (Adafruit MicroPython Tool)

ampy

The tool is available in the python repositories, so it can be installed using the pip tool.

In Windos run in a dos command prompt

pip install adfruit-ampy

1	pip install adfruit-ampy

Similarly in Linux run in a shell

sudo pip3 install adafruit-ampy

1	sudo pip3 install adafruit-ampy

The available commands are listed running

ampy --help

1	ampy --help

Ampy allows the transfer, creation, viewing, and execution of files on the device.

As for the IDE you can install Eric, generic Python IDE

Eric

Eric does not allow communication from the IDE with the device as seen with uPyCraft; this task is delegated to Ampy. For the installation proceed as follows:

For Linux Debian 9 just run

sudo apt-get install eric

1	sudo apt-get install eric

The tool is available among the development tools; at the first execution it requires default settings

We define the workspace location

and we have the access to the IDE

For Windows download the zip

Eric

Unzip the zip into a folder from which we run it; install the prerequisites

pip install pyqt5-tools
pip install qscintilla

1 2	pip install pyqt5-tools pip install qscintilla

Perform the eric installation at this point by double clicking on install.py

The program checks the prerequisites and completes the installation

Clicking twice on eric6.py or running eric6 from a dos command prompt we run the program in the same way as seen for Linux Debian

In the next article we will briefly examine how a MicroPython program is structured

MicroPython – MicroPython program structure

Development, Installation, Software

Micropython – MicroPython IDE uPyCraft

2018-04-27 admin

After installing the firmware on the Nodemcu esp8266 DevKit board

MicroPython Firmware

let us now examine a development tool can be suitable for the development of Python code.

A tool that allows both to write code and upload it to the device is uPyCraft

uPyCraft

The tool currently works for Windows and from version 0.30 is also available for Linux; the source code is available at the link

uPyCraft Source

Here are the steps for Windows and Linux.

Windows

Once downloaded the package we must run it as an administrator; the installation of the Monaco font is required

After the font installation, we have the access to the IDE

We set the Location in Tools->Preferences->Language Location

and the serial port paramenters in Tools->Preferences->Serial

We plug the device into an USB port and set the serial port on uPyCraft

We choose the device type; in this case it is ESP8266

By clicking on the connection icon we access to the device and view the files on it

The firmware installation expands on the device only the Python file boot.py

The tool allows to download examples of MicroPython code for the board, blink.py for example

Clicking the “Download and Run” button we load the code onto the device and run it

In this example the led of the Nodemcu DevKit blinks.

Linux

The tool is similar in the Linux version; once downloaded the package to which we have to assign the execution right we run it. We must assign to the user the access to the serial port with the command, already seen above

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

In our case, on Debian 9, we have the following screens similar to what we saw on Windows.

In the uPyCraft IDE

We set the Location in Tools->Preferences->Language Location

and the serial port paramenters in Tools->Preferences->Serial

We plug the device into an USB port and set the serial port on uPyCraft

We choose the device type; in this case it is ESP8266

By clicking on the connection icon we access to the device and view the files on it

The firmware installation expands on the device only the Python file boot.py

The tool allows to download examples of MicroPython code for the board, blink.py for example

Clicking the “Download and Run” button we load the code onto the device and run it

As in Windows the led of the Nodemcu DevKit blinks..

In version 0.30 for Windows we noticed some bugs, so for this operating system we continue to use the uPyCraft version 0.29.

Further informations about uPyCraft can be found at the following site

uPyCraft Documentation

In the next article we will discuss another Python development tool

MicroPython – Development tools Ampy – Eric

Installation, Software

MicroPython – Python on embedded devices

2018-04-26 admin

In this article we begin to treat MicroPython

MicroPython

an implementation of Python3

Python

for embedded devices.

Various images are available on the MicroPython website for different devices, including the modules esp8266 and esp32

MicroPython Dowloads

We start our tests with a Nodemcu esp8266 DevKit

Nodemcu Devkit

We proceed to load the firmware on this card.

The Micropython site also refers how to load the firmware on the cards; these informations are available at the link

MicroPython Tutorial for esp8266

To load the firmware we always use the tool esptool, also available on the Python repository.

To be able to use it, we need to install Python3 on our development platform. Here are the steps to follow for Windows and Linux.

Windows

For windows we must first install the Python3 environment, available at the following link

Python for Windows

In our case, we downloaded the version 3.6.4 for 64-bit systems. We installed the package with administrative rights

After proceeding to add Python in the Path we click “Install Now”

After the installation, we open a dos command propmt and check the installed Python version

Always from the dos command prompt we proceed to the installation of esptool with the command

pip install esptool

1	pip install esptool

At this point we can proceed to the MicroPython firmware upload on the Nodemcu esp8266 DevKit. Of course, it is necessary to have the serial-ttl drivers installed for your DevKit model on Windows. Now go into the folder where the firmware has been downloaded and run the following commands from the dos command prompt

esptool.py --port COMPORT erase_flash

1	esptool.py --port COMPORT erase_flash

Proceed to load the firmware

esptool.py --port COMPORT --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

1	esptool.py --port COMPORT --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

Once the firmware is installed we log on the Python console using, in our case with the nodemcu card DevKit, the same port already used to load the firmware.

On Windows we can use Putty

Putty

and set the serial connection to 115200 baud rates

Linux

For Linux we use the Debian 9 distribution, but the procedure can be extended to other distributions. After installing Debian 9 , similar to version 8

Debian 8

we proceed to the installation of Python3 and esptool from a Linux shell

sudo apt-get install python3
sudo apt-get install python3-pip

1 2	sudo apt-get install python3 sudo apt-get install python3-pip

Add the user used on Debian to the dialout group

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

In our case, using sviluppo as a user, the command is as follows

sudo usermod -a -G dialout sviluppo

1	sudo usermod -a -G dialout sviluppo

Let’s move on to install the Python esptool package

sudo pip3 install esptool

1	sudo pip3 install esptool

We can then proceed with the installation of the firmware in the same way as done on Windows.

We check on which serial port the card is available (ttyUSBX)

We perform a flash erase and firmware upload

esptool.py --port /dev/ttyUSBX erase_flash

1	esptool.py --port /dev/ttyUSBX erase_flash

esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

1	esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

To log on the DevKit we use screen

sudo apt-get install screen

1	sudo apt-get install screen

Here is the manual of the tool

Screen Manual

screen /dev/ttyUSB0 115200

1	screen /dev/ttyUSB0 115200

To detach from screen press

Ctrl+a+d

Ctrl+a+d

instead to resume run

screen -r

screen -r

To quit screen

killall screen

1	killall screen

Once connected you get the same result as Windows

In the next article we will begin to see which IDEs can be used to create and load our Python code

MicroPython IDE uPyCraft

Hardware

ESP32 Wifi-Bluetooth Module

2018-04-23 admin

In this article we describe briefly the ESP32 chip from Espressif

ESP32

This lower power SOC contains a 32 bit MCU with bluetooth and wifi modules. At the Espressif web site we can find the detailed informations about the ESP32

ESP32 Resources

The device datasheet is available in the following pdf document

ESP32 Datasheet

The ESP32 modules are available individually or in a development kits; the last system simplifies its usage as the development kit contains all the hardware to use rapidly the soc device; we are already ready to load the firmware and use the device.

On internet various web sites describe home automation or iot projects using this soc.

A reference site for the ESP32 is

esp32

At above link we can find the various development platforms utilized for the ESP32. The most relevant are