def mqtt(self): if not hasattr(self, '_mqtt_client'): self.responses = {} self.ready = False client = MQTTClient() client.username_pw_set(self.apikey) client.on_connect = self._on_connect client.on_message = self._on_message client.on_subscribe = self._on_subscribe client.connect(self.client.endpoint.replace('mqtt://', '')) self._mqtt_client = client # Start the loop and wait for the connection to be ready self._mqtt_client.loop_start() while not self.ready: time.sleep(.1) return self._mqtt_client
def get_client(project_id: str, cloud_region: str, registry_id: str, device_id: str, password: str, mqtt_bridge_hostname: str, mqtt_bridge_port: str, ca_certs: str): client_id = 'projects/{}/locations/{}/registries/{}/devices/{}'.format( project_id, cloud_region, registry_id, device_id) secho('Client ID: ', fg='bright_green', nl=False) echo('\'{}\''.format(client_id)) client = Client(client_id=client_id) client.username_pw_set(username='******', password=password) client.tls_set(ca_certs=ca_certs, tls_version=ssl.PROTOCOL_TLSv1_2) # Assign callbacks client.on_connect = on_connect client.on_publish = on_publish client.on_disconnect = on_disconnect client.on_message = on_message # Connect to MQTT bridge client.connect(mqtt_bridge_hostname, mqtt_bridge_port) client.loop_start() return client
def create_client(self, host, port, username, password, clientid, cafile=None): """Creating an MQTT Client Object""" client = MqttClient(clientid) if username and password: client.username_pw_set(username=username, password=password) else: self.logger.warn("Proceeding without username and password") if cafile: client.tls_set(ca_certs=cafile) else: self.logger.warn("Proceeding without certificate file") try: client.on_connect = self.on_connect client.on_message = self.on_message client.connect(host=host, port=port) except OSError as error: self.logger.error(error) return client
def execute(self, chat_id, args): client = Client(userdata=self.user_data) connect_result = client.connect(self.config["server"]) if not connect_result == MQTT_ERR_SUCCESS: raise Exception( "Client connection error {}".format(connect_result)) topics = self.get_topic_list() for topic in topics: (subs_result, subs_id) = client.subscribe(topic) client.on_message = self.on_message if not subs_result == MQTT_ERR_SUCCESS: raise Exception("Subscription error {}".format(subs_result)) time_start = time.time() while True: client.loop() if self.user_data["messages_received"] >= len(topics): break if time.time() - time_start > 10: break self.bot.sendMessage(chat_id, self.format_output())
def init_client(): #variabili di sistema settate access_key = os.environ["AWS_ACCESS_KEY_ID"] secret_key = os.environ["AWS_SECRET_ACCESS_KEY"] port = 443 region = "us-east-2" # This is specific to your AWS account host = "a3pwbt0axh6wnd-ats.iot.us-east-2.amazonaws.com".format(region) extra_headers = functools.partial( get_amazon_auth_headers, access_key, secret_key, region, host, port, ) client = Client(transport="websockets") client.ws_set_options(headers=extra_headers) # Use client as normal from here client.on_connect = on_connect client.on_message = on_message client.on_publish = on_publish client.tls_set() client.connect(host, 443,60) return client
def test_mqtt_telemetry(): # Create receiver sub = Client(clean_session=True) # def on_message(client, userdata, message): # data = message.payload # print(message) on_message_mock = mock.Mock() sub.on_message = on_message_mock sub.connect(cfg.TELEMETRY_MQTT_BROKER_HOST) sub.loop_start() name = "donkey/%s/telemetry" % cfg.TELEMETRY_DONKEY_NAME sub.subscribe(name) t = MqttTelemetry(cfg, default_inputs=['angle'], default_types=['float']) t.publish() timestamp = t.report({'speed': 16, 'voltage': 12}) t.run(33.3) assert t.qsize == 2 time.sleep(1.5) t.publish() assert t.qsize == 0 time.sleep(0.5) res = str.encode( '[{"ts": %s, "values": {"speed": 16, "voltage": 12, "angle": 33.3}}]' % timestamp) assert on_message_mock.call_args_list[0][0][2].payload == res
def main(): global args parser = ArgumentParser(description=__doc__) parser.add_argument( "--host", default='localhost', help='hostname of mqtt broker' ) parser.add_argument( "--topic", default='velogen/raw', help='comma separated list of MQTT topics to subscribe to' ) args = parser.parse_args() c = Client() c.on_connect = on_connect c.on_disconnect = on_disconnect c.on_message = on_message c.connect(args.host) atexit.register(commit) while True: ts = datetime.now().timestamp() for tp, rts in rx_ts_dict.items(): if rts is not None: # dump to file after 30 s of silence if ts - rts > 30: clean_write(tp) rx_ts_dict[tp] = None c.loop(1.0)
def main(): print("Hello! this is aggry! I send wonderful data :)") client = Client(client_id="aggry") client.on_connect = on_connect client.on_message = on_message if debug: client.on_log = on_log else: print("Debug mode disabled by configuration.") # Swarm does not handle dependencies sleep(2) try: rc = client.connect("broker", 1883, 60) except: # just try again print("connect: trying again...") sleep(4) client.connect("broker", 1883, 60) # main loop client.loop_forever()
def main(): global args, write_api parser = ArgumentParser(description=__doc__) parser.add_argument("--host", default='localhost', help='hostname of mqtt broker') parser.add_argument( "-t", action='append', default=['velogen/raw'], help='MQTT topic to subscribe to. Can be put multiple times.') parser.add_argument("-d", action='store_true', help='enable debug output') parser.add_argument("--user", default=None, help="username") parser.add_argument("--pw", default=None, help="password") args = parser.parse_args() client = Client() client.on_connect = on_connect client.on_disconnect = on_disconnect client.on_message = on_message if args.user is not None and args.pw is not None: client.username_pw_set(args.user, args.pw) client.connect(args.host) # For influxdb2 only db = InfluxDBClient(url='http://localhost:8086', token=token, debug=args.d) write_api = db.write_api(write_options=SYNCHRONOUS) while True: client.loop(timeout=1.0)
def setMqttClient(client: Client): client.on_message = on_message client.on_connect = on_connect client.connect(server, port) client.loop_start() self.client = client
def set_up(host, port, subscribe_to_topics_func): global _instance, _subscribe_to_topics_func _subscribe_to_topics_func = subscribe_to_topics_func _instance = Client() _instance.on_connect = _on_connect _instance.on_message = _on_message _instance.connect(host, port) _instance.loop_start()
def main(): influxdb_client = InfluxDBClient(INFLUXDB_HOST, INFLUXDB_PORT, INFLUXDB_USERNAME, INFLUXDB_PASSWORD, INFLUXDB_DATABASE) #First the database is initialized mqtt_client = MQTTClient( MQTT_CLIENT_ID, userdata=influxdb_client) #Then we create a client object mqtt_client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD) #and set the username and password for the MQTT client mqtt_client.tls_set() mqtt_client.on_connect = mqtt_connect_callback #We tell the client which functions are to be run on connecting mqtt_client.on_message = mqtt_message_callback #and on receiving a message mqtt_client.connect(MQTT_HOST, MQTT_PORT) #we can connect to the broker with the broker host and port mqtt_client.loop_forever()
def __subscribe(self): ip_list = self.settings.get("slaves", ["127.0.0.1"]) for ip in ip_list: client = Client() client.connect(ip, 1883, self.settings.get("mqtt_timeout", 60)) client.on_connect = self.__on_connect client.on_message = self.__on_message client.loop_start() self.client_list.append(client)
def main(): influxdb_client = InfluxDBClient(INFLUXDB_HOST, INFLUXDB_PORT, INFLUXDB_USERNAME, INFLUXDB_PASSWORD, INFLUXDB_DATABASE) mqtt_client = MQTTClient(MQTT_CLIENT_ID, userdata=influxdb_client) mqtt_client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD) mqtt_client.tls_set() mqtt_client.on_connect = mqtt_connect_callback mqtt_client.on_message = mqtt_message_callback mqtt_client.connect(MQTT_HOST, MQTT_PORT) mqtt_client.loop_forever()
def setup_mqtt_client(): def on_connect(client, *args): client.subscribe(MQTT_TOPIC) temp_client = Client() temp_client.username_pw_set(**MQTT_CREDS) temp_client.on_connect = on_connect temp_client.on_message = on_message temp_client.connect(MQTT_BROKER, 1883, 60) return temp_client
def get_client(name, signals, *args, **kwargs): ''' Create a MQTT client and bind connect, disconnect, and message callbacks. ''' client = Client(*args, **kwargs) client.connected = threading.Event() client.on_connect = ft.partial(on_connect, name) client.on_disconnect = ft.partial( lambda *args, **kwargs: logging.debug('disconnected')) client.on_message = ft.partial(on_message, 'dropbot', signals) return client
def loop(self, ip, port, clientId='', username='', password='', **kwargs): if MqttConnect.mqtt: MqttConnect.mqtt.loop_stop() mqtt = Client(clientId) mqtt.username_pw_set(username, password) mqtt.connect(ip, int(port)) mqtt.on_log = self.on_log mqtt.on_connect = self.on_connect mqtt.on_message = self.on_message mqtt.loop_start() MqttConnect.mqtt = mqtt
def run_mqtt_listener(): mqtt_broker_url = '167.86.108.163' MQTT_HOST = os.getenv('MQTT_HOST', mqtt_broker_url) client_name = 'mqtt-csw-importer' topic = 'update_csw' print("Sono partito") print("->167.86.108.163") print("->mqtt-csw-importer") def _on_connect(client, userdata, flags, rc): print("Connesso con successo al topic", topic) def _on_log(client, userdata, level, buf): # print("log", level, buf) pass def _on_message(client, userdata, message): message = str(message.payload.decode("utf-8")) payload = json.loads(message)['rndt_xml'] print('received event', payload) print( '----ENDED------------------------------------------------------') cmd = 'pycsw-admin.py -c load_records -f /etc/pycsw/pycsw.cfg -p /home/pycsw/datatemp' filename = "/home/pycsw/datatemp/temp1.xml" try: with open(filename, 'w') as file: file.write(payload) execute(cmd) # execute('rm -f ' + filename) except Exception as e: print('Exception', e) try: client = Client(client_id='{}_{}'.format(client_name, random.randint(1, 10000)), clean_session=True) print('Connecting to MQTT broker at ') client.connect(MQTT_HOST) except ConnectionRefusedError as e: print('Connection refused by MQTT broker at ') raise ConnectionRefusedError client.on_connect = _on_connect client.on_message = _on_message client.on_log = _on_log client.subscribe(topic) client.loop_forever() # client.loop_start() print('loop started')
def mqtt_handler(): global mqtt_client Client.connected_flag = False mqtt_client = Client() mqtt_client.on_connect = on_connect mqtt_client.on_message = on_message mqtt_client.loop_start() mqtt_client.connect(host=MQTT_ADDR, port=MQTT_PRT) while not mqtt_client.connected_flag: # wait in loop print("In wait loop") time.sleep(1) # subscribe all rooms, using MQTT single layer wildcard mqtt_client.subscribe(topic='%s/+' % ORDER_STATUS) mqtt_client.loop_forever() mqtt_client.disconnect()
def mqtt_client(server): # ESP8266: import ubinascii, utime import time machine_id = b'ESP8266-999999' # setup Mosquitto # on Python3: # pip install paho-mqtt from paho.mqtt.client import Client as MQTTClient mqttc = MQTTClient(machine_id, server) mqttc.connect(server) mqttc.on_message = callback_function_PahoMQTT mqttc.subscribe('test/#') mqttc.loop_start() while True: time.sleep(1) mqttc.loop_stop()
def run(client: mqtt.Client): client.publish( f"homeassistant/switch/{CONFIG.get_device_name()}/screen/config", f'{{"unique_id": "screen-{CONFIG.get_device_name()}", "name": "{CONFIG.get_device_name()} Screen", "device": {{"identifiers": ["{CONFIG.get_device_name()}"], "name": "{CONFIG.get_device_name()}"}}, "~": "homeassistant/switch/{CONFIG.get_device_name()}/screen", "availability_topic": "~/state", "command_topic": "~/set", "retain": true}}', retain=True) client.publish( f"homeassistant/switch/{CONFIG.get_device_name()}/screen/state", "online", retain=True) logging.info("Set mqtt toptic state to online") client.subscribe( f"homeassistant/switch/{CONFIG.get_device_name()}/screen/set") client.on_message = on_message client.loop_forever()
def main(): p = argparse.ArgumentParser() p.add_argument('-a', '--account-path', help='Path to JSON file containing Google account details') args = p.parse_args() google_session = get_google_session(args.account_path) brokers = {} clients = [] reporter = Reporter(google_session) for device_id, device, desc in generate_devices_from_config(): if not device.url.startswith('mqtt://'): continue device_name, host, port, username, password = parse_mqtt_url( device.url) broker = (host, port, username, password) brokers.setdefault(broker, {}).setdefault(device_name, []).append(device) for (host, port, username, password), devices in brokers.items(): client = Client(clean_session=True, userdata=devices) client.on_message = reporter.on_msg if username is not None: client.username_pw_set(username, password) client.connect(host, port) for device_name in devices: # log(f'{device_name} --> STATE') client.subscribe(f'stat/{device_name}/RESULT') client.publish(f'cmnd/{device_name}/state') client.loop_start() clients.append(client) try: while 1: time.sleep(5) except KeyboardInterrupt: print('Ctrl-C') for client in clients: client.loop_stop()
def run_client(settings): def on_connect(*args, **kwargs): print("connected") def on_message(*args, **kwargs): print("message received", args, kwargs) client = MQTTClient() client.on_connect = on_connect client.on_message = on_message client.connect(server, settings["mqtt_settings"]["port"], 60) t0 = time.time() while True: time.sleep(1) client.loop() td = time.time() - t0 f = lambda x: np.log(x / 10) * 10 + 50 data = '{"meat_temp": %.1f, "oven_temp": %.1f}' % (f(td), f(td + 100)) print("publishing data") client.publish("test_topic", data)
def mqtt_handler(): global mqtt_client Client.connected_flag = False mqtt_client = Client() # set mosquitto broker password and username mqtt_client.username_pw_set(username=USERNAME, password=PASSWORD) # set TLS cert for the client mqtt_client.tls_set(ca_certs=TLS_CERT) mqtt_client.tls_insecure_set(True) mqtt_client.on_connect = on_connect mqtt_client.on_message = on_message mqtt_client.loop_start() mqtt_client.connect(host=MQTT_ADDR, port=MQTT_PRT) while not mqtt_client.connected_flag: # wait in loop print("In wait loop") time.sleep(1) mqtt_client.subscribe(topic='%s/+' % ORDER_STATUS) mqtt_client.loop_forever() mqtt_client.disconnect()
def get_mqtt_payload(topic): mqttBroker = "localhost" client = Client("Temperature_Inside") if topic == "PYWATERING": client.on_connect = on_connect_st elif topic == "PLANT1": client.on_connect = on_connect_plant1 elif topic == "PLANT2": client.on_connect = on_connect_plant2 elif topic == "PLANT3": client.on_connect = on_connect_plant3 elif topic == "PLANT4": client.on_connect = on_connect_plant4 client.on_message = on_message client.username_pw_set(username=uname, password=passwd) client.connect("localhost") client.loop_start() time.sleep(2) client.loop_stop() return global_message
def test_mqtt_telemetry(): cfg.TELEMETRY_DEFAULT_INPUTS = 'pilot/angle,pilot/throttle' cfg.TELEMETRY_DONKEY_NAME = 'test{}'.format(randint(0, 1000)) cfg.TELEMETRY_MQTT_JSON_ENABLE = True # Create receiver sub = Client(clean_session=True) # def on_message(client, userdata, message): # data = message.payload # print(message) on_message_mock = mock.Mock() sub.on_message = on_message_mock sub.connect(cfg.TELEMETRY_MQTT_BROKER_HOST) sub.loop_start() name = "donkey/%s/#" % cfg.TELEMETRY_DONKEY_NAME sub.subscribe(name) t = MqttTelemetry(cfg) t.add_step_inputs(inputs=['my/voltage'], types=['float']) t.publish() timestamp = t.report({'my/speed': 16, 'my/voltage': 12}) t.run(33.3, 22.2, 11.1) assert t.qsize == 2 time.sleep(1.5) t.publish() assert t.qsize == 0 time.sleep(0.5) res = str.encode('[{"ts": %s, "values": {"my/speed": 16, "my/voltage": 11.1, "pilot/angle": 33.3, ' '"pilot/throttle": 22.2}}]' % timestamp) assert on_message_mock.call_args_list[0][0][2].payload == res
def mqtt_cmnd(topic, payload=None, resp_topic=None, host=None, port=1883, username=None, password=None): resp_q = queue.Queue(1) c = MQTTClient(clean_session=True) if username is not None: c.username_pw_set(username, password) c.connect(host, port) c.subscribe(resp_topic or topic) c.on_message = lambda client, userdata, msg: resp_q.put(msg.payload) c.publish(topic, payload) c.loop_start() try: return resp_q.get(timeout=1) except queue.Empty: raise TimeoutError from None finally: c.loop_stop()
def __init__(self, client_id, config, wait=True): """ initialize mqtt client :param client_id: client id :param config: keeper configuration :param wait: whether to wait for connection """ self.logger = Logger() user = config.get("mqtt.user") pwd = config.get("mqtt.pass") client = Client(client_id=client_id) client.on_connect = self._on_connect client.on_disconnect = self._on_disconnect client.on_message = self._on_message client.enable_logger(self.logger) if user and pwd: client.username_pw_set(user, pwd) client.connect_async(config["mqtt.broker"], config["mqtt.port"], 30) self.client = client self.connected = False self.manager = None self.wait = wait
def main(): parser = argparse.ArgumentParser(description=help_text) parser.add_argument('-l', '--log-level', action='store', type=str, dest='log_level', help='Log level', default='INFO') args = parser.parse_args() numeric_level = getattr(logging, args.log_level.upper(), None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % args.log_level) coloredlogs.install(level=numeric_level) logger.info('Log level set to %s', args.log_level) client = Client() client.username_pw_set("****", "****") client.on_connect = on_connect client.on_message = on_message client.connect(MQTT_ADRESS, MQTT_PORT, 60) client.loop_forever()
def client(self): client = Client(client_id=self._auth.client_id) client.tls_set_context(self.ssl_context) client.on_connect = self.on_connect client.on_message = self.on_message return client
from paho.mqtt.client import Client def on_connect(client, userdata, rc): client.subscribe("#") def on_message(client, userdata, msg): print(msg.topic+" "+str(msg.payload)) client = Client() client.on_message = on_message client.on_connect = on_connect client.connect("broker.mqttdashboard.com") client.loop_forever()