class MQTTReader:
__slots__ = ('host', 'port', 'topic', 'client')
def __init__(self, name, host, port, topic):
self.topic = topic
self.host = host
self.port = port
self.client = MQTTClient(name, host, port)
self.client.set_callback(sub_cb)
self._connect()
self.client.subscribe(topic=self.topic)
def _connect(self):
print("Connecting to %s:%s" % (self.host, self.port))
self.client.connect()
print("Connection successful")
def on_completed(self):
print("mqtt_completed, disconnecting")
self.client.disconnect()
def on_error(self, e):
print("mqtt on_error: %s, disconnecting" % e)
self.client.disconnect()
def disconnect(self):
self.client.disconnect()
def wait_msg(self):
self.client.wait_msg()
def main():
machine.freq(160000000)
c = MQTTClient("HSBNE-small-sign", "10.0.1.253", user="", password="")
c.set_callback(sub_cb)
c.set_last_will("devices/small-sign/state", "offline", retain=True)
c.connect()
c.subscribe("devices/small-sign/#")
c.publish("devices/small-sign/state", "online", retain=True)
c.publish("devices/main-sign/ip",
network.WLAN(network.STA_IF).ifconfig()[0],
retain=True)
sign = SignMatrix()
try:
while True:
while c.check_msg():
pass
if enable != 0:
sign.set_delay(delay)
sign.scroller(text)
else:
c.wait_msg()
except KeyboardInterrupt:
c.publish("devices/small-sign/state", "offline", retain=True, qos=1)
c.disconnect()
def run():
sleep(4)
show_default()
c = MQTTClient('ledkrant',
mqtt_server["ip"],
user=mqtt_server["user"],
password=mqtt_server["password"])
c.DEBUG = True
c.set_callback(sub_callback)
c.connect()
c.subscribe(b"ledkrant/write")
c.subscribe(b"ledkrant/time")
c.subscribe(b"ledkrant/brightness")
c.subscribe(b"ledkrant/reset")
c.subscribe(b"ledkrant/color")
c.subscribe(b"ledkrant/textcolor")
c.subscribe(b"ledkrant/party")
c.subscribe(b"ledkrant/setxy")
while 1:
c.wait_msg()
c.disconnect()
def connect_mqtt():
try:
with open(KEY_FILE, "r") as f:
key = f.read()
print("MQTT received KEY")
with open(CERT_FILE, "r") as f:
cert = f.read()
print("MQTT received CERTIFICATE")
mqtt_client = MQTTClient(client_id=MQTT_CLIENT_ID, server=MQTT_HOST, port=MQTT_PORT, keepalive=5000, ssl=True, ssl_params={"cert":cert, "key":key, "server_side":False})
mqtt_client.connect()
mqtt_client.set_callback(sub_cb)
print("MQTT is connected")
mqtt_client.subscribe(SHADOW_GET_TOPIC)
print("Subscribed to %s topic" % (SHADOW_GET_TOPIC))
while True:
mqtt_client.publish(SHADOW_UPDATE_TOPIC, str(read_sensor_value()))
mqtt_client.wait_msg()
except Exception as e:
print('Cannot connect to MQTT ' + str(e))
raise
def start_mqtt(self, server="ops-senpai.5z.fyi"):
c = MQTTClient("dog",
"ops-senpai.5z.fyi",
port=30001,
user="******",
password="******")
c.set_callback(self._sub_cb)
c.connect()
c.subscribe(b"printme")
try:
while True:
# Blocking wait for message
c.wait_msg()
finally:
c.disconnect()
def listen():
global client
global state
#Create an instance of MQTTClient
client = MQTTClient(CONFIG['CLIENT_ID'],
CONFIG['MQTT_BROKER'],
user=CONFIG['USER'],
password=CONFIG['PASSWORD'],
port=CONFIG['PORT'])
# Attach call back handler to be called on receiving messages
client.set_callback(onMessage)
client.connect()
client.subscribe(CONFIG['TOPIC'])
client.subscribe('Acknowledgement')
print("ESP8266 is Connected to %s and subscribed to %s topic" %
(CONFIG['MQTT_BROKER'], CONFIG['TOPIC']))
while (1):
client.wait_msg()
def main(server="broker.hivemq.com", topic=b"testtopic/1"):
global msgRxd
global msgTime
msgCnt = 0
connectOut = machine.Pin(13, machine.Pin.OUT)
updateLedState(connectOut, msgCnt)
print("Connecting to MQTT server: ", server)
c = MQTTClient("umqtt_client", server)
c.set_callback(sub_cb)
c.connect()
print("Subscribing to: ", topic)
c.subscribe(topic)
lastMsgTime = msgTime
while True:
# Set to True/False depending on whether you want to test
# blocking I/O or not. NOTE: Setting to True makes it
# difficult to Control-C when using WebREPL.
if False:
# Blocking wait for message
print("Waiting for new message from topic: ", topic)
c.wait_msg()
else:
# Non-blocking wait for message
print("Checking for new message from topic: ", topic)
c.check_msg()
mtime = msgTime
msg = msgRxd
if mtime != lastMsgTime and msgRxd != None:
print((topic, msg))
lastMsgTime = mtime
msgCnt = msgCnt + 1
updateLedState(connectOut, msgCnt)
else:
# Then need to sleep to avoid 100% CPU usage (in a real
# app other useful actions would be performed instead)
time.sleep_ms(1000)
c.disconnect()
def main(server=mqtt_server):
mqtt_client = MQTTClient(mqtt_clientID, mqtt_server)
# mqtt berichten gaan naar deze callback functie
mqtt_client.set_callback(sub_cb)
# connecteer op mqtt server
mqtt_client.connect()
# subscribe op de topics
mqtt_client.subscribe(mqtt_topic)
# status mqtt connectie
print("Verbonden met mqtt %s, geabonneerd op %s topic" %
(mqtt_server, mqtt_topic))
try:
while True:
# wacht op mqtt messages
mqtt_client.wait_msg()
finally:
# verbreek mqtt connectie
mqtt_client.disconnect()
def main():
global client
clearLeds()
# Get settings from config.json
while(getSettings() == False):
time.sleep(10)
# Connects to Wifi
setup()
# Open up the connection to MQTT
print("Setting Up Connection To MQTT server")
client = MQTTClient(clientName, mqttServerAddress)
client.set_callback(messageReceived)
# print("Waiting for Network")
# conn = network.WLAN(network.STA_IF)
# while(conn.ifconfig()[0] == '0.0.0.0'):
# time.sleep(100)
# print("Network Ready")
# Try to connect to MQTT server
print("Attempting to connect to MQTT server")
try:
client.connect()
except:
print("Failed. Network info:")
print(network.WLAN(network.STA_IF).ifconfig())
client.subscribe(channelName)
print("Connected and Subscribed to %s channel" % channelName)
# Listen to MQTT
while(True):
print("")
print("Listening to channel")
client.wait_msg();
def main(server="localhost"):
conn_wifi()
client = MQTTClient("client_2",
"18.188.220.135",
user="******",
password="******",
port=1883)
client.set_callback(sub_cb)
client.connect()
client.subscribe(b"hello/lights")
while True:
if True:
# Blocking wait for message
client.wait_msg()
else:
# Non-blocking wait for message
client.check_msg()
# Then need to sleep to avoid 100% CPU usage (in a real
# app other useful actions would be performed instead)
time.sleep(1)
client.disconnect()
# gecodeerde text publiceren
mqtt_cl.publish(TOPIC2, code)
# wifi object aanmaken
myWifi = simpleWifi.Wifi()
# connecteren met wifi
if not (myWifi.open()):
myWifi.get_status()
sys.exit()
# tonen status wifi
myWifi.get_status()
try:
# mqtt client aanmaken
mqtt_cl = MQTTClient('esp_frank_16', BROKER)
# callback functie instellen
mqtt_cl.set_callback(messages)
# connecteren op mqtt broker
mqtt_cl.connect()
# subscriben op topic
mqtt_cl.subscribe(TOPIC1)
# wachten op broker berichten
while True:
mqtt_cl.wait_msg()
except Exception as e:
print('Problemen met MQTT - %s' % e)
finally:
mqtt_cl.disconnect()
myWifi.close()
thingspeakMqttApiKey = b"MQTT_API_KEY" # EDIT - enter Thingspeak MQTT API Key
client = MQTTClient(client_id=myMqttClient,
server=thingspeakUrl,
user=thingspeakUserId,
password=thingspeakMqttApiKey,
ssl=False)
#
# callback to handle data when MQTT channel updates
#
client.set_callback(cb)
client.connect()
#
# subscribe a Thingspeak channel field using MQTT
#
thingspeakChannelId = b"CHANNEL_ID" # EDIT - enter Thingspeak Channel ID
thingspeakChannelReadApiKey = b"READ_API_KEY" # EDIT - enter Thingspeak Read API Key
subscribeTopic = bytes(
"channels/{:s}/subscribe/fields/field1/{:s}".format(
thingspeakChannelId, thingspeakChannelReadApiKey), 'utf-8')
client.subscribe(subscribeTopic)
#
# wait until new data has been Published to the Thingspeak channel
#
while True:
client.wait_msg()
time.sleep(1)
client.disconnect()
class CatFeeder(object):
def __init__(self):
""""""
self._client = None
self._button = Pin(5, mode=Pin.IN, pull=Pin.PULL_UP)
self._done_payload = 'Done feeding!'
self._servo_buzz = Feeder(
pin_servo=0,
trigger=14,
echo=2,
)
self._servo_tuxedo = Feeder(
pin_servo=4,
trigger=12,
echo=13,
)
print('Instancing button and servos.')
self._button.irq(handler=self.button_pressed, trigger=Pin.IRQ_RISING)
print('Setting IRQ.')
def mqtt_connect(self):
""""""
print("Connecting to MQTT server...")
self._client = MQTTClient(
CLIENT_ID,
MQTT_SERVER,
user=MQTT_USERNAME,
password=MQTT_PASSWORD,
)
self._client.set_callback(self.on_message)
print("Connecting MQTT")
self._client.set_last_will(STATUS_TOPIC, "Offline", retain=True)
self._client.connect()
self._client.subscribe(TOPIC)
print("Connected to %s, subscribed to %s topic" % (MQTT_SERVER, TOPIC))
self._client.publish(STATUS_TOPIC, "Connected", retain=True)
while True:
self._client.wait_msg()
def button_pressed(self, pin):
if pin.value():
time.sleep_ms(300)
print('#' * 80)
self._client.publish(MANUAL_FEEDING, "")
def on_message(self, topic, message):
""""""
print(topic, message)
msg = message.strip().decode('utf-8')
self._client.publish(LAST_FED_TOPIC, "Feeding...")
self.feed()
def feed(self):
""""""
time.sleep(0.2)
self._servo_buzz.feed()
print('fed buzz')
time.sleep(1)
print('pause 1 sec')
self._servo_tuxedo.feed()
print('fed tuxedo')
self.done_feeding()
def done_feeding(self):
""""""
time.sleep(0.2)
self._client.publish(DONE_TOPIC, self._done_payload)
time.sleep(0.2)
self._client.publish(QTY_BUZZ_TOPIC,
self._servo_buzz.remaining_quantity)
time.sleep(0.2)
self._client.publish(QTY_TUXEDO_TOPIC,
self._servo_tuxedo.remaining_quantity)
print("Done feeding!\n\n")
print('/' * 80)
print('Waiting for message...')
while True:
self._client.wait_msg()
def run(self):
self.mqtt_connect()
def open_close_test(self, open_=48, pause=1):
""""""
self._servo_buzz.open_position = open_
self._servo_tuxedo.open_position = open_
self._servo_buzz.pause_open = pause
self._servo_tuxedo.pause_open = pause
self._servo_buzz.feed()
print('fed buzz')
time.sleep(1)
print('pause 1 sec')
self._servo_tuxedo.feed()
while True:
self._client.wait_msg()
myWifi.get_status()
sys.exit()
myWifi.get_status()
try:
# mqtt client aanmaken
mqttCl = MQTTClient(ID, BROKER)
# callback functie instellen voor ontvangen berichten
mqttCl.set_callback(mqttMsg)
# connectie maken met mqtt broker
mqttCl.connect()
# subscriben op TOPIC
mqttCl.subscribe(TOPIC1)
# wachten op mqtt berichten
while True:
mqttCl.wait_msg()
utime.sleep(10)
except Exception as e:
print("mqtt of netwerk probleem - %s" % e)
finally:
# led uit
pLed1.value(0)
# als wifi aan
if myWifi.get_status() == 1:
# als mqtt client aan
if mqttCl != None:
# mqtt client afzetten
mqttCl.disconnect()
# wifi afzetten
class Web:
def __init__(self, wifiName, wifiPassword, ADAFRUIT_IO_URL,
ADAFRUIT_USERNAME, ADAFRUIT_IO_KEY):
self.wifiName = wifiName
self.wifiPassword = wifiPassword
self.ADAFRUIT_IO_URL = ADAFRUIT_IO_URL
self.ADAFRUIT_USERNAME = ADAFRUIT_USERNAME
self.ADAFRUIT_IO_KEY = ADAFRUIT_IO_KEY
self.Connected = "F"
# create a random MQTT clientID
random_num = int.from_bytes(os.urandom(3), 'little')
self.mqtt_client_id = bytes('client_' + str(random_num), 'utf-8')
# connect to Adafruit IO MQTT broker using unsecure TCP (port 1883)
#
# To use a secure connection (encrypted) with TLS:
# set MQTTClient initializer parameter to "ssl=True"
# Caveat: a secure connection uses about 9k bytes of the heap
# (about 1/4 of the micropython heap on the ESP8266 platform)
self.client = MQTTClient(client_id=self.mqtt_client_id,
server=ADAFRUIT_IO_URL,
user=ADAFRUIT_USERNAME,
password=ADAFRUIT_IO_KEY,
ssl=False)
self.values = {}
def getConnected(self):
return self.Connected
def connectToWifi(self):
# WiFi connection information
WIFI_SSID = self.wifiName
WIFI_PASSWORD = self.wifiPassword
# turn off the WiFi Access Point
ap_if = network.WLAN(network.AP_IF)
ap_if.active(False)
# connect the device to the WiFi network
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(WIFI_SSID, WIFI_PASSWORD)
# wait until the device is connected to the WiFi network
MAX_ATTEMPTS = 20
attempt_count = 0
while not wifi.isconnected() and attempt_count < MAX_ATTEMPTS:
attempt_count += 1
time.sleep(1)
if attempt_count == MAX_ATTEMPTS:
print('could not connect to the WiFi network')
self.Connected = "F"
wifi.active(False)
return Offline.Offline("Offline_Data.txt")
self.Connected = "T"
return self
def connectToMQTT(self):
try:
self.client.connect()
return 0
except Exception:
return -1
def cb(self, topic, msg):
tp = str(topic, 'utf-8')
tp = (tp.split('/'))[-1]
ms = float(str(msg, 'utf-8'))
self.values[tp] = ms
def _subscribe(self, feedname):
mqtt_feedname = bytes(
'{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, feedname),
'utf-8')
self.client.set_callback(self.cb)
self.client.subscribe(mqtt_feedname)
mqtt_feedname_get = bytes(
'{:s}/feeds/{:s}/get'.format(self.ADAFRUIT_USERNAME, feedname),
'utf-8')
self.client.publish(mqtt_feedname_get, '\0')
self.client.wait_msg()
def publish(self, feedname, stringToPublish):
mqtt_feedname = bytes(
'{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, feedname),
'utf-8')
self.client.publish(mqtt_feedname,
bytes(stringToPublish, 'utf-8'),
qos=0)
def subscribe_to_keys(self, listOfKeys):
for s in listOfKeys:
bs = str(s, 'utf-8')
self.values[s] = -9999
self._subscribe(bs)
def get_latest_value(self, key):
return self.values[key]
def update_values(self):
self.client.check_msg()
class MQTTReaderAWS:
__slots__ = ('host', 'port', 'topic', 'client')
def __init__(self, client_id, host, port, topic, key_file, cert_file):
self.client_id = client_id
self.host = host
self.port = port
self.topic = topic
self.key_file = key_file
self.cert_file = cert_file
self.mqtt_client = None
self.connect_mqtt()
self.mqtt_client.set_callback(sub_cb)
self.mqtt_client.subscribe(topic=self.topic)
def connect_mqtt(self):
try:
with open(self.key_file, "r") as f:
key = f.read()
print("Got Key")
with open(self.cert_file, "r") as f:
cert = f.read()
print("Got Cert")
self.mqtt_client = MQTTClient(client_id=self.client_id,
server=self.host,
port=self.port,
keepalive=5000,
ssl=True,
ssl_params={
"cert": cert,
"key": key,
"server_side": False
})
self.mqtt_client.connect()
print('MQTT Connected')
except Exception as e:
print('Cannot connect MQTT: ' + str(e))
raise
def disconnect(self):
self.mqtt_client.disconnect()
# Checks whether a pending message from server is available.
# If not, returns immediately with None. Otherwise, does
# the same processing as wait_msg.
def wait_msg(self):
self.mqtt_client.wait_msg()
# 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 check_msg(self):
try:
self.mqtt_client.check_msg()
except:
pass
# Behaves like wait_msg, but worse
def subscribe(self):
self.mqtt_client.subscribe(self.topic, 0)
def last_msg(self):
return (str(MESSAGE, 'utf-8'))
print(e)
#conexion a red wifi
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect("ssid", "pass")
time.sleep(5)
#credenciales para conexion a ubidots
ubidotsToken = "token"
clientID = "espcontrol"
topic=b"/v1.6/devices/espprueba/r/lv" #el topic define a que device en especifico es que se va a subir datos
#b"/v1.6/devices/{NOMBRE_DISPOSITIVO}" en el que NOMBRE_DISPOSITIVO es quien
#define entre los devices creados al cual se quiere subir el dato
#inicializacion de cliente para mqtt y conexion
client = MQTTClient(clientID, "industrial.api.ubidots.com", 1883, user = ubidotsToken, password = ubidotsToken) #creacion de objeto
client.connect() #conexion a ubidots
client.set_callback(cb) #seteo de funcion de callback
client.subscribe(topic) #conectarse a topics definidos
client.subscribe(b"/v1.6/devices/espprueba/g/lv")
client.subscribe(b"/v1.6/devices/espprueba/b/lv")
while True:
try:
client.wait_msg() #recepcion del dato
except Exception as e:
print(e)
client.disconnect()
sys.exit()
class IoTCClient():
def __init__(self,
id_scope,
device_id,
credentials_type: IoTCConnectType,
credentials,
logger=None,
storage=None):
self._device_id = device_id
self._id_scope = id_scope
self._credentials_type = credentials_type
self._content_type = 'application%2Fjson'
self._content_encoding = 'utf-8'
self._connected = False
self._credentials = credentials
self._storage = storage
self._events = {}
self._model_id = None
if logger is not None:
self._logger = logger
else:
self._logger = ConsoleLogger(IoTCLogLevel.API_ONLY)
self._twin_request_id = time()
def set_content_type(self, content_type):
self._content_type = encode_uri_component(content_type)
def set_content_encoding(self, content_encoding):
self._content_encoding = content_encoding
def set_log_level(self, log_level: IoTCLogLevel):
self._logger.set_log_level(log_level)
def _on_message(self, topic, message):
topic = topic.decode('utf-8')
self._logger.debug(topic)
if topic == HubTopics.TWIN_RES.format(200, self._twin_request_id):
self._logger.info('Received twin: {}'.format(message))
if topic.startswith(HubTopics.PROPERTIES):
# desired properties
self._logger.info(
'Received desired property message: {}'.format(message))
message = json.loads(message.decode('utf-8'))
self.on_properties_update(message)
elif topic.startswith(HubTopics.COMMANDS):
# commands
match = self._commands_regex.match(topic)
if match is not None:
if all(m is not None for m in [match.group(1),
match.group(2)]):
command_name = match.group(1)
command_req = match.group(2)
command = Command(command_name, message)
try:
command_name_with_components = command_name.split("*")
if len(command_name_with_components) > 1:
# In a component
self._logger.debug("Command in a component")
command = Command(
command_name_with_components[1],
message,
component_name=command_name_with_components[0],
)
def reply_fn():
self._logger.debug(
'Acknowledging command {}'.format(
command.name))
self._mqtt_client.publish(
'$iothub/methods/res/{}/?$rid={}'.format(
200, command_req).encode('utf-8'), '')
if command.component_name is not None:
self.send_property({
"{}".format(command.component_name): {
"{}".format(command.name): {
"value": command.value,
"requestId": command_req
}
}
})
else:
self.send_property({
"{}".format(command.name): {
"value": command.value,
"requestId": command_req
}
})
command.reply = reply_fn
self._on_commands(command)
sleep(0.1)
except:
pass
elif topic.startswith(
HubTopics.ENQUEUED_COMMANDS.format(self._device_id)):
params = topic.split(
"devices/{}/messages/devicebound/".format(self._device_id),
1)[1].split('&')
for param in params:
p = param.split('=')
if p[0] == "method-name":
command_name = decode_uri_component(p[1])
command = Command(command_name, message)
try:
command_name_with_components = command_name.split("*")
if len(command_name_with_components) > 1:
# In a component
self._logger.debug("Command in a component")
command = Command(
command_name_with_components[1],
message,
component_name=command_name_with_components[0],
)
except:
pass
self._logger.debug(
'Received enqueued command {} with message: {}'.format(
command.name, command.value))
self._on_enqueued_commands(command)
def connect(self, force_dps=False):
creds = None
if force_dps:
self._logger.info("Refreshing credentials...")
if self._storage is not None and force_dps is False:
creds = self._storage.retrieve()
if creds is None:
prov = ProvisioningClient(self._id_scope, self._device_id,
self._credentials_type,
self._credentials, self._logger,
self._model_id)
creds = prov.register()
self._mqtt_client = MQTTClient(self._device_id,
creds.host,
8883,
creds.user,
creds.password,
ssl=True,
keepalive=60)
self._commands_regex = ure.compile(
'\$iothub\/methods\/POST\/(.+)\/\?\$rid=(.+)')
try:
self._mqtt_client.connect(False)
self._connected = True
self._logger.info('Device connected!')
if self._storage:
self._storage.persist(creds)
self._mqtt_client.set_callback(self._on_message)
self._mqtt_client.subscribe(HubTopics.TWIN)
self._mqtt_client.subscribe('{}/#'.format(HubTopics.PROPERTIES))
self._mqtt_client.subscribe('{}/#'.format(HubTopics.COMMANDS))
self._mqtt_client.subscribe('{}/#'.format(
HubTopics.ENQUEUED_COMMANDS.format(self._device_id)))
self._logger.debug(self._twin_request_id)
self._mqtt_client.publish(
HubTopics.TWIN_REQ.format(
self._twin_request_id).encode('utf-8'), '{{}}')
except:
self._logger.info("ERROR: Failed to connect to Hub")
if force_dps is True:
exit(1)
self.connect(True)
def is_connected(self):
if self._connected == True:
return True
return False
def set_model_id(self, model):
self._model_id = model
def send_property(self, payload):
self._logger.debug('Sending properties {}'.format(json.dumps(payload)))
self._mqtt_client.publish(
HubTopics.PROP_REPORT.format(time()).encode('utf-8'),
json.dumps(payload))
def send_telemetry(self, payload, properties=None):
topic = 'devices/{}/messages/events/?$.ct={}&$.ce={}'.format(
self._device_id, self._content_type, self._content_encoding)
if properties is not None:
for prop in properties:
topic += '&{}={}'.format(prop, properties[prop])
self._mqtt_client.publish(topic.encode('utf-8'),
json.dumps(payload).encode('utf-8'))
def on(self, event, callback):
self._events[event] = callback
def listen(self):
if not self.is_connected():
return
self._mqtt_client.ping()
self._mqtt_client.wait_msg()
sleep(0.5)
def _handle_property_ack(
self,
callback,
property_name,
property_value,
property_version,
component_name=None,
):
if callback is not None:
ret = callback(property_name, property_value, component_name)
else:
ret = True
if ret:
if component_name is not None:
self._logger.debug("Acknowledging {}".format(property_name))
self.send_property({
"{}".format(component_name): {
"{}".format(property_name): {
"ac": 200,
"ad": "Property received",
"av": property_version,
"value": property_value,
}
}
})
else:
self._logger.debug("Acknowledging {}".format(property_name))
self.send_property({
"{}".format(property_name): {
"ac": 200,
"ad": "Property received",
"av": property_version,
"value": property_value,
}
})
else:
self._logger.debug(
'Property "{}" unsuccessfully processed'.format(property_name))
def on_properties_update(self, patch):
try:
prop_cb = self._events[IoTCEvents.PROPERTIES]
except:
return
# Set component at false by default
is_component = False
for prop in patch:
is_component = False
if prop == "$version":
continue
# check if component
try:
is_component = patch[prop]["__t"]
except KeyError:
pass
if is_component:
for component_prop in patch[prop]:
if component_prop == "__t":
continue
self._logger.debug(
'In component "{}" for property "{}"'.format(
prop, component_prop))
self._handle_property_ack(
prop_cb,
component_prop,
patch[prop][component_prop]["value"],
patch["$version"],
prop,
)
else:
self._handle_property_ack(prop_cb, prop, patch[prop]["value"],
patch["$version"])
def _cmd_resp(self, command: Command, value):
self._logger.debug('Responding to command "{}" request'.format(
command.name))
self.send_property({
'{}'.format(command.name): {
'value': value,
'requestId': command.request_id
}
})
def _on_commands(self, command: Command):
try:
cmd_cb = self._events[IoTCEvents.COMMANDS]
except KeyError:
return
self._logger.debug('Received command {}'.format(command.name))
cmd_cb(command)
def _on_enqueued_commands(self, command: Command):
try:
cmd_cb = self._events[IoTCEvents.ENQUEUED_COMMANDS]
except KeyError:
return
self._logger.debug('Received enqueued command {}'.format(command.name))
cmd_cb(command)
class IoTCClient():
def __init__(self,
id_scope,
device_id,
credentials_type: IoTCConnectType,
credentials,
logger=None):
self._device_id = device_id
self._id_scope = id_scope
self._credentials_type = credentials_type
self._content_type = 'application%2Fjson'
self._content_encoding = 'utf-8'
self._connected = False
self._credentials = credentials
self._events = {}
self._model_id = None
if logger is not None:
self._logger = logger
else:
self._logger = ConsoleLogger(IoTCLogLevel.API_ONLY)
self._twin_request_id = time()
def set_content_type(self, content_type):
self._content_type = encode_uri_component(content_type)
def set_content_encoding(self, content_encoding):
self._content_encoding = content_encoding
def set_log_level(self, log_level: IoTCLogLevel):
self._logger.set_log_level(log_level)
def _on_message(self, topic, message):
topic = topic.decode('utf-8')
if topic == HubTopics.TWIN_RES.format(200, self._twin_request_id):
self._logger.info('Received twin: {}'.format(message))
if topic.startswith(HubTopics.PROPERTIES):
# desired properties
self._logger.info(
'Received desired property message: {}'.format(message))
message = json.loads(message.decode('utf-8'))
self.on_properties_update(message)
elif topic.startswith(HubTopics.COMMANDS):
# commands
self._logger.info('Received command {} with message: {}'.format(
topic, message))
match = self._commands_regex.match(topic)
if match is not None:
if all(m is not None for m in [match.group(1),
match.group(2)]):
command_name = match.group(1)
command_req = match.group(2)
command = Command(command_name, command_req)
if message is not None:
command.payload = message
self._on_commands(command)
elif topic.startswith(
HubTopics.ENQUEUED_COMMANDS.format(self._device_id)):
params = topic.split(
"devices/{}/messages/devicebound/".format(self._device_id),
1)[1].split('&')
for param in params:
p = param.split('=')
if p[0] == "method-name":
command_name = p[1].split("Commands%3A")[1]
self._logger.info(
'Received enqueued command {} with message: {}'.format(
command_name, message))
command = Command(command_name, None)
if message is not None:
command.payload = message
self._on_enqueued_commands(command)
def connect(self):
prov = ProvisioningClient(self._id_scope, self._device_id,
self._credentials_type, self._credentials,
self._logger, self._model_id)
creds = prov.register()
self._mqtt_client = MQTTClient(self._device_id,
creds.host,
8883,
creds.user.encode('utf-8'),
creds.password.encode('utf-8'),
ssl=True,
keepalive=60)
self._commands_regex = ure.compile(
'\$iothub\/methods\/POST\/(.+)\/\?\$rid=(.+)')
self._mqtt_client.connect(False)
self._connected = True
self._logger.info('Device connected!')
self._mqtt_client.set_callback(self._on_message)
self._mqtt_client.subscribe(HubTopics.TWIN)
self._mqtt_client.subscribe('{}/#'.format(HubTopics.PROPERTIES))
self._mqtt_client.subscribe('{}/#'.format(HubTopics.COMMANDS))
self._mqtt_client.subscribe('{}/#'.format(
HubTopics.ENQUEUED_COMMANDS.format(self._device_id)))
self._logger.debug(self._twin_request_id)
self._mqtt_client.publish(
HubTopics.TWIN_REQ.format(self._twin_request_id).encode('utf-8'),
'{{}}')
def is_connected(self):
if self._connected == True:
return True
return False
def set_model_id(self, model):
self._model_id = model
def send_property(self, payload):
self._logger.debug('Sending properties {}'.format(json.dumps(payload)))
self._mqtt_client.publish(
HubTopics.PROP_REPORT.format(time()).encode('utf-8'),
json.dumps(payload))
def send_telemetry(self, payload, properties=None):
topic = 'devices/{}/messages/events/?$.ct={}&$.ce={}'.format(
self._device_id, self._content_type, self._content_encoding)
if properties is not None:
for prop in properties:
topic += '{}={}&'.format(
encode_uri_component(prop),
encode_uri_component(properties[prop]))
topic = topic[:-1]
self._mqtt_client.publish(topic.encode('utf-8'),
json.dumps(payload).encode('utf-8'))
def on(self, event, callback):
self._events[event] = callback
def listen(self):
if not self.is_connected():
return
self._mqtt_client.ping()
self._mqtt_client.wait_msg()
sleep(1)
def on_properties_update(self, patch):
try:
prop_cb = self._events[IoTCEvents.PROPERTIES]
except:
return
for prop in patch:
if prop == '$version':
continue
ret = prop_cb(prop, patch[prop]['value'])
if ret:
self._logger.debug('Acknowledging {}'.format(prop))
self.send_property({
'{}'.format(prop): {
"value": patch[prop]["value"],
'status': 'completed',
'desiredVersion': patch['$version'],
'message': 'Property received'
}
})
else:
self._logger.debug(
'Property "{}" unsuccessfully processed'.format(prop))
def _cmd_resp(self, command: Command, value):
self._logger.debug('Responding to command "{}" request'.format(
command.name))
self.send_property({
'{}'.format(command.name): {
'value': value,
'requestId': command.request_id
}
})
def _cmd_ack(self, command: Command):
self._logger.debug('Acknowledging command {}'.format(command.name))
self._mqtt_client.publish(
'$iothub/methods/res/{}/?$rid={}'.format(
200, command.request_id).encode('utf-8'), '')
def _on_commands(self, command: Command):
try:
cmd_cb = self._events[IoTCEvents.COMMANDS]
except KeyError:
return
self._logger.debug('Received command {}'.format(command.name))
self._cmd_ack(command)
cmd_cb(command, self._cmd_resp)
def _on_enqueued_commands(self, command: Command):
try:
cmd_cb = self._events[IoTCEvents.ENQUEUED_COMMANDS]
except KeyError:
return
self._logger.debug('Received enqueued command {}'.format(command.name))
self._cmd_ack(command)
cmd_cb(command)
strip.write()
time.sleep(parsed['s'])
strip.fill([0, 0, 0, 0])
strip.write()
def handle_mqtt_message(topic, message):
if topic == MQTT_PREFIX + b'json':
process_json(message)
if __name__ == '__main__':
strip = apa102.APA102(machine.Pin(APA102_PIN_CI),
machine.Pin(APA102_PIN_DI),
APA102_PIXELS)
strip.fill([0, 0, 0, 0])
strip.write()
del strip
wlan = network.WLAN(network.STA_IF)
while not wlan.isconnected():
pass # Wait until connected to wifi
mqtt = MQTTClient("gyro", MQTT_BROKER)
mqtt.set_callback(handle_mqtt_message)
mqtt.connect()
mqtt.subscribe(MQTT_PREFIX + b'json')
while True:
try:
mqtt.wait_msg()
except:
pass # Ignore errors in request handling
class Mqtt:
def __init__(self,
mqttapi,
ADAFRUIT_IO_URL=b'io.adafruit.com',
ADAFRUIT_USERNAME=b'Dreambot',
ADAFRUIT_IO_KEY=b'aio_AdWB65gxoBGd08a7ja2Ws0DJr1WJ',
mqtt_client_id=bytes(
'client_' + str(int.from_bytes(os.urandom(3), 'little')),
'utf-8'),
WIFI_SSID='Bendix',
WIFI_PASSWORD='******',
MAX_ATTEMPTS=20,
attempt_count=0):
self.ADAFRUIT_USERNAME = ADAFRUIT_USERNAME
self.mqttapi = mqttapi
self.client = MQTTClient(client_id=mqtt_client_id,
server=ADAFRUIT_IO_URL,
user=ADAFRUIT_USERNAME,
password=ADAFRUIT_IO_KEY,
ssl=False)
# turn off the WiFi Access Point
self.ap_if = network.WLAN(network.AP_IF)
self.ap_if.active(False)
# connect the device to the WiFi network
self.wifi = network.WLAN(network.STA_IF)
self.wifi.active(True)
self.wifi.connect(WIFI_SSID, WIFI_PASSWORD)
# wait until the device is connected to the WiFi network
while not self.wifi.isconnected() and attempt_count < MAX_ATTEMPTS:
attempt_count += 1
time.sleep(1)
print(attempt_count)
if attempt_count == MAX_ATTEMPTS:
print('could not connect to the WiFi network')
sys.exit()
try:
self.client.connect()
except Exception as e:
print('could not connect to MQTT server {}{}'.format(
type(e).__name__, e))
sys.exit()
self.client.set_callback(self.cb)
self.feednames = [
b'Peltier Element',
b'Fan',
b'P',
b'I',
b'D',
]
for feedname in self.feednames:
txt = bytes('{:s}/feeds/{:s}'.format(ADAFRUIT_USERNAME, feedname),
'utf-8')
self.client.subscribe(txt)
def __call__(self):
try:
self.client.wait_msg()
except KeyboardInterrupt:
print('Ctrl-C pressed...exiting')
self.client.disconnect()
sys.exit()
def cb(self, topic, msg):
try:
self.mqttapi[topic](str(msg, 'utf-8'))
except Exception as e:
print(e)
print("missing key in " + str(topic, 'utf-8'))
finally:
print(topic)
print(msg)
def publish(self, topic, value):
try:
mqtt_feedname = bytes(
'{:s}/feeds/{:s}'.format(self.ADAFRUIT_USERNAME, topic),
'utf-8')
self.client.publish(mqtt_feedname,
bytes(str(value), 'utf-8'),
qos=0)
except KeyboardInterrupt:
print('Ctrl-C pressed...exiting')
self.client.disconnect()
sys.exit()
finally:
return value
class UnmanagedDevice:
"""
An "unmanaged device" for the Watson IoT platform.
Can be used with "Quickstart";
see https://quickstart.internetofthings.ibmcloud.com
"""
decoders = {}
encoders = {}
commands = {}
def __init__(self,
org=QUICKSTART_ORG,
device_type=None,
device_id=None,
username='******',
token='',
port=8883,
clean_session=True,
domain=DOMAIN,
ssl_params=None,
log_level='info'):
"""
Builds proper params for connecting to IoT platform MQTT broker.
Registers JSON encoder & decoder.
Creates MQTT client object, but does not connect.
`quickstart` implies an *insecure* connection!
`device_type` and `token` not necessary if `org` is `quickstart`.
:param log_level: Logging level
:type log_level: str
:param org: IoT platform organization
:type org: str
:param device_type: IoT platform device type
:type device_type: str
:param device_id: IoT platform client identifier
:type device_id: str
:param username: IoT platform username
:type username: str
:param token: IoT platform API token
:type token: str
:param port: MQTT broker port
:type port: int
:param clean_session: Whether to use a clean session when connecting
:type clean_session: bool
:param domain: IoT platform domain name
:type domain: str
:param ssl_params: Additional SSL parameters for a secure connection
:type ssl_params: dict
"""
if not device_id:
raise Exception('"device_id" parameter required')
self.org = org
if not self.is_quickstart:
if not device_type:
raise Exception('"device_type" parameter required')
if not token:
raise Exception('"token" parameter required')
self.username = username
self.token = token
self.device_type = device_type
self.address = '%s.messaging.%s' % (org, domain)
self.client_id = 'd:%s:%s:%s' % (self.org, self.device_type, device_id)
self.port = port
self.keep_alive = 60
self.logger = logging.getLogger(
'%s.%s' % (self.__module__, self.__class__.__name__))
self.logger.level = LOG_LEVELS[log_level]
self.clean_session = clean_session
self.ssl_params = ssl_params or {}
self.client = MQTTClient(self.client_id,
self.address,
user=self.username,
password=self.token,
keepalive=60,
ssl=self.is_secure,
ssl_params=self.ssl_params)
if self.logger.level == logging.DEBUG:
self.client.DEBUG = True
self.set_decoder('json', bytes_to_json)
self.set_encoder('json', json.dumps)
self.set_decoder('text', bytes_to_utf8)
# noinspection PyTypeChecker
self.set_encoder('text', str)
@property
def is_connected(self):
"""
Crudely checks connectivity by pinging
:return: Whether or not socket is alive
:rtype: bool
"""
try:
self.client.ping()
return True
except OSError:
return False
def set_encoder(self, name, func):
"""
"Registers" an encoder
:param name: Name of encoder
:type name: str
:param func: Encoding function
:type func: function
"""
self.encoders[name] = func
def unset_encoder(self, name):
"""
"Un-registers" a encoder
:param name: Name of existing encoder
:type name: str
"""
try:
del self.encoders[name]
except KeyError:
pass
def set_decoder(self, name, func):
"""
"Registers" a decoder
:param name: Name of decoder
:type name: str
:param func: Decoding function
:type func: function
"""
self.decoders[name] = func
def unset_decoder(self, name):
"""
"Un-registers" a decoder
:param name: Name of existing decoder
:type name: str
"""
try:
del self.decoders[name]
except KeyError:
pass
def set_command(self, command_id, handler):
"""
"Registers" a command handler (if org is not "quickstart")
:param command_id: Command ID
:type command_id: str
:param handler: Command handler
:type handler: function
"""
if self.is_quickstart:
raise Exception('"quickstart" org does not support commands')
self.commands[command_id] = handler
def unset_command(self, command_id):
"""
"Unregisters" a command
:param command_id: Command ID
:type command_id: str
"""
try:
del self.commands[command_id]
except KeyError:
pass
@property
def is_secure(self):
"""
Secure connection? `False` if `org` is `quickstart`
:return: Whether or not SSL is enabled.
:rtype: bool
"""
return self.port == 8883 and not self.is_quickstart
@property
def is_quickstart(self):
"""
Is "quickstart" org?
:return: Whether or not `org` is `quickstart`
:rtype: bool
"""
return self.org == QUICKSTART_ORG
def connect(self):
"""
Connects to the MQTT broker. If not a "quickstart" org,
then subscribes to commands.
"""
self.client.connect(self.clean_session)
self.logger.debug('client "%s" connected to %s:%s' %
(self.client_id, self.address, self.port))
if not self.is_quickstart:
def message_callback(topic, message):
"""
Callback executed when a msg for a subscribed topic is received
:param topic: Raw MQTT topic
:type topic: bytes
:param message: Raw MQTT message
:type message: bytes
"""
topic = bytes_to_utf8(topic)
matches = TOPIC_REGEX.match(topic)
command_id = matches.group(1)
message_format = matches.group(2)
if message_format in self.decoders:
message = self.decoders[message_format](message)
else:
self.logger.debug(
'no suitable decoder for message format "%s"' %
message_format)
self.logger.debug('topic: %s\nmessage: %s' % (topic, message))
if command_id in self.commands:
self.logger.info('received command "%s"' % command_id)
self.commands[command_id](message)
else:
self.logger.warning('command "%s" received, \
but no handler registered' % command_id)
self.client.set_callback(message_callback)
self.client.subscribe(DEVICE_COMMAND_TOPIC)
self.logger.debug('subscribed to device command topic: %s',
DEVICE_COMMAND_TOPIC)
def publishEvent(self, event_id, payload, message_format='json', qos=0):
"""
Publishes an event
:param event_id: Event ID
:type event_id: str
:param payload: Event payload
:type payload: Any
:param message_format: Message format
:type message_format: str
:param qos: Quality of Service
:type qos: int
"""
if not self.is_connected:
raise Exception('client is not connected')
if qos == 2:
raise Exception('QoS level 2 not implemented')
event_id = event_id.strip()
if message_format in self.encoders:
payload = self.encoders[message_format](payload)
self.client.publish('iot-2/evt/%s/fmt/%s' % (event_id, message_format),
payload, qos)
def disconnect(self):
"""
Disconnects (if connected)
"""
try:
self.client.disconnect()
self.logger.warning('Closed connection to the IBM Watson \
IoT Platform')
except OSError:
self.logger.warning('Attempted to disconnect from a \
disconnected socket')
def loop(self):
"""
Non-blocking check-for-messages. You need to do something else
after this, such as `time.sleep(1)`, or other meaningful work,
if you are going to do this in a busy-loop.
This appears unsupported in some environments (incl. unix)
"""
self.client.check_msg()
def sync_loop(self):
"""
Blocking check-for-messages. Run this in a busy-loop.
"""
self.client.wait_msg()
c.set_callback(sub_cb)
# Connect to server, requesting not to clean session for this
# client. If there was no existing session (False return value
# from connect() method), we perform the initial setup of client
# session - subscribe to needed topics. Afterwards, these
# subscriptions will be stored server-side, and will be persistent,
# (as we use clean_session=False).
#
# There can be a problem when a session for a given client exists,
# but doesn't have subscriptions a particular application expects.
# In this case, a session needs to be cleaned first. See
# example_reset_session.py for an obvious way how to do that.
#
# In an actual application, it's up to its developer how to
# manage these issues. One extreme is to have external "provisioning"
# phase, where initial session setup, and any further management of
# a session, is done by external tools. This allows to save resources
# on a small embedded device. Another extreme is to have an application
# to perform auto-setup (e.g., clean session, then re-create session
# on each restart). This example shows mid-line between these 2
# approaches, where initial setup of session is done by application,
# but if anything goes wrong, there's an external tool to clean session.
if not c.connect(clean_session=False):
print("New session being set up")
c.subscribe(b"foo_topic")
while 1:
c.wait_msg()
c.disconnect()
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect(WIFI_SSID, WIFI_PW)
sta_if.ifconfig()
client = MQTTClient(client_id=MQTT_CLIENT_ID,
server=MQTT_HOST,
port=8883,
keepalive=4000,
ssl=True,
ssl_params={
"key": key,
"cert": cert,
"server_side": False
})
def subfunc(topic, msg):
print(msg)
client.set_callback(subfunc)
client.connect()
print("Connect")
client.subscribe(topic=SUB_MQTT_TOPIC)
LED = Pin(14, Pin.OUT)
while True:
print(type(client.wait_msg()))
