Tag Archives: texas instruments

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

Configuration, Software

Mqtt with Beaglebone and ESP8266 – Articles List

2017-05-21 admin

Below is a list of the articles to follow to build your IOT environment consisting of sensors and relays with Beaglebone, ESP8266 and MQTT Mosquitto server.

Configuration, Software

Mqtt with Beaglebone and ESP8266 – Android Client

2017-05-05 admin

After Mosquitto server, ESP8266 nodes and Freeboard configuration

Mqtt with Beaglebone and ESP8266-Mosquitto installation on Beaglebone

MQTT with BeagleBone and ESP8266-MQTT ESP8266

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with temperature sensor

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with Relay

Mqtt with Beaglebone and ESP8266 – Freeboard

now we can proceed to use a Mqtt Client on an Android device.

In the Playstore various Mqtt applications are available

After the publishing and subscriber topics configuration in the Android client , analogous to what has been done for Freeboard widgets

Mqtt with Beaglebone and ESP8266 – Freeboard

it is possible to monitor the sensor temperature and humidity, the devices status and send commands to the relay (Turn On, Turn Off, Status, Restart, Sleep) and to the sensor (Restart, Sleep, Status).

Here is a screenshot with some subcriber topic and publisher topics of our installation using MQTT Dashboard

With the relay on

Configuration, Software

Mqtt with Beaglebone and ESP8266 – Freeboard

2017-04-22 admin

After the Mqtt web client installation

MQTT with Beaglebone and ESP8266 – WebServer and MQTT WebSocket

let’s install now the dashboard freeboard

Freeboard

In a ssh commad shell go into the /var/www/html folder on Beaglebone as root and clone the freeboard github respository; change the owner of the freeboard folder 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

With a web browser go to the freeboard folder on Beaglebone webserver to access the dashboard

We have to add now Freeboard additional plugins. We add the following

freeboard-mqtt

Clone the https://github.com/alsm/freeboard-mqtt github

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

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

Download the mqtt paho javascript library

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

Here is the direct link to the library

Last Version mqttws31.js

Create the mqtt folder under the Freeboard plugins folder and copy the mqttws31.js and paho.mqtt.plugin.js files

#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

Edit the paho.mqtt.plugin.js file and insert the reference to the mqttws31.js library in the external_scripts section; in this case too we have to change the folder and contents owner

// # 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" : [

Change the owner

#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

Edit the /var/www/html/freeboard/index.html file and insert the reference to the paho.mqtt.plugin.js plugin in the heads.js section

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

Add the dynamic-highcharts plugin

Clone in a folder the github

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

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

Copy the plugin_highcharts.js to the folder /var/www/html/plugins/thirdparty and change the owner

#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

Edit again the file /var/www/html/freeboard/index.html and add the plugin as done above

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

Access now the Freeboard dashboard and add the links to the temperature and humidity topics, the gauges and timeseries mesauring the values in real time and in a specific range of time . Here are some settings:

Datasource

Gauge

Timeseries

Chrome/Chromium browser allows to save the settings in a json file. This settings can be loaded locally or loaded from the web server, saving for example the dashboard.json file in /var/www/html/freeboard, with the url

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

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

The image shows the Freeboad interface with various widgets showing the status and timeseries of the ESP8266 relay and sensors

In these series of articles we configured the envinronment to access the Beaglebone using the beaglebone.local/beaglebone alias

Debian sd card setup for Beaglebone Black

but you can use anyway the Beaglebone IP tho access the services provided by the board.

In the next article we’ll treat the Mqtt Android client

Mqtt with Beaglebone and ESP8266 – Android Client

Configuration, Software

MQTT with BeagleBone and ESP8266 – WebServer and MQTT WebSocket

2017-04-08 admin

After the MQTT server and ESP8266 nodes configurations

MQTT with BeagleBone and ESP8266 – Mosquitto installation on Beaglebone

MQTT with BeagleBone and ESP8266-MQTT ESP8266

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with temperature sensor

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with Relay

we analize now the webserver configuration on BeagleBone and the Websocket configuration for the broker MQTT mosquitto always on Beaglebone.

First step is to access on the Beaglebone in ssh and disable the following services

$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

Go into the folder /etc/apache2/sites-enabled and modfy 000-default.conf changing the webserver port from 8080 to 80

<VirtualHost *:80>

1	<VirtualHost *:80>

In /etc/apache2/port.conf modify the listening port from 8080 to 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

Restart the Http server

sudo systemctl restart apache2

1	sudo systemctl restart apache2

Go into folder /etc/mosquitto/conf.d and create a new file websockets.conf with the following contents inside

listener 1883
protocol mqtt

listener 9001
protocol websockets

listener 1883

protocol mqtt

listener 9001

protocol websockets

Save the file and restart Mosquitto

sudo systemctl restart mosquitto

1	sudo systemctl restart mosquitto

Disable the IPV6 protocol on Beaglebone as described at the following link

Disable IPV6 in Debian

In the file /etc/sysctl.conf add

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

Restart the Beaglebone.

We proceed at this point to install on the http server a MQTT Websocket client and the Freeboard dashboard.

As for the MQTT Websocket client hive-MQTT we download the code from github

Hive mqtt

Log in as root in ssh on Beaglebone and go into /var/www/html folder; clone the Mqtt client into mqtt-web folder and change the owner of this folder

#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

With a web browser navigate on our Http server to the mqtt-web link obtaining the Mqtt Web client; we can now set the parameters for the connection to the Mosquitto Mqtt Broker

Populating the values for the subscription and publishing topics we can access to the messages of the topics and the ability to perform a command to the publishing topic

In the next article we’ll install the Freeboad dashboard on the Beaglebone

Mqtt with Beaglebone and ESP8266 – Freeboard

Development, Hardware, Software

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with Relay

2017-04-01 admin

After the article about the connection with the temperature and humidity sensor

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with temperature sensor

in this article we set the esp8266 to run a relay. Here is how we connect the relay to the ESP module

In this example too we will consider the option of putting the nodemcu in sleep. To have the node back form the sleep the system has to reboot and it is necessary to connect the PIN D0 (GPIO16) to RST PIN as specified in the nodemcu documentation

Nodemcu sleep

Let us take a look at the lua code; It consists of init.lua and relay.lua files.

We analyze now the main points of each file

init.lua

-- init.lua
SSID="SSID" -- SSID 
PASSWORD="password" -- SSID password
TIMEOUT=10000   -- timeout to check the network status
EXSENSOR1="relay.lua"   -- module to run
MQTTSERVER="mqttaddress"   -- mqtt broker address
MQTTPORT="1883" -- mqtt broker port
MQTTQOS="0" -- qos used

-- Set the netowrk parameters and get ip address
wifi.setmode(wifi.STATION)
wifi.sta.config(SSID, PASSWORD)
wifi.sta.getip()


-- Check the network status after the TIMEOUT interval
tmr.alarm(0, TIMEOUT,tmr.ALARM_SINGLE, function()
    status=wifi.sta.status()
   -- if esp8266 got the ip
   if (status == wifi.STA_GOTIP ) then

        dofile(EXSENSOR1)
        
    
    else
        -- Without up restart the node
        print("Error acquiring ip address=",status)
        node.restart()
    end


end

)

-- init.lua

SSID="SSID" -- SSID

PASSWORD="password" -- SSID password

TIMEOUT=10000 -- timeout to check the network status

EXSENSOR1="relay.lua" -- module to run

MQTTSERVER="mqttaddress" -- mqtt broker address

MQTTPORT="1883" -- mqtt broker port

MQTTQOS="0" -- qos used

-- Set the netowrk parameters and get ip address

wifi.setmode(wifi.STATION)

wifi.sta.config(SSID, PASSWORD)

wifi.sta.getip()

-- Check the network status after the TIMEOUT interval

tmr.alarm(0, TIMEOUT,tmr.ALARM_SINGLE, function()

status=wifi.sta.status()

-- if esp8266 got the ip

if (status == wifi.STA_GOTIP ) then

dofile(EXSENSOR1)

else

-- Without up restart the node

print("Error acquiring ip address=",status)

node.restart()

end

)

In the file we set the the parameters to access the wifi network, the address and port of the MQTT broker and the file to be run on the ESP after wifi connection to the access point is estabilished. If the ESP doesn’t acquire the network address the system is restarted.

relay.lua

-- relay.lua
CNAME="relay1" -- Client name 
AMBIENT="home"  -- Ambient name 
STOPIC     = AMBIENT.."/"..CNAME.."/status"  -- Status topic
CTOPIC     = AMBIENT.."/"..CNAME.."/command" --Command topic   
MTOPIC     = AMBIENT.."/"..CNAME.."/monitor" --Monitor topic


sleep_in_seconds= nil --Sleep in seconds


TUPDATE = 20 -- Time interval for update monitor in seconds
RPIN        =1 -- Relay Pin
TGEN = 5 -- Time interval in seconds usend in various trm
gpio.mode(RPIN,gpio.OUTPUT) -- Set Relay pin mode
gpio.write(RPIN,gpio.LOW) -- Default output is OFF





-- Define Client Name and connection parameters
mqt = mqtt.Client(CNAME, 60, "", "", 1) 

-- Subscribe to the topics and send status to the status topic
mqt:on("connect", function() 
    mqt:subscribe(STOPIC, MQTTQOS)
    mqt:subscribe(CTOPIC, MQTTQOS)
    mqt:subscribe(MTOPIC, MQTTQOS)
    send_status("Relay ready again")
end )

-- Callback when mqtt is offline
mqt:on("offline", function() print("mqtt offline");  end)

--Callback to manage messages 
mqt:on("message", function(client, topic, data) 
    manage_message(client, topic, data) 
end)

-- Function to filter the messages
function manage_message(client, topic, data) 
    -- If CTOPIC: command topic
    if topic == CTOPIC then

        -- If the command is Restart
        if data == "Restart" then
            send_status("Restarting")
            send_mstatus("Restarting")
            tmr.alarm(2, TGEN*1000, tmr.ALARM_SINGLE, node.restart)
        -- If the command is null    
        elseif data == nil then
            send_status("Command not valid")
        -- Command to turn on the Relay    
        elseif data == "ON" then
            relay_on()
        -- Command to turn off the Relay    
        elseif data == "OFF" then
            relay_off()  
        -- Command to check the state of the Relay    
        elseif data == "Status" then
            relay_status()         
            
        else
            -- Check the Sleep command
            i=string.len(data)
            dato=string.sub(data,1,5)

            if dato == "Sleep" then
                ndato=string.sub(data,6)
                TSLEEP=tonumber(ndato)
                if TSLEEP ~= nil then

                    if TSLEEP >= 1 then
 
                        -- Sets the interval in seconds to sleep
                        sleep_in_seconds=TSLEEP*60
                        esp_sleep()
                    else
                        -- Send an error in Sleep command
                        send_status("Sleep command error")
                    
                    end
                else
                    -- Send an error in Sleep command 
                    send_status("Sleep command error")
                end

            else
                -- Command not managed           
                send_status("Command not valid")      

            end
            
        end
        
    end
end

-- Function to turn on the relay
function relay_on()
    
    gpio.write(RPIN,gpio.HIGH)
    send_status("Relay ON")
end

-- Function to turn off the relay
function relay_off()
    
    gpio.write(RPIN,gpio.LOW)
    send_status("Relay OFF")
end

-- Function to check if the the relay is on or off
function relay_status()
    
    risultato=gpio.read(RPIN)

    if(risultato==1) then
        send_status("Relay ON")
    elseif(risultato==0) then
        send_status("Relay OFF")
    end
end


-- Function to send messages to to STOPIC: status topic
function send_status(message)
    mqt:publish(STOPIC, message, MQTTQOS, 0)
    
end

-- Fucntion to send messages to MTOPIC: monitor topic
function send_mstatus(message)
    mqt:publish(MTOPIC, message, MQTTQOS, 0)
    
end


-- Function that sleeps esp8266
function esp_sleep()
 
    send_status("Relay going to sleep now")
    send_mstatus("Relay going to sleep now")
    -- Delayd sleep to send the message above.
    tmr.alarm(3, TGEN*1000, tmr.ALARM_SINGLE, function() 
        node.dsleep(sleep_in_seconds*1000000) 
    end)
end


-- Connection to the mqtt server at the msttport
mqt:connect(MQTTSERVER, MQTTPORT, 0, 1)



-- Send periodically a message to the monitor topic
tmr.alarm(4, TUPDATE*1000, tmr.ALARM_AUTO, function() send_mstatus("Relay Ready") end)

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

-- relay.lua

CNAME="relay1" -- Client name

AMBIENT="home" -- Ambient name

STOPIC = AMBIENT.."/"..CNAME.."/status" -- Status topic

CTOPIC = AMBIENT.."/"..CNAME.."/command" --Command topic

MTOPIC = AMBIENT.."/"..CNAME.."/monitor" --Monitor topic

sleep_in_seconds= nil --Sleep in seconds

TUPDATE = 20 -- Time interval for update monitor in seconds

RPIN =1 -- Relay Pin

TGEN = 5 -- Time interval in seconds usend in various trm

gpio.mode(RPIN,gpio.OUTPUT) -- Set Relay pin mode

gpio.write(RPIN,gpio.LOW) -- Default output is OFF

-- Define Client Name and connection parameters

mqt = mqtt.Client(CNAME, 60, "", "", 1)

-- Subscribe to the topics and send status to the status topic

mqt:on("connect", function()

mqt:subscribe(STOPIC, MQTTQOS)

mqt:subscribe(CTOPIC, MQTTQOS)

mqt:subscribe(MTOPIC, MQTTQOS)

send_status("Relay ready again")

end )

-- Callback when mqtt is offline

mqt:on("offline", function() print("mqtt offline"); end)

--Callback to manage messages

mqt:on("message", function(client, topic, data)

manage_message(client, topic, data)

end)

-- Function to filter the messages

function manage_message(client, topic, data)

-- If CTOPIC: command topic

if topic == CTOPIC then

-- If the command is Restart

if data == "Restart" then

send_status("Restarting")

send_mstatus("Restarting")

tmr.alarm(2, TGEN*1000, tmr.ALARM_SINGLE, node.restart)

-- If the command is null

elseif data == nil then

send_status("Command not valid")

-- Command to turn on the Relay

elseif data == "ON" then

relay_on()

-- Command to turn off the Relay

elseif data == "OFF" then

relay_off()

-- Command to check the state of the Relay

elseif data == "Status" then

relay_status()

else

-- Check the Sleep command

i=string.len(data)

dato=string.sub(data,1,5)

if dato == "Sleep" then

ndato=string.sub(data,6)

TSLEEP=tonumber(ndato)

if TSLEEP ~= nil then

if TSLEEP >= 1 then

-- Sets the interval in seconds to sleep

sleep_in_seconds=TSLEEP*60

esp_sleep()

else

-- Send an error in Sleep command

send_status("Sleep command error")

end

else

-- Send an error in Sleep command

send_status("Sleep command error")

end

else

-- Command not managed

send_status("Command not valid")

end

-- Function to turn on the relay

function relay_on()

gpio.write(RPIN,gpio.HIGH)

send_status("Relay ON")

end

-- Function to turn off the relay

function relay_off()

gpio.write(RPIN,gpio.LOW)

send_status("Relay OFF")

end

-- Function to check if the the relay is on or off

function relay_status()

risultato=gpio.read(RPIN)

if(risultato==1) then

send_status("Relay ON")

elseif(risultato==0) then

send_status("Relay OFF")

end

-- Function to send messages to to STOPIC: status topic

function send_status(message)

mqt:publish(STOPIC, message, MQTTQOS, 0)

end

-- Fucntion to send messages to MTOPIC: monitor topic

function send_mstatus(message)

mqt:publish(MTOPIC, message, MQTTQOS, 0)

end

-- Function that sleeps esp8266

function esp_sleep()

send_status("Relay going to sleep now")

send_mstatus("Relay going to sleep now")

-- Delayd sleep to send the message above.

tmr.alarm(3, TGEN*1000, tmr.ALARM_SINGLE, function()

node.dsleep(sleep_in_seconds*1000000)

end)

end

-- Connection to the mqtt server at the msttport

mqt:connect(MQTTSERVER, MQTTPORT, 0, 1)

-- Send periodically a message to the monitor topic

tmr.alarm(4, TUPDATE*1000, tmr.ALARM_AUTO, function() send_mstatus("Relay Ready") end)

The relay.lua file manages the relay, the subscription on MQTT broker with submission of the data. Global parameters have been set to manage the topic, the waiting time in tmr.alarm. There are in particular the following topics

/home/relay1/status : Status topic. The status is sent at the start and at request from the command topic /home/relay1/command.
/home/relay1/monitor: Status of the esp sent periodically to this topic.
/home/relay1/command: Other clients can send commands to the esp:
- Restart: Restarts the esp.
- Sleep n: Put to sleep for n seconds the esp.
- ON: Turn on the relay.
- OFF: Turn off the relay.
- Status: Request of tthe relay status (ON or OFF).

There are various service functions to manage all. The comments in the code describe each feature.

In the next article we will set up the webserver on Beaglebone and the websocket configuration for Mosquitto always on the Beaglebone

MQTT with BeagleBone and ESP8266 – WebServer and MQTT WebSocket

Development, Hardware, Software

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with temperature sensor

2017-03-23 admin

After loading the firmware into the device esp8266

MQTT with BeagleBone and ESP8266-MQTT ESP8266

we now connect this module with a DHT11 temperature and humidity sensor. Here is how we connect the sensor to the ESP module

In this example we will consider the option of putting the nodemcu in sleep. To have the node back form the sleep the system has to reboot and it is necessary to connect the PIN D0 (GPIO16) to RST PIN as specified in the nodemcu documentation

Nodemcu sleep

Let us take a look at the lua code; It consists of init.lua and tempumid.lua files.

We analyze now the main points of each file

init.lua

-- init.lua
SSID="SSDNAME" -- SSID 
PASSWORD="passwordssid" -- SSID password
TIMEOUT=10000    -- timeout to check the network status
EXSENSOR1="tempumid.lua"    -- module to run
MQTTSERVER="mqttbrokeraddress"   -- mqtt broker address
MQTTPORT="1883"  -- mqtt borker port
MQTTQOS="0" -- qos used

-- Set the netowrk parameters and get ip address
wifi.setmode(wifi.STATION)
wifi.sta.config(SSID, PASSWORD)
wifi.sta.getip()

-- Check the network status after the TIMEOUT interval
tmr.alarm(0, TIMEOUT,tmr.ALARM_SINGLE, function()
    status=wifi.sta.status()
    
    -- if esp8266 got the ip
   if (status == wifi.STA_GOTIP ) then

       dofile(EXSENSOR1)
        
    
    else
        -- Without ip restart the node
        print("Error acquiring ip address=",status)
        node.restart()
    end


end

-- init.lua

SSID="SSDNAME" -- SSID

PASSWORD="passwordssid" -- SSID password

TIMEOUT=10000 -- timeout to check the network status

EXSENSOR1="tempumid.lua" -- module to run

MQTTSERVER="mqttbrokeraddress" -- mqtt broker address

MQTTPORT="1883" -- mqtt borker port

MQTTQOS="0" -- qos used

-- Set the netowrk parameters and get ip address

wifi.setmode(wifi.STATION)

wifi.sta.config(SSID, PASSWORD)

wifi.sta.getip()

-- Check the network status after the TIMEOUT interval

tmr.alarm(0, TIMEOUT,tmr.ALARM_SINGLE, function()

status=wifi.sta.status()

-- if esp8266 got the ip

if (status == wifi.STA_GOTIP ) then

dofile(EXSENSOR1)

else

-- Without ip restart the node

print("Error acquiring ip address=",status)

node.restart()

end

In the file we set the the parameters to access the wifi network, the address and port of the MQTT broker and the file to be run on the ESP after wifi connection to the access point is estabilished. If the ESP does’t acquire the netowrk address the system is restarted.

tempumid.lua

-- tempumid.lua
CNAME="room1" -- Client name 
AMBIENT="home"  -- Ambient name
TTOPIC     = AMBIENT.."/"..CNAME.."/temperature"  -- Temperature topic
HTOPIC     = AMBIENT.."/"..CNAME.."/humidity"  -- Humidity topic 
STOPIC     = AMBIENT.."/"..CNAME.."/status"  -- Status topic
CTOPIC     = AMBIENT.."/"..CNAME.."/command" --Command topic   
MTOPIC     = AMBIENT.."/"..CNAME.."/monitor" --Monitor topic


sleep_in_seconds= nil --Sleep in seconds


TUPDATE = 15 -- Time interval for update monitor in seconds
TUPTEMP = 10 -- Time interval for update temperature and humidity values
SPIN         = 4  -- Sensor pin
TGEN = 5 -- Time interval in seconds usend in various trm


-- Define Client Name and connection parameters
mqt = mqtt.Client(CNAME, 60, "", "", 1) 

-- Subscribe to the topics and send status to the status topic
mqt:on("connect", function() 
    mqt:subscribe(STOPIC, MQTTQOS)
    mqt:subscribe(CTOPIC, MQTTQOS)
    mqt:subscribe(MTOPIC, MQTTQOS)
    mqt:subscribe(TTOPIC, MQTTQOS)
    mqt:subscribe(HTOPIC, MQTTQOS)
    send_status("Sensor ready again")
end )

-- Callback when mqtt is offline
mqt:on("offline", function() print("mqtt offline");  end)

--Callback to manage messages 
mqt:on("message", function(client, topic, data) 
    manage_message(client, topic, data) 
end)


-- Function to filter the messages
function manage_message(client, topic, data) 
    -- If CTOPIC: command topic
    if topic == CTOPIC then
        --print("Command")
        -- If the command is Restart
        if data == "Restart" then
            send_status("Restarting")
            send_mstatus("Restarting")
            tmr.alarm(2, TGEN*1000, tmr.ALARM_SINGLE, node.restart)
            --print("restart")
        -- If the command is null    
        elseif data == nil then
           -- print("Command not valid")
            send_status("Command not valid")
        
        
        else
            -- Check the Sleep command           
            i=string.len(data)
            dato=string.sub(data,1,5)
          
            if dato == "Sleep" then
                ndato=string.sub(data,6)
                TSLEEP=tonumber(ndato)
                if TSLEEP ~= nil then
                    if TSLEEP >= 1 then
                        -- Sets the interval in seconds to sleep
                        sleep_in_seconds=TSLEEP*60
                        esp_sleep()
                    else
                        -- Send an error in Sleep command
                        send_status("Sleep command error")
                    
                    end
                else
                    -- Send an error in Sleep command 
                    send_status("Sleep command error")
                end

            else
                -- Command not managed           
                send_status("Command not valid")      

            end
            
        end
        
    end
end

-- Function to send messages to STOPIC: status topic
function send_status(message)
    mqt:publish(STOPIC, message, MQTTQOS, 0)
    
end

-- Fucntion to send messages to MTOPIC: monitor topic
function send_mstatus(message)
    mqt:publish(MTOPIC, message, MQTTQOS, 0)
    
end

-- Function to display temp and hum
function display_temphum(temp,humi)
    print("Temperature=%d, Humidity=%d",temp,humi)
end

 
-- Function to read and publish temperature and humidity
function read_temp_hum(client)
    status, temp, humi, temp_dec, humi_dec = dht.read(SPIN)
    if status == dht.OK then
    
        mqt:publish(TTOPIC, temp,MQTTQOS, 0)
        mqt:publish(HTOPIC, humi, MQTTQOS, 0)
        
       -- display_temphum(temp,humi)
       
    elseif status == dht.ERROR_CHECKSUM then
        print( "DHT Checksum error." )
    elseif status == dht.ERROR_TIMEOUT then
        print( "DHT timed out." )
    end
end


-- Function that sleeps esp8266
function esp_sleep()
 
    send_status("Sensor going to sleep now")
    send_mstatus("Sensor going to sleep now")
    -- Delayd sleep to send the message above.
    tmr.alarm(3, TGEN*1000, tmr.ALARM_SINGLE, function() 
        node.dsleep(sleep_in_seconds*1000000) 
    end)
end

-- Connection to the mqtt server at the mqttport
mqt:connect(MQTTSERVER, MQTTPORT, 0, 1)

--Sends periodically the temperature and humidity to the topics
tmr.alarm(1, TUPTEMP*1000, tmr.ALARM_AUTO, function() read_temp_hum(mqt) end)

-- Sends periodically a message to the monitor topic
tmr.alarm(4, TUPDATE*1000, tmr.ALARM_AUTO, function() send_mstatus("Sensor Ready") end)

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

-- tempumid.lua

CNAME="room1" -- Client name

AMBIENT="home" -- Ambient name

TTOPIC = AMBIENT.."/"..CNAME.."/temperature" -- Temperature topic

HTOPIC = AMBIENT.."/"..CNAME.."/humidity" -- Humidity topic

STOPIC = AMBIENT.."/"..CNAME.."/status" -- Status topic

CTOPIC = AMBIENT.."/"..CNAME.."/command" --Command topic

MTOPIC = AMBIENT.."/"..CNAME.."/monitor" --Monitor topic

sleep_in_seconds= nil --Sleep in seconds

TUPDATE = 15 -- Time interval for update monitor in seconds

TUPTEMP = 10 -- Time interval for update temperature and humidity values

SPIN = 4 -- Sensor pin

TGEN = 5 -- Time interval in seconds usend in various trm

-- Define Client Name and connection parameters

mqt = mqtt.Client(CNAME, 60, "", "", 1)

-- Subscribe to the topics and send status to the status topic

mqt:on("connect", function()

mqt:subscribe(STOPIC, MQTTQOS)

mqt:subscribe(CTOPIC, MQTTQOS)

mqt:subscribe(MTOPIC, MQTTQOS)

mqt:subscribe(TTOPIC, MQTTQOS)

mqt:subscribe(HTOPIC, MQTTQOS)

send_status("Sensor ready again")

end )

-- Callback when mqtt is offline

mqt:on("offline", function() print("mqtt offline"); end)

--Callback to manage messages

mqt:on("message", function(client, topic, data)

manage_message(client, topic, data)

end)

-- Function to filter the messages

function manage_message(client, topic, data)

-- If CTOPIC: command topic

if topic == CTOPIC then

--print("Command")

-- If the command is Restart

if data == "Restart" then

send_status("Restarting")

send_mstatus("Restarting")

tmr.alarm(2, TGEN*1000, tmr.ALARM_SINGLE, node.restart)

--print("restart")

-- If the command is null

elseif data == nil then

-- print("Command not valid")

send_status("Command not valid")

else

-- Check the Sleep command

i=string.len(data)

dato=string.sub(data,1,5)

if dato == "Sleep" then

ndato=string.sub(data,6)

TSLEEP=tonumber(ndato)

if TSLEEP ~= nil then

if TSLEEP >= 1 then

-- Sets the interval in seconds to sleep

sleep_in_seconds=TSLEEP*60

esp_sleep()

else

-- Send an error in Sleep command

send_status("Sleep command error")

end

else

-- Send an error in Sleep command

send_status("Sleep command error")

end

else

-- Command not managed

send_status("Command not valid")

end

-- Function to send messages to STOPIC: status topic

function send_status(message)

mqt:publish(STOPIC, message, MQTTQOS, 0)

end

-- Fucntion to send messages to MTOPIC: monitor topic

function send_mstatus(message)

mqt:publish(MTOPIC, message, MQTTQOS, 0)

end

-- Function to display temp and hum

function display_temphum(temp,humi)

print("Temperature=%d, Humidity=%d",temp,humi)

end

-- Function to read and publish temperature and humidity

function read_temp_hum(client)

status, temp, humi, temp_dec, humi_dec = dht.read(SPIN)

if status == dht.OK then

mqt:publish(TTOPIC, temp,MQTTQOS, 0)

mqt:publish(HTOPIC, humi, MQTTQOS, 0)

-- display_temphum(temp,humi)

elseif status == dht.ERROR_CHECKSUM then

print( "DHT Checksum error." )

elseif status == dht.ERROR_TIMEOUT then

print( "DHT timed out." )

end

-- Function that sleeps esp8266

function esp_sleep()

send_status("Sensor going to sleep now")

send_mstatus("Sensor going to sleep now")

-- Delayd sleep to send the message above.

tmr.alarm(3, TGEN*1000, tmr.ALARM_SINGLE, function()

node.dsleep(sleep_in_seconds*1000000)

end)

end

-- Connection to the mqtt server at the mqttport

mqt:connect(MQTTSERVER, MQTTPORT, 0, 1)

--Sends periodically the temperature and humidity to the topics

tmr.alarm(1, TUPTEMP*1000, tmr.ALARM_AUTO, function() read_temp_hum(mqt) end)

-- Sends periodically a message to the monitor topic

tmr.alarm(4, TUPDATE*1000, tmr.ALARM_AUTO, function() send_mstatus("Sensor Ready") end)

The temumid.lua file manages the measurement of temperature and humidity, the subscription on MQTT broker with submission of the data. Global parameters have been set to manage the topic, the waiting time in tmr.alarm. There are in particular the following topics

/home/room1/temperature: measured temperature topic.
/home/room1/humidity: measured humidity topic.
/home/room1/status : Status topic. The status is sent at the start and at request from the command topic /home/room1/command.
/home/room1/monitor: Status of the esp sent periodically to this topic.
/home/room1/command: Other clients can send commands to the esp:
- Restart: Restarts the esp.
- Sleep n: Put to sleep for n seconds the esp.

There are various service functions to manage all. The comments in the code describe each feature.

In the next article we will set up the esp with the relay

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with Relay

Configuration, Software

Mqtt with Beaglebone and ESP8266-MQTT ESP8266

2017-03-19 admin

After installing the MQTT server on BeagleBone

Mqtt with Beaglebone and ESP8266-Mosquitto installation on Beaglebone

let us set the MQTT nodes on ESP8266.

As first operation we must generate the nodemcu firmware, as described in the previous article

Nodemcu compilation on Linux

with at least the following parameters activated in user_module.h file

DHT
file
GPIO
MQTT
net
node
timer
UART
WiFi

These settings are the default in the user_module.h file.

At present the latest version 2.0 of nomemcu firmware was released. Here are the compiled files for this version of the firmware

Nodemcu2.0.0 firmware

As already described in previous articles and from the nodecmu link on flashing

Flashing the firmware

we have to set the correct parameters for the esp8266 model.

In our case, with 4MB flash, we used the parameters shown in the image to load the firmware on the device with nodemcu-flasher tool. You can also use other tools for loading the firmware. In our case, the settings used are as follows

In the next article we’ll treat the ESP8266 node that detects temperature and humidity

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with temperature sensor

Configuration, Software

MQTT with BeagleBone and ESP8266 – Mosquitto installation on Beaglebone

2017-03-12 admin

After summarizing the architecture that we are implementing in the previous article

Mqtt with Beaglebone and ESP8266-Architecture

We proceed now with the installation of the MQTT broker on Beaglebone Black with the following version of Debian

root@beaglebone:~#  cat /etc/dogtag
BeagleBoard.org Debian Image 2016-11-06
root@beaglebone:~# uname -a
Linux beaglebone 4.4.30-ti-r64 #1 SMP Fri Nov 4 21:23:33 UTC 2016 armv7l GNU/Lux

root@beaglebone:~# cat /etc/dogtag

BeagleBoard.org Debian Image 2016-11-06

root@beaglebone:~# uname -a

Linux beaglebone 4.4.30-ti-r64 #1 SMP Fri Nov 4 21:23:33 UTC 2016 armv7l GNU/Lux

The image used is the following

Beaglebone Black Image

We proceed to the configuration as described in the article

Debian sd card setup for Beaglebone Black

Proceed to extend the space on the SD card with the application gparted in a linux host or using the grow_partition.sh tool on BeagleBone in the /opt/scripts/tools folder

root@beaglebone:/opt/scripts/tools# ./grow_partition.sh

1	root@beaglebone:/opt/scripts/tools# ./grow_partition.sh

Performing the upgrade with this image we have had space issue with 4Gb partition.

The message broker we’ll use is mosquitto

Mosquitto

The version of Mosquitto with Debian Jessie doesn’t not have the Wesockets services, which we’ll use for the Dashboard. For this reason, we have to install a more recent version of Mosquitto (or recompile it from source).

Log on as root in a command shell on BeagleBone and add the Debian testing repository

cd /etc/apt
vi sources.list

1 2	cd /etc/apt vi sources.list

deb http://httpredir.debian.org/debian stretch main contrib non-free

1	deb http://httpredir.debian.org/debian stretch main contrib non-free

Run the following

apt-get update
apt-get install mosquitto
apt-get install mosquitto-clients

apt-get update

apt-get install mosquitto

apt-get install mosquitto-clients

After the installation comment the reference of the debian testing repository in /etc/apt/sources.list

#deb http://httpredir.debian.org/debian stretch main contrib non-free

1	#deb http://httpredir.debian.org/debian stretch main contrib non-free

and run

apt-get update

1	apt-get update

We test at this point if the server is installed correctly by running in a shell the subscription to a topic

mosquitto_sub -h localhost -t "topic/test"

1	mosquitto_sub -h localhost -t "topic/test"

In another command shell run the publishing on topic “topic / test”

mosquitto_pub -h localhost -t "topic/test" -m "Prova"

1	mosquitto_pub -h localhost -t "topic/test" -m "Prova"

The first shell has to show the message “Prova”

With MQTT protocol we can define different QOS, as described in the Mosquitto FAQ

QOS Mosquitto

With QoS = 0 the message is sent only once and is not required confirmation of receipt by the subscribers; the MQTT implementation in these articles is without protection with name/password or ssl channel encryption and with QOS=0.

In the next article we’ll proceed to the preparation of ESP9266 module with the Mqtt lua library inside the nodemcu firmware

MQTT with BeagleBone and ESP8266-MQTT ESP8266

Configuration, Software

Mqtt with Beaglebone and Esp8266-Architecture

2017-03-12 admin

In this series of articles we treat a MQTT message broker installed on BeagleBone Black; this componet allows to manage various esp8266 devices, to which we connect various probes such as temperaure sensors, relays.

All this is handled with the help of apps on Android and a Dashboard installed on Apache on BeagleBone.

We start from the message MQTT broker (Message Queue Telemetry Transport); here there is the description of the protocol

MQTT

In particular in the FAQ section there are the first indications on the protocol and its use

MQTT Faq

The system is formed by three components:

MQTT Broker: relays the messages published to all subscribers.
Publisher: Publish messages in the registered topics on MQTT Broker.
Subscriber: Receives messages for its registered topics from MQTT Broker.

The following shows the topology for two topics used in our example

The system is composed of a MQTT broker on BeagleBone. In this MQTT broker server you can define topics; different devices can be registered to these topics. For each topic the action can be subscription and publishing. By subscribing you receive all messages of topics, while with the publishing we can perform actions on the topic (for example, turn on a relay, restart a device, send sensor measurement,etc.). In the example we treat there will be, for example, a queue for the temperature monitor, hooked to esp8266 temperature reading device, another for the management of a relay, always run with esp8266. The MQTT broker relays the received messages among all subscribers/ publishers for each topic.

We can subcribe/publish to the topics on the MQTT broker using Android apps; the apps can receive messages and send commands to the esp8266 end device (Turn onRelay, Restart sensor, etc.).

With the javascript framework Freeboard

Freeboard

installed on the Beablebone Apache web server we can monitor in real time the end devices.

For more informations on MQTT system, consult the web site listed above.

In the next article we’ll start by installing the MQTT broker on BeagleBone Black

MQTT with BeagleBone and ESP8266 – Mosquitto installation on Beaglebone

Micro Devices

Tag Archives: texas instruments

MicroPython – Nodes examples with DHT11, Relay and MQTT

Mqtt with Beaglebone and ESP8266 – Articles List

Mqtt with Beaglebone and ESP8266 – Android Client

Mqtt with Beaglebone and ESP8266 – Freeboard

MQTT with BeagleBone and ESP8266 – WebServer and MQTT WebSocket

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with Relay

MQTT with BeagleBone and ESP8266 – MQTT on ESP8266 with temperature sensor

Mqtt with Beaglebone and ESP8266-MQTT ESP8266

MQTT with BeagleBone and ESP8266 – Mosquitto installation on Beaglebone

Mqtt with Beaglebone and Esp8266-Architecture

Blog about embedded devices