def publish(self, topic, payload, retain=True, qos=1):
# try wifi reconnect in case it lost connection
utils.wifi_connect()
if not isinstance(payload, bytes):
payload = bytes(str(payload), 'utf-8')
t = b'/'.join((self.topic, topic))
done = False
while not done:
try:
print('MQTT PUBLISH: {} --> {}'.format(t, payload))
self.mqtt.publish(t, payload, retain=retain, qos=qos)
done = True
except Exception as e:
# some error during publishing
done = False
done_reconnect = False
utime.sleep(RETRY_DELAY)
# tries to reconnect
while not done_reconnect:
try:
self._mqtt_connect()
self.publish_properties() # re-publish
done_reconnect = True
except Exception as e:
done_reconnect = False
print('ERROR: cannot connect, {}'.format(str(e)))
utime.sleep(RETRY_DELAY)
def __init__(self, settings):
self.errors = 0
self.settings = settings
self.nodes = []
self.node_ids = []
self.topic_callbacks = {}
self.start_time = utime.time()
self.next_update = utime.time()
self.stats_interval = self.settings.DEVICE_STATS_INTERVAL
# base topic
self.topic = b'/'.join((self.settings.MQTT_BASE_TOPIC,
self.settings.DEVICE_ID))
# setup wifi
utils.setup_network()
utils.wifi_connect()
try:
self._mqtt_connect()
except Exception as e:
print('ERROR: can not connect to MQTT')
print(e)
def __init__(self, settings):
self._state = "init"
self.mqtt = None
self.errors = 0
self.settings = settings
self.retry_delay = 10
self.nodes = []
self.node_ids = []
self.topic_callbacks = {}
self.start_time = time()
self.next_update = time()
self.stats_interval = self.settings.DEVICE_STATS_INTERVAL
# device base topic
self.topic = b"/".join((settings.MQTT_BASE_TOPIC, settings.DEVICE_ID))
# setup wifi
utils.setup_network()
utils.wifi_connect()
try:
self._umqtt_connect()
except Exception:
print("ERROR: can not connect to MQTT")
def publish(self, topic, payload, retain=True):
# try wifi reconnect in case it lost connection
utils.wifi_connect()
if not isinstance(payload, bytes):
payload = bytes(str(payload), "utf-8")
t = b"/".join((self.topic, topic))
done = False
while not done:
try:
# print('MQTT PUBLISH: {} --> {}'.format(t, payload))
self.mqtt.publish(t, payload, retain=retain, qos=1)
done = True
except Exception:
# some error during publishing
done = False
done_reconnect = False
sleep(self.retry_delay)
# tries to reconnect
while not done_reconnect:
try:
self._umqtt_connect()
self.publish_properties() # re-publish
self.subscribe_topics() # re-subscribe
done_reconnect = True
except Exception as e:
done_reconnect = False
print("ERROR: cannot connect, {}".format(str(e)))
sleep(self.retry_delay)
def start(self):
"""publish device and node properties, run forever"""
self.publish_properties()
gc.collect()
while True:
if not utils.wlan.isconnected():
utils.wifi_connect()
# publish device data
self.publish_data()
# check for new mqtt messages
self.mqtt.check_msg()
sleep(1)
def __init__(self, settings):
self._state = "init"
self._stime = time()
self.stats_interval = settings.DEVICE_STATS_INTERVAL
self.nodes = []
self.callback_topics = {}
self.device_name = settings.DEVICE_NAME
self.btopic = settings.MQTT_BASE_TOPIC
self.dtopic = SLASH.join(
(settings.MQTT_BASE_TOPIC, settings.DEVICE_ID)
)
# setup networking
utils.setup_network(settings.WIFI_PASSWORD)
utils.wifi_connect(settings.WIFI_SSID)
self.mqtt = MQTTClient(
client_id=settings.DEVICE_ID,
server=settings.MQTT_BROKER,
port=settings.MQTT_PORT,
user=settings.MQTT_USERNAME,
password=settings.MQTT_PASSWORD,
keepalive=settings.MQTT_KEEPALIVE,
ssl=settings.MQTT_SSL,
ssl_params=settings.MQTT_SSL_PARAMS,
subs_cb=self.sub_cb,
connect_coro=self.connection_handler,
will=(SLASH.join((self.dtopic, DEVICE_STATE)), b"lost", True, QOS),
)
# Start coros
loop = get_event_loop()
loop.create_task(self.publish_stats())
def start(self):
"""publish device and node properties, run forever"""
self.publish_properties()
self.subscribe_topics()
gc.collect()
self.set_state("ready")
while True:
try:
if not utils.wlan.isconnected():
utils.wifi_connect()
# publish device data
self.publish_data()
# check for new mqtt messages
self.mqtt.check_msg()
idle()
sleep(1)
except KeyboardInterrupt:
self.set_state("disconnected")
self.mqtt.disconnect()
