Archivi tag: apache

Monitoraggio Sensori – Preparazione Ambiente

2019-06-20 admin

Nella impostazione della infrastruttura per il monitoraggio dei sensori costituiti da dispositivi ESP8266 in articoli pubblicati in precedenza

Mqtt con Beaglebone ed ESP8266 – Freeboard

si era impostato Freeboard per la visualizzazione dei dati provenienti dai sensori.

In questa nuova serie di articoli, si intende impostare Grafana

Grafana Dashboard

come ambiente per visualizzare i dati dei vari sensori.

L’ambiente in questo caso lo implementiamo su una scheda Orange Pi PC, ma può essere utilizzato altro sistema arm o pc.

Di seguito l’architettura utilizzata in questa serie di articoli

Nel corso di questi articoli si useranno utenze con il massimo delle autorizzazioni per ciascun ambiente, non si useranno autorizzazioni su mosquitto e non vengono utilizzare connessioni cifrate. In un ambiente di test tale impostazione va bene, ma in un ambiente di esercizio occorre impostare le corrette autorizzazioni e possibilmente le cifrature nelle connessioni in tutti gli ambienti.

Abbiamo installato una versione da noi compilata di Debian 9 Stretch per Orange PI PC. L’immagine usata è la seguente

Download Immagine

E’ stato creato l’utente monitor, mentre l’hostname è stata rinominato in dashboardora. Se non installato procedere ad installare il demone avahi

sudo apt-get install avahi-daemon

1	sudo apt-get install avahi-daemon

In tale modo i servizi sono accessibili tramite la pubblicazione dell’hostname, utilizzando dashboardora.local.

Utilizzando la utility armbian disabilitare ip6 sul sistema; per eseguire tale impostazione lanciare armbian-config

sudo armbian-config

1	sudo armbian-config

Procedere alla disabilitazione dell’ip6

Come primo passo installiamo il broker mqtt mosquitto

sudo apt-get install mosquitto
sudo apt-get install mosquitto-clients

1 2	sudo apt-get install mosquitto sudo apt-get install mosquitto-clients

Installare i servizi http ed i database Mysql e MySqlWorkbench

Apache2

sudo apt-get install apache2

1	sudo apt-get install apache2

e vari prerequisiti

sudo apt-get install libapache2-mod-php

1	sudo apt-get install libapache2-mod-php

Avviare apache

sudo systecmtl start apache2

1	sudo systecmtl start apache2

e controllare che il server risponde all’indirizzo web, che nel nostro caso corrisponde a http://dashboardora.local

MySql

sudo apt-get install mysql-server mysql-client

1	sudo apt-get install mysql-server mysql-client

Con Debian 9 si installa MariaDB; bisogna impostare la password dell’utenza di amministrazione root del database con il seguente comando

sudo systemctl start mysql
sudo mysql_secure_installation

1 2	sudo systemctl start mysql sudo mysql_secure_installation

Impostiamo la password di root e la possibilità di accesso da altri host come root

Il resto delle opzioni scelte sono elencate di seguito

Installiamo phpmyadmin per la gestione del database

sudo apt-get install phpmyadmin

1	sudo apt-get install phpmyadmin

Alla schermata successiva scegliere apache2

Infine scegliere NO

Eseguire i comandi di seguito elencati

sudo mysql -u root -p mysql
update user set plugin=' 'where user='root';
flush privileges;
exit

sudo mysql -u root -p mysql

update user set plugin=' 'where user='root';

flush privileges;

exit

Controllare che il sistema funzioni correttamente accedendo tramite web browser aggiungendo all’indirizzo di apache phpmyadmin, nel nostro caso

http://dashboardora.local/phpmyadmin

Collegarsi con le credenziali di root del database.

Per poter accedere dall’esterno occorre abilitare mariadb ad accettare connessioni da altri host. Per tale scopo accedere in

/etc/mysql/mariadb.conf.d

1	/etc/mysql/mariadb.conf.d

ed editare come root il file 50-server.cnf, modificando l’impostazione

bind-address= 127.0.0.1

1	bind-address= 127.0.0.1

bind-address= 0.0.0.0

1	bind-address= 0.0.0.0

Per consentire all’utente root del database di poter accedere da un client esterno, occorre accedere su mariadb localmente con il suo client ed abilitare tale opzione; si esegue pertanto quanto segue

mysql -u root -p


GRANT ALL PRIVILEGES ON *.* TO 'root'@'%'
IDENTIFIED BY 'password'
WITH GRANT OPTION;
FLUSH PRIVILEGES;
exit

mysql -u root -p

GRANT ALL PRIVILEGES ON *.* TO 'root'@'%'

IDENTIFIED BY 'password'

WITH GRANT OPTION;

FLUSH PRIVILEGES;

exit

Installazione su PC di Mysql Workbench

Accedere al link

MySql Workbench

e scaricare la versione per il proprio sistema operativo per poi procedere alla installazione.

Sulle distribuzioni Linux è presente anche nei repository.

Dopo aver configurato la connessione si accede alla schermata di controllo del systema MySql

Nel prossimo articolo continueremo la installazione degli altri componenti per il monitoraggio dei sensori

Monitoraggio Sensori – Preparazione Ambiente 2

Software, Sviluppo

MicroPython – Esempi nodi con DHT11, Relé ed MQTT

2018-06-16 admin

In una serie di articoli visti in precedenza su Mqtt, Beaglebone ed ESP8266

Mqtt con Beaglebone ed ESP8266 – Lista Articoli

abbiamo creato l’infrastruttura per la gestione dei nodi esp8266.

In questo articolo gestiamo i due nodi esp8266 invece che non Nodemcu e Lua con MicroPython.

Il resto della infrastruttura rimane identica; sul Beaglebone vi è il mqtt Mosquitto e Freeboard per la gestione dei topic mqtt, visualizzazione ed interazione.

Per gli esempi del nodo ESP8266 con relé e sensore DHT11 occorre caricare le librerie MicroPython umqtt, disponibili sul sito

umqtt simple

Negli esempi che seguono si utlizza solo la umqtt simple; nel codice sono stati inseriti vari delay per permettere alla scheda di gestire i messaggi e non incorrere in errori; è stato, inoltre, impostato che nel caso il server mqtt non risponda di riavviare la scheda.

Di seguito il codice utilizzato per gli esempi.

Nodo con sensore DHT11

boot.py: codice eseguito all’avvio

#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: libreria mqtt

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: modulo per la lettura della temperatura ed umidità sul 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: codice eseguito dopo il boot

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

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

client_mqtt.py: Modulo principale per la gestione del nodo

#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(clean_session=False)

      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(clean_session=False)

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: codice di servizio per riavviare il modulo da uPyCraft

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

#Module to reboot the device running it

import machine

machine.reset()

Nodo con relé

boot.py: codice eseguito all’avvio

#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: libreria mqtt

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: codice eseguito dopo il boot
exec(open('./client_mqtt.py').read(),globals())

1

exec(open('./client_mqtt.py').read(),globals())
client_mqtt.py: Modulo principale per la gestione del nodo

#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(clean_session=False)   
    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(clean_session=False)

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: codice di servizio per riavviare il modulo da uPyCraft

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

#Module to reboot the device running it

import machine

machine.reset()

Di seguito il filesystem su ESP8266 per l’esempio del relé

Accedendo a Freeboard si hanno le stesse informazioni ottenute con Nodemcu e LUA

Di seguito le schermate della gestione da Smartphone con MQTT Dashboard, con la possibilità di controllare lo stato del relè, leggere i parametri del sensore e far ripartire o mettere in sleep i due nodi

Questi sono i collegamenti per scaricare i due esempi

Esempio sensore dht11

Esempio relé

Nel prossimo articolo compileremo il firmware MicroPython per ESP8266

MicroPython – Compilazione MicroPython per ESP8266

Configurazione, Software

Mqtt con Beaglebone ed ESP8266 – Freeboard

2017-04-22 admin

Dopo aver installato un client mqtt web

Mqtt con Beaglebone ed ESP8266-Web server e Mqtt websocket

passiamo ad installare la dashboard freeboard

Freeboard

Posizionamoci in /var/www/html sul Beaglebone come root e cloniamo il repository github di freeboard; cambiare il proprietario della cartella freeboard in www-data:www-data

#cd /var/www/html
#git clone https://github.com/Freeboard/freeboard.git freeboard
#chown www-data:www-data -R freeboard

#cd /var/www/html

#git clone https://github.com/Freeboard/freeboard.git freeboard

#chown www-data:www-data -R freeboard

Accedendo con brower sul Beaglebone nella cartella freeboard si accede alla dashboard

Occorre a questo punto inserire dei plugin aggiuntivi a freeboard. Si aggiungono i seguenti plugin

freeboard-mqtt

Clonare il github https://github.com/alsm/freeboard-mqtt

#cd
#git clone https://github.com/alsm/freeboard-mqtt

1 2	#cd #git clone https://github.com/alsm/freeboard-mqtt

Scaricare la libreria javascript mqtt paho

Paho mqtt javascript library

#cd
#git clone https://github.com/eclipse/paho.mqtt.javascript.git

1 2	#cd #git clone https://github.com/eclipse/paho.mqtt.javascript.git

Il link alla libreria è il seguente

Ultima Versione mqttws31.js

Creare una cartella mqtt sotto la cartella plugins di freeboard e copiare i file mqttws31.js e paho.mqtt.plugin.js

#cd /var/www/html/freeboard/plugins/mqtt
# ls
mqttws31.js  paho.mqtt.plugin.js

#cd /var/www/html/freeboard/plugins/mqtt

# ls

mqttws31.js paho.mqtt.plugin.js

Editare il file paho.mqtt.plugin.js ed inserire il riferimento della libreria mqttws31.js nella sezione external_scripts; anche in questo caso cambiare il proprietario per la nuova cartella mqtt ed i suoi contenuti

// # A Freeboard Plugin that uses the Eclipse Paho javascript client to read MQTT messages

(function()
{
        // ### Datasource Definition
        //
        // -------------------
        freeboard.loadDatasourcePlugin({
                "type_name"   : "paho_mqtt",
                "display_name": "Paho MQTT",
        "description" : "Receive data from an MQTT server.",
                "external_scripts" : [
                        "plugins/mqtt/mqttws31.js"
                ],
                "settings"    : [

// # A Freeboard Plugin that uses the Eclipse Paho javascript client to read MQTT messages

(function()

{

// ### Datasource Definition

// -------------------

freeboard.loadDatasourcePlugin({

"type_name" : "paho_mqtt",

"display_name": "Paho MQTT",

"description" : "Receive data from an MQTT server.",

"external_scripts" : [

"plugins/mqtt/mqttws31.js"

"settings" : [

Cambiare il proprietario

#cd /var/www/html/freeboard/plugins
#chown www-data:www-data -R mqtt

1 2	#cd /var/www/html/freeboard/plugins #chown www-data:www-data -R mqtt

Editare il file /var/www/html/freeboard/index.html ed inserire il riferimento al nuovo plugin paho.mqtt.plugin.js nella sezione head.js

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>freeboard</title>
        <meta name="mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-capable" content="yes" />
    <meta name="apple-mobile-web-app-status-bar-style" content="black" />
    <meta name="viewport" content = "width = device-width, initial-scale = 1, user-scalable = no" />
    <link href="css/freeboard.min.css" rel="stylesheet" />
    <script src="js/freeboard.thirdparty.min.js"></script>
    <script type="text/javascript">
        head.js("js/freeboard_plugins.min.js",
                "plugins/mqtt/paho.mqtt.plugin.js",
                // *** Load more plugins here ***
                function(){

<!DOCTYPE html>

<html>

<head>

<title>freeboard</title>

head.js("js/freeboard_plugins.min.js",

"plugins/mqtt/paho.mqtt.plugin.js",

// *** Load more plugins here ***

function(){

Aggiungere il plugin dynamic-highcharts

Clonare in una cartella il github

git clone https://github.com/onlinux/freeboard-dynamic-highcharts-plugin

1	git clone https://github.com/onlinux/freeboard-dynamic-highcharts-plugin

Copiare il file plugin_highcharts.js nella cartella /var/www/html/plugins/thirdparty e cambiare il proprietario

#cd /var/www/html/freeboard/plugins/thirdparty
#chown www-data:www-data plugin_highcharts.js

1 2	#cd /var/www/html/freeboard/plugins/thirdparty #chown www-data:www-data plugin_highcharts.js

Editare anche in questo caso il file /var/www/html/freeboard/index.html ed aggiungere il plugin come fatto al punto precedente

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>freeboard</title>
        <meta name="mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-capable" content="yes" />
    <meta name="apple-mobile-web-app-status-bar-style" content="black" />
    <meta name="viewport" content = "width = device-width, initial-scale = 1, user-scalable = no" />
    <link href="css/freeboard.min.css" rel="stylesheet" />
    <script src="js/freeboard.thirdparty.min.js"></script>
    <script type="text/javascript">
        head.js("js/freeboard_plugins.min.js",
                "plugins/thirdparty/plugin_highcharts.js",
                "plugins/mqtt/paho.mqtt.plugin.js",
                // *** Load more plugins here ***
                function(){

<!DOCTYPE html>

<html>

<head>

<title>freeboard</title>

head.js("js/freeboard_plugins.min.js",

"plugins/thirdparty/plugin_highcharts.js",

"plugins/mqtt/paho.mqtt.plugin.js",

// *** Load more plugins here ***

function(){

Accedere sulla dashboard freeboard ed aggiungere i collegamenti ai topic di temperatura ed umidità come datasource, i gauge per la misura instananea dei valori e la rappresentazione dei valori nel corso del tempo. Di seguito esempi di impostazioni :

Datasource

Gauge

Timeseries

Utilizzando Chrome/Chromium come brower è possibile salvare le impostazioni in un file json. La configurazione può essere caricata localmente dal brower o può essere caricata dal browser dal webserver, salvando ad esempio il file dashboard.json in /var/www/html/freeboard; inserendo l’url

http://beaglebone.local/freeboard/index.html?load=dashboard.json

1	http://beaglebone.local/freeboard/index.html?load=dashboard.json

si accede alla Dashboard.

Di seguito la interfaccia Freeboard con varie widgets che mostrano lo stato e l’andamento dei sensori e relay ESP8266

In questa serie di articolo il Beaglebone è stato configurato in modo da porte accedere utlizzando l’alias beaglebone.local/beaglebone

Preparazione sd card Debian per Beaglebone Black

ma si può usare comunque l’IP del Beaglebone per accedere ai servizi forniti dalla scheda.

Nel prossimo articolo si tratta la configurazione di client Mqtt Android

Mqtt con Beaglebone ed ESP8266 – Client Android

Configurazione, Software

Mqtt con Beaglebone ed ESP8266-Web server e Mqtt Websocket

2017-04-08 admin

Dopo aver configurato il server MQTT ed i nodi ESP8266

Mqtt con Beaglebone ed ESP8266 – Installazione mosquitto su Beaglebone

Mqtt con Beaglebone ed ESP8266-MQTT ESP8266

Mqtt con Beaglebone ed ESP8266-MQTT su ESP8266 per sensore temperatura

Mqtt con Beaglebone ed ESP8266-MQTT su ESP8266 per Relé

passiamo alla configurazione del webserver su Beaglebone ed alla configurazione del websocket sul broker mqtt mosquitto.

Accediamo sul Beaglebone in ssh e disabilitiamo i seguenti servizi

$sudo systemctl stop cloud9.service 
$sudo systemctl stop cloud9.socket 
$sudo systemctl disable cloud9.service
$sudo systemctl disable cloud9.socket
$sudo systemctl stop bonescript-autorun.service
$sudo systemctl stop bonescript.service
$sudo systemctl stop bonescript.socket
$sudo systemctl disable bonescript-autorun.service
$sudo systemctl disable bonescript.service
$sudo systemctl disable bonescript.socket
$sudo systemctl daemon-reload

$sudo systemctl stop cloud9.service

$sudo systemctl stop cloud9.socket

$sudo systemctl disable cloud9.service

$sudo systemctl disable cloud9.socket

$sudo systemctl stop bonescript-autorun.service

$sudo systemctl stop bonescript.service

$sudo systemctl stop bonescript.socket

$sudo systemctl disable bonescript-autorun.service

$sudo systemctl disable bonescript.service

$sudo systemctl disable bonescript.socket

$sudo systemctl daemon-reload

Accedere in /etc/apache2/sites-enabled e modificare in 000-default.conf la porta del webserver da 8080 ad 80

<VirtualHost *:80>

1	<VirtualHost *:80>

In /etc/apache2/port.conf modificare la porta in ascolto da 8080 ad 80

# If you just change the port or add more ports here, you will likely also
# have to change the VirtualHost statement in
# /etc/apache2/sites-enabled/000-default.conf

Listen 80

# If you just change the port or add more ports here, you will likely also

# have to change the VirtualHost statement in

# /etc/apache2/sites-enabled/000-default.conf

Listen 80

Far ripartire il server http con il comando

sudo systemctl restart apache2

1	sudo systemctl restart apache2

Accedere alla configurazione di mosquitto in /etc/mosquitto/conf.d e creare il file websockets.conf con il seguente contenuto

listener 1883
protocol mqtt

listener 9001
protocol websockets

listener 1883

protocol mqtt

listener 9001

protocol websockets

Dopo aver salvato il file far ripartire mosquitto

sudo systemctl restart mosquitto

1	sudo systemctl restart mosquitto

Disabilitiamo l’ipv6 sul Beaglebone come descritto al link

Disabilitazione Ipv6 Debian

Nel file /etc/sysctl.conf aggiungiamo

net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1
net.ipv6.conf.eth0.disable_ipv6 = 1

net.ipv6.conf.all.disable_ipv6 = 1

net.ipv6.conf.default.disable_ipv6 = 1

net.ipv6.conf.lo.disable_ipv6 = 1

net.ipv6.conf.eth0.disable_ipv6 = 1

e facciamo ripartire il Beaglebone.

Procediamo a questo punto ad installare sul server http un client MQTT su websocket e la dashboard Freeboard.

Per quanto concerne il client websocket mqtt hive-mqtt si scarica il codice dal github

Hive mqtt

Accedere come root in ssh sul Beaglebone in /var/www/html; clonare il client sotto mqtt-web e cambiare il proprietario della cartella clonata

#cd /var/www/html/
#git clone https://github.com/hivemq/hivemq-mqtt-web-client.git mqtt-web
#chown www-data:www-data -R mqtt-web

#cd /var/www/html/

#git clone https://github.com/hivemq/hivemq-mqtt-web-client.git mqtt-web

#chown www-data:www-data -R mqtt-web

Se accediamo da brower sul server http in mqtt-web viene mostrato il client web; si inseriscono le informazioni per la connessione

Si inserisco i topic in sottoscrizione e publishing e si hanno i vari messaggi e comandi per il broker

Nel prossimo articolo imposteremo la dashboard Freeboard sul Beaglebone

Mqtt con Beaglebone ed ESP8266 – Freeboard

Micro Devices

Archivi tag: apache

Monitoraggio Sensori – Preparazione Ambiente

MicroPython – Esempi nodi con DHT11, Relé ed MQTT

Mqtt con Beaglebone ed ESP8266 – Freeboard

Mqtt con Beaglebone ed ESP8266-Web server e Mqtt Websocket

Blog dedicato a dispositivi embedded