def __init__(self, id, ip, topic_sub, robot): threading.Thread.__init__(self) self._client = MQTTClient(id, ip) self._client.set_callback(self.getmessages) self._client.connect() self._client.subscribe(topic_sub, qos=1) self._topic_sub = topic_sub self._id = id self._robot = robot self._delta_time = 1 self._topics = []
def connect_and_subscribe(): global client_id, mqtt_server, topic_sub client = MQTTClient(client_id, mqtt_server) client.set_callback(sub_cb) client.connect() client.subscribe(topic_sub) client.subscribe(topic_sub1) print('Connected to %s MQTT broker, subscribed to %s topic' % (mqtt_server, topic_sub)) return client
def mqttConnect(config): from umqtt.robust import MQTTClient # extract properties from JSON-parsed configuration brokerHost = str(config['mqtt']['brokerHost']) brokerPort = int(config['mqtt']['brokerPort']) print('Connecting to broker {}:{} as client ID={}'.format( brokerHost, brokerPort, getClientId())) global mqttClient mqttClient = MQTTClient(getClientId(), brokerHost, brokerPort) mqttClient.connect()
def _init_mqtt(self): MQTT_USER = env['MQTT_USER'] if 'MQTT_USER' in env.keys() else None MQTT_PASSWORD = env['MQTT_PASSWORD'] if 'MQTT_PASSWORD' in env.keys( ) else None # Create an mqtt client self.mqtt = MQTTClient(self.hardware_id, env['MQTT_HOST'], user=MQTT_USER, password=MQTT_PASSWORD) self.mqtt.set_callback(self._mqtt_callback)
def __init__(self, chair, host): self.chair = chair self.chair.register_observer(self) self.client = MQTTClient(client_id='SmartChair', server=host, user=hassio_mqtt_user, password=hassio_mqtt_pwd, port=1883, ssl=False) status = self.client.connect() if status != 0: print('Could not connect to MQTT broker')
def update(): c = MQTTClient("umqtt_client", MQTT_HOST) c.connect() standard_data = fetch_standard_data() print("Publishing: {}".format(standard_data)) c.publish("mc66c/energy", str(standard_data["energy"]), True) c.publish("mc66c/volume", str(standard_data["volume"]), True) c.publish("mc66c/temperature_flow", str(standard_data["temperature_flow"]), True) c.publish("mc66c/temperature_return", str(standard_data["temperature_return"]), True)
def __init__(self, client, broker, id): self.uid = '{:02x}{:02x}{:02x}{:02x}'.format(id[0], id[1], id[2], id[3]) self.client = MQTTClient(client, broker) self.client.set_callback(self.mqtt_sub_cb) print('attempt to %s MQTT broker' % (broker)) try: self.client.connect() print('Connected to %s MQTT broker' % (broker)) except: print("error connecting to MQTT broker") pass
class HackerLabState: def __init__(self): self.wlan = network.WLAN(network.STA_IF) self.wlan.active(True) ap = network.WLAN(network.AP_IF) ap.active(False) self.mqtt = MQTTClient(node_id, mqtt_host) self.do_connect() pin = Pin(button_pin, Pin.IN, Pin.PULL_UP) pin.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=self.state_changed) self.state = pin.value() while True: pass def do_connect(self): if not self.wlan.isconnected(): print("Connecting to wifi...") self.wlan.connect(credentials.wifi_ssid, credentials.wifi_password) while not self.wlan.isconnected(): pass print("Network config: ", self.wlan.ifconfig()) print("Connecting to MQTT...") if not self.mqtt.connect(): print("Connected") else: print("Could not connect") def state_changed(self, pin): pin_value = pin.value() active = 0 while active < 100: if pin.value() != pin_value: active += 1 else: active = 0 sleep_ms(1) self.state = pin_value print("State ", self.state) self.mqtt.publish(mqtt_topic, b"1" if self.state == 1 else b"0") urequests.get( "https://slack.com/api/chat.postMessage?token=%s&channel=hackerlab&text=Hackerlab%%20is%%20%s" % (credentials.slack_token, "OPEN" if self.state == 1 else "CLOSED"))
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 __init__(self): if config.POWER_ON_STATE: self.relay_control(1) self.led_control(0) self.device_status = "ON" self.mqtt_client = MQTTClient(client_id=config.DEVICE_NAME, server=config.MQTT_SERVER, port=config.MQTT_PORT, user=config.MQTT_USER, passwd=config.MQTT_PASSWD, keepalive=60) self.mqtt_client.set_callback(self.sub_callback) self.mqtt_client.set_last_will(config.AVAILABILITY_TOPIC, "offline") self.ping_mqtt = 0 self.ping_fail = 0 self.button_interrupt = 0
def __init__(self): config = Config() self.heatmessage = {'Heating': ''} self.tempMessage = {'TempIN': '', 'TempOUT': ''} self.mqttID = config.mqttID self.mqttBroker = config.mqttBroker self.user = config.mqttUser self.password = config.mqttPassword self.client = MQTTClient(self.mqttID, self.mqttBroker, 1883, self.user, self.password) self.client.connect() self.client.set_callback(sub_cb) self.client.subscribe(topic="home/attackHeater/stat")
def _connect(): try: global client _log.info("Connecting to %s:%s" % (_broker, _port)) client = MQTTClient(_client_id, _broker, user=_broker_username, password=_broker_password, port=_port) client.connect() _log.info("Connection successful") except Exception as ex: _log.error("error in _connect " + str(ex))
def begin(self, username, password, clientid, hostname='mqtt.mydevices.com', port=1883): """Initializes the client and connects to Cayenne. username is the Cayenne username. password is the Cayenne password. clientID is the Cayennne client ID for the device. hostname is the MQTT broker hostname. port is the MQTT broker port. """ self.rootTopic = "v1/%s/things/%s" % (username, clientid) self.client = MQTTClient(clientid, hostname, port, username, password) cayenne = self def lambda_on_message(topic, payload): #print("lambda_on_message") topic = str(topic.decode()) payload = str(payload.decode()) #print(topic) #print(payload) # CayenneMessage expect a msg object with topic and payload attributes class Msg: def __init__(self, topic, payload): self.topic = topic self.payload = payload on_message(cayenne.client, cayenne, Msg(topic, payload)) self.client.set_callback(lambda_on_message) try: self.client.connect(clean_session=True) except MQTTException(e): print("MQTTException %s\n" % str(e)) else: self.connected = True command_topic = self.getCommandTopic() print("SUB %s\n" % command_topic) self.client.subscribe(command_topic) self.mqttPublish("%s/sys/model" % self.rootTopic, "micropython") self.mqttPublish("%s/sys/version" % self.rootTopic, __version__) print("Connecting to %s..." % hostname)
def __init__(self, user_settings_dict): settings = user_settings_dict.get('mqtt') server = settings.get('brokerAddr') port = settings.get('brokerPort') username = settings.get('username') password = settings.get('password') client_id = 'hydrometer-' + str(ubinascii.hexlify(machine.unique_id()), 'UTF-8') self.enabled = settings.get('enabled') self.interval_ms = settings.get('pubIntervalMs') self.topic = settings.get('topic') if self.topic.endswith('/'): self.topic = self.topic[:-1] self.client = MQTTClient(client_id, server, port, username, password)
class MQTTWriter: __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._connect() def _connect(self): print("Connecting to %s:%s" % (self.host, self.port)) self.client.connect() print("Connection successful") def on_next(self, x): data = bytes(json.dumps(x), 'utf-8') self.client.publish(bytes(self.topic, 'utf-8'), data) 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 device_connect(): global MQTT_CLIENT try: #all this below runs once ,equivalent to Arduino's "setup" function) with open(KEY_FILE, "r") as f: key = f.read() print("set private Key") with open(CERT_FILE, "r") as f: cert = f.read() print("set client Cert") 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() print('MQTT Connected') MQTT_CLIENT.set_callback(sub_cb) MQTT_CLIENT.subscribe(SUB_TOPIC) print('Subscribed to %s as the incoming topic' % (SUB_TOPIC)) return MQTT_CLIENT except Exception as e: print('Cannot connect MQTT: ' + str(e)) raise
class MQTTWriter: __slots__ = ('client') def __init__(self, id='1', server='io.adafruit.com', user='******', password = '******', port=1883): self.client = MQTTClient( client_id=id, server=server, user=user, password='******', port=port ) self._connect() def _connect(self): print("Connecting.....")) self.client.connect() print("Connection successful") def on_next(self, topic, data): # data = bytes(json.dumps(x), 'utf-8') # self.client.publish(bytes(self.topic, 'utf-8'), data) self.client.publish(topic=topic, msg=data) 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 main(): config = utils.Config() # On board LED led = machine.Pin(2, machine.Pin.OUT, machine.Pin.PULL_UP) sensor = dht.DHT22(machine.Pin(config.get("dht_gpio", 4))) client_id = "esp8266_" + ubinascii.hexlify(machine.unique_id()).format() client = MQTTClient(client_id, config.get("mqtt_broker"), config.get("mqtt_port"), config.get("mqtt_user"), config.get("mqtt_passwd")) try: client.connect() except OSError as e: # Just report and continue, since publish will try to reconnect print("Error when connecting to the MQTT broker") else: print("Connected to {}".format(config.get("mqtt_broker"))) # Iterate and publish while True: sensor.measure() led.low() client.publish("{}/temperature".format(config.get("mqtt_topic")), str(sensor.temperature())) client.publish("{}/humidity".format(config.get("mqtt_topic")), str(sensor.humidity())) led.high() time.sleep(5)
def send_mqtt(payload_out): global ip slimDNS = None try: slimDNS = SlimDNSServer(wlan.ifconfig()[0]) host_address_bytes = slimDNS.resolve_mdns_address(MQTT_SERVER_MDNS_ADDRESS) print(host_address_bytes) if ip != None: print(ip) ip = bytes_to_dotted_ip(host_address_bytes) except Exception as e: print("Could not connect find mDNS address " + str(e)) if ip != None: print('Connecting to MQTT server:', ip) mqtt = None try: mqtt = MQTTClient(client_id=unique_id, server=ip, port=1883) mqtt.connect() except Exception as e: print('Could not connect to MQTT server') return try: mqtt.publish("vendingmachine/sensors", payload_out) mqtt.disconnect() except Exception: print("Failed To Publish")
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 __init__(self, server, user, password, sname): self.topic = bytes('{}/feeds/{}-{{:s}}'.format(user, sname.lower()), 'utf-8').format client_id = hexlify(unique_id()).upper() self.client = MQTTClient(client_id, server, user=user, password=password) self.client.set_callback(self.buttons_cb) self.client.connect() # Subscribe to topics LOG.debug("Subscribe: %s", self.topic('force')) self.client.subscribe(self.topic('force'))
def connect_and_subscribe(client_id, broker_ip, broker_port, sub_callback=None, sub_topics=[]): # Set Options for MQTT-Broker client = MQTTClient(client_id, broker_ip, broker_port) # Set callback to handel Messages if sub_callback is not None: client.set_callback(sub_callback) # Connect client.connect(clean_session=False) for topic in sub_topics: client.subscribe(topic) time.sleep(3) client.check_msg() return client
def __init__(self): # Connect to MQTT broker. self.mqtt = MQTTClient( client_id="esp32_Upython", server=HOST, port = 8883, keepalive = 10000, ssl = True, ssl_params={"cert": certificate, "key": private_key, "server_side":False } ) time.sleep(4) self.mqtt.connect() print('Connected to AWS cloud')
def __init__(self, chair): self.chair = chair self.client = MQTTClient(client_id='SmartChair', server='mqtt.thingspeak.com', user=thingspeak_mqtt_user, password=thingspeak_mqtt_pwd, port=1883, ssl=False) status = self.client.connect() if status != 0: print('Could not connect to MQTT broker') self.timer = Timer(1) self.timer.init(period=1000 * 60, mode=Timer.PERIODIC, callback=self.on_timer_tick)
def __init__(self, server, user, password, sname): self.topic = bytes('/'.join([user, 'feeds/{}_{{:s}}'.format(sname)]), 'utf-8') client_id = hexlify(unique_id()).upper() self.client = MQTTClient(client_id, server, user=user, password=password) self.client.set_callback(self.buttons_cb) self.client.connect() # Subscribe to topics for topic in ['btn', 'sampling']: mqtt_button = self.topic.format(topic) self.client.subscribe(mqtt_button) self.sampling = SAMPLING mqtt_sampling = self.topic.format('sampling') self.client.publish(mqtt_sampling, bytes(str(self.sampling), 'utf-8'))
def init(self, protocol): self._log.debug("Protocol " + name + ": Init") self._client_id = protocol['client_id'] self._server = protocol['hostname'] self._port = protocol['port'] self._user = protocol['user'] self._password = protocol['password'] self._queue_out = protocol['publish'] self._queue_in = protocol['subscribe'] self._mq = MQTTClient(self._client_id, self._server, self._port, self._user, self._password) # Print diagnostic messages when retries/reconnects happens #self._mq.DEBUG = True self._queue = queues.Queue(maxsize=100) return self._queue
def __init__(self, led=None): self.led = led self.t = machine.Timer(0) self.a = machine.ADC(0) gc.collect() loops = 0 self.m = MQTTClient(config.mqtt.id, config.mqtt.host, **config.mqtt["auth"]) while True: try: self.m.connect() except (IndexError, OSError) as err: print("Retrying connect because of a {}...".format(str(err))) if loops > 10: print("Resetting the board") machine.reset() except MemoryError: print("Got a memory error. Resetting the board in 2 seconds") time.sleep(2) machine.reset() except: raise else: break loops += 1 time.sleep(1)
class TelemetryTransportMQTT: def __init__(self, uri, format): self.uri = uri self.format = format self.scheme, self.netloc, self.path, self.query, self.fragment = urlsplit( self.uri) self.connection = MQTTClient("umqtt_client", self.netloc) self.connection.DEBUG = True self.connection.connect() def send(self, request_data): topic = self.path.lstrip('/') print('MQTT Topic: ', topic) print('Payload: ', request_data['payload']) self.connection.publish(topic, request_data['payload']) return True
def __init__(self, server): self.station = network.WLAN(network.STA_IF) # self.station.ifconfig( # ('192.168.3.201', '255.255.255.0', '192.168.3.1', '192.168.3.1')) self.server = server self.station.active(True) self.station.connect() while self.station.isconnected() == False: pass print('wifi connected') client_id = ubinascii.hexlify(machine.unique_id()) + '-bbb' print(client_id, self.server) self.client = MQTTClient(client_id, self.server) self.client.connect() print('mqtt connected')
def __init__(self): self._client = MQTTClient( client_id=ubinascii.hexlify(machine.unique_id()), server="io.adafruit.com", user=settings.ADAFRUIT_IO_USERNAME, password=settings.ADAFRUIT_IO_KEY, ssl=False ) self._temp_feed = bytes( settings.ADAFRUIT_IO_USERNAME + "/feeds/" + settings.ADAFRUIT_TEMP_FEED, "utf-8" ) self._hum_feed = bytes( settings.ADAFRUIT_IO_USERNAME + "/feeds/" + settings.ADAFRUIT_HUM_FEED, "utf-8" )
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 mqtt_subscribe(self): client_id = b'tom_' + ubinascii.hexlify(machine.unique_id()) self.mqtt = MQTTClient(client_id, self.config['host'], port=int(self.config['port'])) self.mqtt.set_callback(self.mqtt_callback) self.mqtt.connect() self.mqtt.subscribe(self.config['topic'])
class MoistureMonitor(): def __init__(self, led=None): self.led = led self.t = machine.Timer(0) self.a = machine.ADC(0) gc.collect() loops = 0 self.m = MQTTClient(config.mqtt.id, config.mqtt.host, **config.mqtt["auth"]) while True: try: self.m.connect() except (IndexError, OSError) as err: print("Retrying connect because of a {}...".format(str(err))) if loops > 10: print("Resetting the board") machine.reset() except MemoryError: print("Got a memory error. Resetting the board in 2 seconds") time.sleep(2) machine.reset() except: raise else: break loops += 1 time.sleep(1) def start(self): self.m.publish(b'nodes', 'hi there') self.t.init(period=5000, mode=machine.Timer.PERIODIC, callback=lambda t: self.update()) def stop(self): self.t.deinit() def update(self): now = time.localtime() tstamp = "{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format(*now[0:6]) val = { "m": self.a.read() / 1024, "t": tstamp } print("Updating moisture, new value is {}".format(val)) self.m.publish(b"moisture", json.dumps(val).encode('utf-8'), retain=True) if self.led is not None: self.led(0) time.sleep(0.1) self.led(1)
class DoorAlarm(object): def __init__(self): self.config = None self.p0 = machine.Pin(2, machine.Pin.OUT) def load_config(self): with open('cfg.json', 'r') as cfg: self.config = ujson.load(cfg) def connect_wifi(self): ap_if = network.WLAN(network.AP_IF) ap_if.active(False) sta_if = network.WLAN(network.STA_IF) sta_if.active(True) if sta_if.isconnected(): sta_if.disconnect() sta_if.connect(self.config['ssid'], self.config['passwd']) for _ in range(20): time.sleep(1) if sta_if.isconnected(): return print('Unable to connect to AP: {}'.format(ssid)) sys.exit(1) def mqtt_callback(self, topic, msg): self.p0.value(not self.p0.value()) def mqtt_subscribe(self): client_id = b'tom_' + ubinascii.hexlify(machine.unique_id()) self.mqtt = MQTTClient(client_id, self.config['host'], port=int(self.config['port'])) self.mqtt.set_callback(self.mqtt_callback) self.mqtt.connect() self.mqtt.subscribe(self.config['topic'])
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