def initMQTT():
topic = config.MQTT_TOPIC
bTopic = bytes(topic, 'UTF-8')
c = MQTTClient(config.MQTT_CLIENT_ID,
config.MQTT_SERVER,
user=secrets.MQTT_USER,
password=secrets.MQTT_PASS)
# Print diagnostic messages when retries/reconnects happens
c.DEBUG = False
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=True):
c.subscribe(bTopic)
return c
def main():
led = Pin(2, Pin.OUT, value=1)
def sub_cb(topic, msg):
led.off() # actually on
utime.sleep_ms(500)
led.on() # actually off
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect(WLAN_ESSID, WLAN_PASSWORD)
while not sta_if.isconnected():
utime.sleep_ms(1)
print("WLAN Connected")
c = MQTTClient(MQTT_ID,
MQTT_SERVER,
user=MQTT_USERNAME,
password=MQTT_PASSWORD)
c.DEBUG = True
c.set_callback(sub_cb)
c.connect(clean_session=False)
c.subscribe(MQTT_TOPIC)
print("MQTT Connected")
gc.collect()
while True:
c.check_msg()
utime.sleep_ms(10)
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 create_mqtt_client(client_id, hostname, username, password, port=8883, keepalive=120, ssl=True):
if not keepalive:
keepalive = 120
if not ssl:
ssl = True
c = MQTTClient(client_id=client_id, server=hostname, port=8883, user=username, password=password, keepalive=120, ssl=True)
c.DEBUG = True
return c
def init_mqtt():
log("MQTT Connecting")
cli = MQTTClient(config.mqtt_name, config.mqtt_server)
cli.DEBUG = True
cli.set_callback(sub_cb)
cli.connect()
cli.subscribe(config.mqtt_subscribe)
log("MQTT Connected")
return cli
def Conexion_MQTT():
#client_id = b"Covid_1" + ubinascii.hexlify(machine.unique_id())
client_id = CONFIG["client_id"]
mqtt_server = CONFIG["broker"]
port_mqtt = 1883
user_mqtt = None #Si su servidor no necesita usuario escribe None sin comillas
pswd_mqtt = None #Si su servidor no necesita contraseña escribe None sin comillas
client = MQTTClient(client_id, mqtt_server,port_mqtt,user_mqtt,pswd_mqtt)
client.DEBUG = True
client.set_callback(form_sub)
client.connect(True)
client.subscribe(CONFIG["subscribe"])
print('Conectado a %s' % mqtt_server)
return client
def connect():
from umqtt.robust import MQTTClient
c = MQTTClient(ID, mqttHost, ssl=mqttSSL, user=mqttUser, password=mqttPass)
c.DEBUG = True
if not c.connect():
print('connected, will publish to {}/{}/#'.format(mqttTopicRoot, ID))
c.set_last_will('{}/{}/status'.format(mqttTopicRoot, ID),
'offline',
retain=True)
c.publish('{}/{}/status'.format(mqttTopicRoot, ID),
'connected',
retain=True)
return c
return None
def mqtt_reconnect():
# Create an instance of MQTTClient
global client
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.DEBUG = True
client.set_callback(onMessage)
client.connect(clean_session=True)
client.subscribe(CONFIG['TOPIC'])
print("ESP8266 is Connected to %s and subscribed to %s topic" %
(CONFIG['MQTT_BROKER'], CONFIG['TOPIC']))
def main():
i2c = machine.I2C(scl=machine.Pin(5), sda=machine.Pin(4), freq=10000)
led = machine.Pin(2, machine.Pin.OUT)
do_connect()
client = MQTTClient(cfg.getSYS("mqtt.id"), cfg.getSYS("mqtt.broker"))
client.DEBUG = True
client.set_callback(sub_cb)
if not client.connect(clean_session=True):
client.subscribe(t.ACTION_STATUS + "/#")
client.publish(t.CONNECT, cfg.getSYS("serial"))
while 1:
print("loop START")
gc.collect()
toggle(led)
update_sensors(client, i2c)
utime.sleep(1)
client.check_msg()
toggle(led)
client.disconnect()
def __init__(self, connection_string):
self._connection_string = connection_string
self._lastUpdated = 0
self._updateSas = True
parsed_connection = self._parse_connection()
self._shared_access_key = parsed_connection.get("SharedAccessKey")
self._shared_access_key_name = parsed_connection.get("SharedAccessKeyName")
self._gateway_hostname = parsed_connection.get("GatewayHostName")
self._hostname = parsed_connection.get("HostName")
self._device_id = parsed_connection.get("DeviceId")
self._module_id = parsed_connection.get("ModuleId")
self._username = self._hostname + '/' + self._device_id
self._c2d_cb = None
self._sas = self._generate_sas_token()
c = MQTTClient(client_id=self._device_id, server=self._hostname, port=8883, user=self._username, password=self._sas, keepalive=120, ssl=True)
c.DEBUG = True
c.set_callback(self._callback_handler)
self._mqtt_client = c
import time
from umqtt.robust import MQTTClient
def sub_cb(topic, msg):
print((topic, msg))
c = MQTTClient("umqtt_client", "localhost")
# Print diagnostic messages when retries/reconnects happens
c.DEBUG = True
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
from umqtt.robust import MQTTClient
import config
mqtt_client = MQTTClient(
server=config.MQTT_SERVER,
client_id=config.MQTT_CLIENT_ID,
user=config.MQTT_USER,
password=config.MQTT_PASSWORD,
)
mqtt_client.DEBUG = True
else:
return False
def sub_cb(topic, msg):
t = topic.decode('ASCII')
m = msg.decode('ASCII')
if t == IN:
print("IN: %s" % m)
if(m.startswith('T')):
if(len(m) > 2):
print(m[1] + m[2])
else:
print(m[1])
if(m == 'ligar led'):
pinA.value(1)
if(m == 'desligar led'):
pinA.value(0)
while True:
if wifi.isconnected():
umqtt_client = MQTTClient("P3", MQTT_SERVER)
umqtt_client.DEBUG = True
umqtt_client.set_callback(sub_cb)
umqtt_client.connect(clean_session=False)
umqtt_client.subscribe(IN)
print("Connected to MQTT broker: %s" % MQTT_SERVER)
break
while True:
umqtt_client.check_msg()
def init_controller(cli_name, mqtt_links):
"""
Prepares controller for work starting
initializes mqtt_links
"""
global ml
global cname
global mqtt_cli
global tool_verbs
ml = mqtt_links
cname = cli_name
groups = dict()
for t, ma in ml.items():
if ma[0] not in tool_verbs:
print("FATAL: Invalid tool type:", ma[0], "for link", t)
return None
else: # run initialization routine for the tool type
if tool_verbs[ma[0]][2](ma) != True:
print("FATAL: Could not initialize tool type [", ma[0],
"] for link [", t, "!!!")
return None
# check mosfet groups
if ma[0] == b"MOSFET":
if ma[1][3] != mlc.NO_GROUP:
if ma[1][3] not in groups:
groups[ma[1][3]] = [
mlc.NO_SEQ, []
] # first item is a sequence flag for a group
groups[ma[1][3]][1].append(
ma[1][0]) # group consists of pin numbers of mosfets
ma[2].insert(
3, groups[ma[1][3]]
) # group info holds in 4th item of the run-time objects list
if ma[1][3] == mlc.SEQ:
groups[ma[1][3]][0] = mlc.SEQ
# sequental group has an extra item in a group list which indicates next mosfet to power on
if len(groups[ma[1][3]]) == 2:
# add next mosfet index into group info
# it should be the first item in a group list
groups[ma[1][3]].append(groups[ma[1][3]][1][0])
else:
# if mosfet isn't in any group, add an empy group to its run-time
ma[2].insert(3, [mlc.NO_SEQ, []])
import mqtt_cfg
c = MQTTClient(cname, mqtt_cfg.mqtt_srv_name)
print("Trying to connect to", mqtt_cfg.mqtt_srv_name)
c.DEBUG = True
c.connect(clean_session=False)
print("Connected")
c.set_callback(cb)
# subscribe for mqtt links
for mak in ml.keys():
c.subscribe(mak)
print("Subscribed for", mak)
# subscribe for system mqtt requests
c.subscribe(cname)
print("Subscribed for", cname)
mqtt_cli = c
publish_status(b"READY")
return c
