def connect_and_subscribe(): global client client = MQTTClient(machine_id, broker) client.set_callback(callback) client.connect() print("Connected to {}".format(broker)) for topic in (b'config', b'control'): t = topic_name(topic) client.subscribe(t) print("Subscribed to {}".format(t))
def main(server="localhost"): c = MQTTClient("umqtt_client", server) c.set_callback(sub_cb) c.connect() c.subscribe(b"foo_topic") while True: if True: # Blocking wait for message c.wait_msg() else: # Non-blocking wait for message c.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) c.disconnect()
def main(): print("initilising wifi") initiliseWifi() print("wifi initlised") time.sleep(2) defaultMsg() c = MQTTClient(server="io.adafruit.com", client_id="LokeshR", password="******") c.set_callback(callBack) c.connect() c.subscribe("LokeshR/feeds/switchcontrol") try: while True: c.wait_msg() finally: c.disconnect()
def mqtt_connect(): global config print('Setting up MQTT client...') CLIENT_ID = b"Huzzah-" + ubinascii.hexlify(machine.unique_id()) c = MQTTClient(CLIENT_ID, config["MQTT_Broker"]) # Subscribed messages will be delivered to this callback c.set_callback(sub_callback) c.connect() c.subscribe(config["TOPIC"]) print("Connected to {}, subscribed to {} topic.".format( config["MQTT_Broker"], config["TOPIC"])) while True: c.wait_msg() #c.check_msg() c.disconnect()
def get_mqtt_client(self, project_id, cloud_region, registry_id, device_id, jwt): """Create our MQTT client. The client_id is a unique string that identifies this device. For Google Cloud IoT Core, it must be in the format below.""" client_id = 'projects/{}/locations/{}/registries/{}/devices/{}'.format( project_id, cloud_region, registry_id, device_id) print('Sending message with password {}'.format(jwt)) client = MQTTClient( client_id.encode('utf-8'), server=config.google_cloud_config['mqtt_bridge_hostname'], port=config.google_cloud_config['mqtt_bridge_port'], user=b'ignored', password=jwt.encode('utf-8'), ssl=True) client.set_callback(on_message) client.connect() client.subscribe('/devices/{}/config'.format(device_id), 1) client.subscribe('/devices/{}/commands/#'.format(device_id), 1) return client
def check_user_unlock(block): #connects to EERover broker and waits for a user responce with a code to disarm the device sta_if = network.WLAN(network.STA_IF); sta_if.active(True) #connect to EERover network sta_if.connect(BROKER_NAME,BROKER_PASSWORD) while sta_if.isconnected() == False: #wait for connectoin to be established time.sleep_ms(10) print("Broker Connected") client=MQTTClient(machine.unique_id(),"192.168.0.10") client.connect() client.set_callback(sub_cb) client.subscribe("esys/<team_little_boots>/unlock/1234") #subcribe to a topic with a specific code (here 1234) would be different for different units if(block): client.wait_msg() #blocking message receive function that waits until the topic is recieved else: #blocks operation but only for 1 minute rtc.datetime((2017, 5, 1, 4, 13, 0, 0, 0)) while((rtc.datetime()[5] < 1) and (ALARM_RESET == False)): client.check_msg() time.sleep_ms(10) client.disconnect() #disconnect from broker and network sta_if.disconnect()
def main(server="mqtt.just4fun.site"): c = MQTTClient("umqtt_client", server) c.set_callback(sub_cb) c.connect() #c.subscribe(b"/test_umqtt") c.subscribe(b"/test_umqtt", qos=1) while True: if True: # Blocking wait for message print("running...") c.wait_msg() else: # Non-blocking wait for message c.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) c.disconnect()
def mqtt_main_thread(): global c, uM while True: gc.collect() func(None, None, 'MQTT START.') if inif['mqtt_state'] == 0: try: c = MQTTClient(inif['mqttClientId'], inif['strBroker'], inif['Brokerport'], inif['mqttUsername'], inif['mqttPassword'], keepalive=120) c.set_callback(sub_cb) c.connect() inif['mqtt_state'] = 1 uM = 0 func(None, None, 'MQTT TOPIC ING.') c.subscribe(inif['sysTOPIC']) #上传消息成功收到回复消息 c.subscribe(inif['getTOPIC']) #接收服务器自定义消息 func(None, None, 'MQTT OK.') while True: try: c.wait_msg() except: if inif['mqtt_state'] == 1: inif['mqtt_state'] = 0 try: c.disconnect() #断开连接释放资源 except: pass break except: func(None, None, 'MQTT OVER.') if inif['mqtt_state'] == 1: inif['mqtt_state'] = 0 try: c.disconnect() #断开连接释放资源 except: pass time.sleep(5) else: time.sleep(5)
def init_client(): global client print("Trying to connect to mqtt broker.") wifi.connect() try: client = MQTTClient(config.mqtt_client_id, config.mqtt_broker, user=config.mqtt_user, password=config.mqtt_password) client.set_callback(callback) client.connect() print("Connected to {}".format(config.mqtt_broker)) t = config.mqtt_topic + b"/#" client.subscribe(t) print("Subscribed to %s topic" % t) # client.subscribe(command_topic) # client.subscribe(brightness_command_topic) # client.subscribe(rgb_command_topic) except: print("Trouble to init mqtt.")
def main(): client = MQTTClient(client_id=config['id'], server=config['broker'], user=config['user'], password=config['key']) client.set_callback(subCallback) client.connect() client.subscribe(config['topic']) try: while True: client.check_msg() time.sleep(10) except Exception as e: print(e.args[0]) client.disconnect() print('bye!') if e.args[0] == '-1': main()
def mqtt_connect_and_subscribe(): global mqtt_client global retries if retries < 300: try: mqtt_client = MQTTClient(client_id, mqtt_server_ip) mqtt_client.connect() mqtt_client.set_callback(mqtt_on_message) mqtt_client.subscribe(light.tc_set) mqtt_client.subscribe(esp8266_set) print('connected to mqtt server at {}'.format(mqtt_server_ip)) retries = 0 except OSError: time.sleep(1) retries += 1 print('connection to mqtt server failed, retrying') mqtt_connect_and_subscribe() else: print('could not connect to mqtt_server at {}'.format(mqtt_server_ip))
class mqtt_client: def __init__(self, client_id, broker): self.client_id = client_id self.broker = broker self.mogi = MQTTClient(self.client_id, self.broker) def set_callback(self, callback): self.mogi.set_callback(callback) def connect(self): self.mogi.connect() def subscribe(self, topic): self.mogi.subscribe(topic) def publish(self, topic, value, retain=True): self.mogi.publish(topic, value, retain) def check_msg(self): self.mogi.check_msg()
def subscribe_test(clientId="clientId", hostname=aws_endpoint, sslp=ssl_params, msg_limit=2): # "clientId" should be unique for each device connected c = MQTTClient(clientId, hostname, ssl=True, ssl_params=sslp) c.set_callback(sub_cb) print("connecting...") c.connect() print("connected") c.subscribe("sample/xbee") print("subscribed") print('waiting...') global msgs_received msgs_received = 0 while msgs_received < msg_limit: c.check_msg() time.sleep(1) c.disconnect() print("DONE")
def main(): global CLIENT CLIENT = MQTTClient(CLIENT_ID, SERVER) CLIENT.set_callback(new_msg) CLIENT.connect() CLIENT.subscribe(COMMAND_TOPIC) # Publish as available once connected CLIENT.publish(AVAILABILITY_TOPIC, "online") print("Connected to {}, subscribed to {} topic".format( SERVER, COMMAND_TOPIC)) try: while 1: CLIENT.wait_msg() finally: CLIENT.publish(AVAILABILITY_TOPIC, "offline") CLIENT.disconnect()
def main(server="alpcer0.local"): global blocking_wait c = MQTTClient("umqtt_client", server) c.set_callback(simple_sub_cb) c.connect() c.subscribe(b"foo_topic") while True: if blocking_wait: # Blocking wait for message c.wait_msg() c.publish(b'bar_topic', b'received a message') else: c.publish(b'bar_topic', b'checking for messages') # Non-blocking wait for message c.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) c.disconnect()
def main(server=SERVER): c = MQTTClient(CLIENT_ID, server, PORT_NO, USERNAME, PASSWORD, 60) # Subscribed messages will be delivered to this callback c.set_callback(sub_cb) c.connect() c.subscribe(TOPIC) print("Connected to %s, subscribed to %s topic" % (server, TOPIC)) while (True): try: while 1: #micropython.mem_info() c.wait_msg() finally: print("finish!!!") time.sleep(2) machine.reset() c.disconnect()
def main(): client = MQTTClient(CLIENT_ID) client.connect(host=SERVER, user=USER, password=PASSWORD, port=PORT) print("Connected to MQTT broker ", SERVER) client.set_callback(sub_cb) client.subscribe("otto/#") global lifting global door_down last_door_down = 1 last_lifting = 0 try: while True: if opto_2 and not opto_1: door_up = True else: door_up = False if opto_2 and opto_1: door_down = True else: door_down = False if lifting != last_lifting: if lifting: entry = time.ticks_ms() if time.ticks_ms() >= entry + 10000: timeout = True if door_up | timeout: lifting = False timeout = False stop_now() if door_down != last_door_down: if door_down: stop_now() last_lifting = lifting last_door_down = door_down client.check_msg() except KeyboardInterrupt: print("Graceful exit by keyboard interrupt") finally: print("Code stopped, idle now")
class Mqtt: def __init__(self, client_name, server): self.__c = MQTTClient(client_name, server) self.__connected = False def is_connected(self): try: logger.print_cmd('Send MQTT ping') self.__c.ping() self.__connected = True logger.print_info('Connected from MQTT Broker') except: self.disconnect(False) return self.__connected def connect(self): logger.print_cmd('Connect to MQTT Broker') self.__c.connect() self.is_connected() def disconnect(self, force=False): if self.__connected or force: logger.print_cmd('Disconnected from MQTT Broker') self.__connected = False self.__c.disconnect() def publish(self, topic, msg): logger.print_cmd('Publish data vi MQTT') self.__c.publish(topic, msg) def subscribe(self, topic, message_func): logger.print_cmd('Subscribe data vi MQTT') self.__c.set_callback(message_func) self.__c.subscribe(topic) def wait_msg(self): try: while 1: self.__c.wait_msg() finally: self.__c.disconnect()
def start(): global c # wait to connect to the network print("waiting to be connected") sta_if = network.WLAN(network.STA_IF) sta_if.active(True) while not (sta_if.isconnected()): time.sleep(0.3) print("connected to the network") print(sta_if.ifconfig()) c = MQTTClient(CLIENT_ID, server) c.set_callback(sub_cb) c.connect() c.subscribe(REQUEST_TOPIC) print("entering loop") while True: #print("waiting for message") c.wait_msg()
def show_mqtt(): global scroller scroller = Scroller() mqtt = MQTTClient(b"scroller", b"mqtt") try: mqtt.connect() except: scroller.scroll("MQTT connect failed") return mqtt.set_callback(mqtt_cb) mqtt.subscribe(b"#") scroller.scroll("started") scroller.clear_up() try: while True: mqtt.wait_msg() finally: mqtt.disconnect()
def listen(): #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.publish(CONFIG['TOPIC'], "on") client.subscribe(CONFIG['TOPIC']) print("ESP8266 is Connected to %s and subscribed to %s topic" % (CONFIG['MQTT_BROKER'], CONFIG['TOPIC'])) try: while True: msg = client.wait_msg() #msg = (client.check_msg()) finally: client.disconnect()
def inicializar_mqtt_controle(): #dados do broker mqtt (nome do dispositivo, broker, usuario, senha, e porta) client = MQTTClient("esp-kaller", "ioticos.org",user="******", password="******", port=1883) client.set_callback(sub_cb) client.connect() client.subscribe(topic="snEwCneZjyGXl7B/led1") client2 = client client2.subscribe(topic="snEwCneZjyGXl7B/led2") def estou_conectado(): while True: client.publish(topic="snEwCneZjyGXl7B/conectado", msg="conectado") time.sleep(15) t =_thread.start_new_thread(led_on_1,()) t2 =_thread.start_new_thread(led_on_2,()) t3 =_thread.start_new_thread(estou_conectado,()) while True: client.wait_msg() time.sleep(1) client2.check_msg() time.sleep(1)
def send(topic="test", data="hello world!", client_id='testmicropython', server='mqtt.flespi.io', port=1883, user='', password=''): from umqtt.simple import MQTTClient import time print(data) client = MQTTClient(client_id, server, port, user, password) # Create MQTT client client.set_callback(sub_cb) # on message callback client.connect() # connect to MQTT broker client.subscribe(topic) # subscribe topic client.publish(topic, str(data)) # publish data to topic client.wait_msg() # waiting for a message time.sleep(2) client.disconnect() # disconnect
def listen(): #Create an instance of MQTTClient client = MQTTClient(CONFIG['CLIENT_ID'], CONFIG['MQTT_BROKER'], port=CONFIG['PORT']) # Attach call back handler to be called on receiving messages client.set_callback(onMessage) client.connect() client.publish("test1", "ESP8266 is Connected") client.subscribe(CONFIG['TOPIC']) print("ESP8266 is Connected to %s and subscribed to %s topic" % (CONFIG['MQTT_BROKER'], CONFIG['TOPIC'])) try: while True: msg = client.wait_msg() #msg = client.check_msg() if msg1 == "on": client.publish("stat", "LED ON") if msg1 == "off": client.publish("stat", "LED OFF") finally: client.disconnect()
def main(): print('main called') # Wait up to 30s for connection start_ticks = time.ticks_ms() wlan = network.WLAN(network.STA_IF) wlan.active(True) if not wlan.isconnected(): while not wlan.isconnected() and (time.ticks_ms() < start_ticks + 30000): pass initPins() loadConfig() global redPWM, greenPWM, bluePWM, client client = MQTTClient(CONFIG['client_id'], CONFIG['broker'], 0, CONFIG['mqtt_username'], CONFIG['mqtt_password']) client.connect() print("Connected to {}".format(CONFIG['broker'])) # Listen for all the things client.set_callback(mqtt_sub_callback) client.subscribe(CONFIG['command_topic']) client.subscribe(CONFIG['brightness_command_topic']) client.subscribe(CONFIG['rgb_command_topic']) # Set the light's color so we know we're running redPWM.duty(250) try: while 1: client.wait_msg() finally: client.disconnect()
def mqtt_drive(server="localhost", robot_name='another robot', mqtt_user='******', mqtt_password='******'): global time_to_stop intro() motor.motor_a.stop() motor.motor_b.stop() print("I'm %s" % topic) time_to_announce = ticks_ms() + 15 * 1000 c = MQTTClient(b"umqtt_client/%s" % robot_id, server, 1883, mqtt_user, mqtt_password) c.set_callback(msg_callback) # c.set_last_will(topic + "/$online$", "0", retain=1) c.connect() c.publish(topic + "/$online$", '1') c.publish(topic + "/$name$", robot_name, retain=1) c.subscribe(topic + '/#') while True: c.check_msg() if ticks_ms() > time_to_stop: motor.motor_a.stop() motor.motor_b.stop() c.ping() time_to_stop = ticks_ms() + 10 * TIMEOUT if ticks_ms() > time_to_announce: c.publish(topic + "/$online$", '1') time_to_announce = ticks_ms() + 16 * 1000 # Then need to sleep to avoid 100% CPU usage (in a real # app other useful actions would be performed instead) time.sleep(0.005) c.disconnect()
def main(server=SERVER, port=PORT, user=USER, password=PASSWORD): global MSGQ print("Connecting") c = MQTTClient(CLIENT_ID, server, port, user, password) try: c.connect() except OSError as exc: machine.reset() print("Connected to %s" % server) c.set_callback(sub_cb) c.subscribe(COMMAND_TOPIC_PWR) c.subscribe(COMMAND_TOPIC_DIMMER) c.subscribe(COMMAND_TOPIC_EFFECT) c.subscribe(COMMAND_TOPIC_RGB) # set to off on connect pin_red.duty(0) pin_green.duty(0) pin_blue.duty(0) while True: c.check_msg() if MSGQ != []: currItem = MSGQ.pop() c.publish(currItem[0], currItem[1]) c.disconnect()
def mqtt_connect(config): mqtt_host = config["host"] mqtt_client = MQTTClient( DEVICE_ID, mqtt_host, port=config["port"], user=config["user"], password=config["password"], ) broker_url = ("mqtt://{user}@{host}:{port}/".format(**config).replace( "//@", "").replace(":1883/", "/")) print("Connecting to " + broker_url, end="...") try: mqtt_client.connect() print("done.") publish_machine_identifier(mqtt_client) mqtt_client.set_callback(on_mqtt_message) mqtt_client.subscribe("imu/control/" + DEVICE_ID) mqtt_client.subscribe("imu/control/*") except OSError as err: print(err) return mqtt_client
def listen(onMessage, each_loop, config): #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.publish(config['TOPIC'], "ESP8266 is Connected") client.subscribe(config['TOPIC']) print("ESP8266 is Connected to %s and subscribed to %s topic" % (config['MQTT_BROKER'], config['TOPIC'])) try: while True: #msg = client.wait_msg() msg = client.check_msg() each_loop(client) finally: client.disconnect()
class ModeMcuMqttComm(MqttComm): def __init__(self, *args, **kwargs): super(ModeMcuMqttComm, self).__init__(*args, **kwargs) self._client = MQTTClient(self._manager._name, self._host) self._client.set_callback(self._on_message) self._client.connect() self._client.subscribe(self._subscribe_topic) self._client.check_msg() def __del__(self): self._client.disconnect() def _on_message(self, topic, msg): """ The callback for when a PUBLISH message is received from the broker. """ self._log.debug("Received message {0} on topic {1}".format(msg, topic)) self.receive_data(topic, msg) def send_datum(self, datum): self._client.publish(self._publish_topic, self._to_string(datum)) self._log.debug("Published {0} to {1}.".format(datum, self._host))
def mqttReceive(): CLIENT_ID = hexlify(unique_id()) #BROKER_ADDRESS = "192.168.0.10" BROKER_ADDRESS = "192.168.0.87" c = MQTTClient(CLIENT_ID,BROKER_ADDRESS,port = 1883) print ('Waiting to recieve') c.set_callback(sub_cb) c.connect() c.subscribe(b"pikachu/rec") while True: if True: # Blocking wait for message c.wait_msg() else: # Non-blocking wait for message c.check_msg() # Then need to sleep to avoid 100% CPU usage (in a real # app other useful actions would be performed instead) sleep_ms(1000) c.disconnect()
def Main(i2cPort, address): global x c = MQTTClient(machine.unique_id(), '192.168.0.10') c.set_callback(sub_cb) c.connect() c.subscribe(b"ESYS/netball") while True: # Non-blocking wait for message c.check_msg() if Functions.fog(i2cPort, address): Functions.send(i2cPort, address) else if(x['RemoveFog'] == "true"): Functions.demist(i2cPort, address, False) x['RemoveFog'] = "false" c.disconnect() c.connect() c.subscribe(b"ESYS/netball") else if (x['WindowFogged'] == "true" && !Functions.fog(i2cPort,address)): Functions.send(i2cPort, address) time.sleep(5) c.disconnect()
# bin_walk_3() hour_glass() client.set_callback(gotMessage) s = network.WLAN(network.STA_IF) while not s.isconnected(): # s.connect('ShArVa') print("Network not connected - sleeping") time.sleep(1) print(s.ifconfig()) connected = False while not connected: try: print("Connecting") client.connect() except: print("Connection Fail") time.sleep(1) else: connected = True print("Connected") client.subscribe(b"strip/anet") while True: client.wait_msg()
# messages are being sent at a high rate led.value(not led.value()) # Blink the LED every 100ms to indicate we made it into the main.py file for _ in range(10): time.sleep_ms(100) led.value(not led.value()) # Toggle the LED time.sleep_ms(100) # Make sure the LED is off led.high() # define a time, because we only want to send every 1s but received as fast as possible # last_time = time.time() mqtt = MQTTClient(CLIENT_ID, HOST, port=PORT) # Subscribed messages will be delivered to this callback mqtt.set_callback(subscriction_callback) mqtt.connect() mqtt.subscribe(TOPIC) print('Connected to {}, subscribed to {} topic.'.format(HOST, TOPIC)) try: while 1: #micropython.mem_info() mqtt.wait_msg() finally: mqtt.disconnect()
# Make sure the LED is off led.high() # Create a MQTTClient instance. mqtt = MQTTClient(CLIENT_ID, HOST, port=PORT) # Subscribed messages will be delivered to this callback mqtt.set_callback(subscriction_callback) # Connect to the MQTT server mqtt.connect() # Define the topic to subscribe to mqtt.subscribe(SUB_TOPIC) print('\nMQTT:\n Connected to: {}:{}\n Subscribed to: {:s}\n Publishing to: {:s}'.format(HOST, PORT, SUB_TOPIC, PUB_TOPIC)) try: while True: # This is the non-blocking method to check if there are MQTT messages mqtt.check_msg() # This attempts to read the UART until a newline character # Because we specified a timeout=0, when initializing the UART, it will # not block and instead returns the characters that it can read, even # if a newline isn't present. This means that we need to check for a newline # and be smart about processing the bytes/characters that were able # to receive if one was not present. uart_message = uart.readline()
s = network.WLAN(network.STA_IF) while not s.isconnected(): # s.connect('ShArVa') print("Network not connected - sleeping") time.sleep(1) print(s.ifconfig()) connected = False while not connected: try: print("Connecting") client.connect() except: print("Connection Fail") time.sleep(1) else: connected = True print("Connected") client.subscribe(b"model/light/#") party(np) while True: client.wait_msg() print("Waiting") time.sleep(1)
print(".") time.sleep(1) else: connected = True publish("alive " + motd + ' ' + s.ifconfig()[0]) letters = " " if client_id in fleet: letters = fleet[client_id] for i in range(0, len(letters)): nps[i] = neopixel.NeoPixel(machine.Pin(4), lights) set_char(letters[i], nps[i]) client.set_callback(gotMessage) client.subscribe("/strip/command/" + client_id) ntp_sync = False while not ntp_sync: try: print("NTP time sync") ntptime.settime() ntp_sync = True except: print("NTP fail") allOff() while True: client.check_msg()