def main(): try: global mqtt_hostname, mqtt_server, wifi_ap _thread.start_new_thread("led-animation", ledThread, ()) _buttons.register(0) _buttons.attach(0, buttonHandler) mqtt = MQTTClient(mqtt_hostname, mqtt_server) mqtt.set_callback(mqttHandler) while True: if wifi_ap: mqtt.disconnect() break if not wifi.status(): connectToWiFi() mqtt.connect() mqtt.subscribe(b"hoera10jaar/+") else: mqtt.check_msg() time.sleep(0.1) except BaseException as e: print("MAIN THREAD CRASHED") print(e) time.sleep(2) system.home()
def subscribe_test(client_id=CLIENT_ID, hostname=AWS_ENDPOINT, sslp=SSL_PARAMS, msg_limit=2): """ Connects to AWS, subscribes to a topic and starts listening for messages. :param client_id: Unique identifier for the device connected. :param hostname: AWS hostname to connect to. :param sslp: SSL certificate parameters. :param msg_limit: Maximum number of messages to receive before disconnecting from AWS.. """ global msgs_received # Connect to AWS. client = MQTTClient(client_id, hostname, ssl=True, ssl_params=sslp) client.set_callback(sub_cb) print("- Connecting to AWS... ", end="") client.connect() print("[OK]") # Subscribe to topic. print("- Subscribing to topic '%s'... " % TOPIC, end="") client.subscribe(TOPIC) print("[OK]") # Wait for messages. msgs_received = 0 print('- Waiting for messages...') while msgs_received < msg_limit: client.check_msg() time.sleep(1) # Disconnect. client.disconnect() print("- Done")
def mqtt_sub(): import time from umqtt.simple import MQTTClient # Received messages from subscriptions will be delivered to this callback def sub_callback(topic, msg): print((topic, msg)) _broker = '192.168.0.100' _port = 1883 _topic = b'Debug' _client = MQTTClient(client_id="ESP8266", server=_broker, port=_port) _client.set_callback(sub_callback) _client.connect() _client.subscribe(_topic) while True: if True: # Blocking wait for message _client.wait_msg() else: # Non-blocking wait for message _client.check_msg() # Sleep to avoid 100% CPU usage time.sleep_ms(500) _client.disconnect()
def run(self, server=SERVER): """ Connects to Homeassistant, listen for changes and update led """ led = Led() rainbow = Rainbow() c = MQTTClient(CLIENT_ID, server) c.set_callback(self.sub_callback) c.connect() c.subscribe(TOPIC) print("Connected to %s, subscribed to %s topic" % (server, TOPIC)) try: while True: c.check_msg() if self.updated == True: led.update_colors(self.red, self.green, self.blue) self.updated = False if ure.match('OFF', self.ledstate): led.turn_off() elif ure.match('rainbow', self.effect): rainbow.show(60) elif ure.match('rainbow_slow', self.effect): rainbow.show(100) elif ure.match('rainbow_fast', self.effect): rainbow.show(30) else: led.change_nyance() time.sleep_ms(10) finally: c.disconnect()
def main(mqtt_broker='test.mosquitto.org', mqtt_port=1883, mqtt_user=None, mqtt_password=None, client_id=None, command_topic=None): global COMMAND_TOPIC, CLIENT_ID if client_id: CLIENT_ID = client_id if command_topic: COMMAND_TOPIC = command_topic mqtt = MQTTClient(CLIENT_ID, mqtt_broker, mqtt_port, mqtt_user, mqtt_password) mqtt.set_callback(mqtt_cb) mqtt.connect() mqtt.subscribe(COMMAND_TOPIC) print("链接到服务器:{s},端口:{p}".format(s=mqtt_broker, p=mqtt_port)) print("接受命令topic:开关({c})".format(c=COMMAND_TOPIC)) while True: mqtt.check_msg()
def sub_topic(server="localhost"): client = MQTTClient(machine.unique_id(), '192.168.0.10') client.set_callback(sub_cb) client.connect() client.subscribe(b"ESYS/netball") client.check_msg() client.disconnect()
def main(server=SERVER): global newmessage out() do_connect() c = MQTTClient(CLIENT_ID, server) # 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)) try: while 1: #micropython.mem_info() c.check_msg() #print (type(c.check_msg())) #a = c.check.msg() #if a is not None: # newmessage = True #elif c.check.msg() is None: # newmessage = False time.sleep(1) finally: c.disconnect()
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(2) except KeyboardInterrupt: print('bye') except OSError as ex: print(ex.args[0]) if ex.args[0] == -1: print('woooops') gc.collect() time.sleep(1) main() # --- finally: client.disconnect()
class Mimqtt(): def __init__(self): id_cliente = "12hi3b1i2n98dno2jnd921" mqtt_server = "broker.hivemq.com" self.client = MQTTClient(id_cliente, mqtt_server) self.client.set_callback(self.mqtt_callback) self.client.connect() self.client.subscribe(b'curso_eoi') def enviar_mqtt(self, nombre, metodo, tiempo): topic = b'curso_eoi' datos = {"Nombre": nombre, "Metodo": metodo, "Tiempo": tiempo} datos = json.dumps(datos) self.client.publish(topic, datos) def mqtt_callback(self, topic, msg): try: datos = json.loads(msg.decode()) except ValueError: print("mensaje invalido") print("me llego por '{}' esto: {}".format(topic, msg)) def comprobar_mensajes(self): for i in range(10): self.client.check_msg() time.sleep_ms(10)
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()
class IOClient: def __init__(self): self._client = ubinascii.hexlify(machine.unique_id()) self._feed = credentials.adafruitUsername + "/feeds/" self._url = "io.adafruit.com" self._sta_if = network.WLAN(network.STA_IF) self._io = MQTTClient(self._client, self._url, 0, credentials.adafruitUsername, credentials.adafruitAioKey) self._data = dict([('temperature', 0), ('humidity', 0), ('pressure', 0), ('gas', 0), ('battery', 0)]) def publish(self): if not self._sta_if.isconnected(): self._sta_if.active(True) self._sta_if.connect(credentials.wifiSsid, credentials.wifiPassword) while not self._sta_if.isconnected(): pass self._io.connect() for k, v in self._data.items(): feed = self._feed + k self._io.publish(feed, str(v)) self._io.check_msg() self._io.disconnect() self._sta_if.disconnect() self._sta_if.active(False) def update(self, t, h, p, g, b): self._data['temperature'] = t self._data['humidity'] = h self._data['pressure'] = p self._data['gas'] = g self._data['battery'] = b
def main(server=env['MQTT_SERVER'], user=env['MQTT_USER'], password=env['MQTT_PASSWORD'], port=env['MQTT_PORT']): c = MQTTClient("umqtt_client", server, user=user, password=password, port=port) c.set_callback(sub_cb) c.connect() c.subscribe(bytes(env['TW_STREAM_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()
class MqttClient: def __init__(self, client_id, host, port, user=None, password=None): self.client = MQTTClient(client_id, host, port=port, user=user, password=password) self.client.set_callback(self.sub_cb) self.client.connect() def subscribe(self, topic): self.client.subscribe(topic.encode()) def sub_cb(self, topic, msg): topic = topic.decode("utf-8").lower() msg = msg.decode("utf-8").lower() if topic == "klo/switch": global led if msg == "on": led.switch_on() elif msg == "off": led.switch_off() def check_msg(self): self.client.check_msg() time.sleep_ms(100) def publish(self, topic, msg): self.client.publish(topic, msg.encode())
def main(mqtt_broker='test.mosquitto.org', mqtt_port=1883, mqtt_user=None, mqtt_password=None, client_id=CLIENT_ID): global mqtt # 此处增加keepalive=60,表示60秒以上未通讯,客户端为断开 mqtt = MQTTClient(client_id, mqtt_broker, mqtt_port, mqtt_user, mqtt_password, keepalive=60) mqtt.set_callback(mqtt_cb) # 设置lastwill,相应消息会在断开mqtt连接后自动在服务器端发布 # 注:在connect之前设置lastwill mqtt.set_last_will(AVAILABILITY_TOPIC, b"offline", retain=True) mqtt.connect() mqtt.subscribe(COMMAND_TOPIC) mqtt.publish(AVAILABILITY_TOPIC, b"online", retain=True) state = b"ON" if LED.value() == 1 else b"OFF" mqtt.publish(STATE_TOPIC, state, retain=True) print("链接到服务器:{s},端口:{p}".format(s=mqtt_broker, p=mqtt_port)) print("接受命令topic:开关({c})".format(c=COMMAND_TOPIC)) while True: mqtt.check_msg()
def connect(self): fail_notified = False while True: try: c = MQTTClient(self.uuid, self.ip, self.port, self.user, self.password, keepalive=120) c.set_callback(self.callback) c.connect() c.subscribe(self.topic) try: while True: fail_notified = False if True: c.wait_msg() else: c.check_msg() time.sleep(1) except Exception as e: if not fail_notified: fail_notified = True log("Subscribe: {}".format(e)) c.disconnect() except Exception as e: if not fail_notified: fail_notified = True log("Subscribe-connection: {}".format(e)) time.sleep(5)
def main( mqtt_broker='test.mosquitto.org', mqtt_port=1883, mqtt_user=None, mqtt_password=None, client_id=CLIENT_ID): global mqtt mqtt = MQTTClient( client_id, mqtt_broker, mqtt_port, mqtt_user, mqtt_password, keepalive=60 ) mqtt.set_callback(mqtt_cb) mqtt.set_last_will( AVAILABILITY_TOPIC, b"offline", retain=True) mqtt.connect() mqtt.subscribe(COMMAND_TOPIC) #此处增加对亮度命令的订阅 mqtt.subscribe(BRIGHTNESS_COMMAND_TOPIC) mqtt.publish( CONFIG_TOPIC, CONFIG_DATA.encode(), retain=True) mqtt.publish( AVAILABILITY_TOPIC, b"online", retain=True) mqtt.publish( STATE_TOPIC, light_state.encode(), retain=True ) mqtt.publish( BRIGHTNESS_STATE_TOPIC, str(light_brightness).encode(), retain=True ) print("链接到服务器:{s},端口:{p}".format(s=mqtt_broker,p=mqtt_port)) print("接受开关命令topic:开关({c})".format(c=COMMAND_TOPIC)) print("接受亮度命令topic:开关({c})".format(c=BRIGHTNESS_COMMAND_TOPIC)) while True: mqtt.check_msg()
def main(server=SERVER_IP): while True: client = MQTTClient( SERVER_NAME, server, port=1883, user=USER, password=PASSWD ) client.set_callback(sub_cb) client.connect() client.subscribe(t_sub, qos=1) # Currently the two sleep calls below are necessary to get check_msg() to run. # Need to figure out why, because as it is right now it is possible to miss commands # between disconnect and reconnect. sleep(1) client.check_msg() sleep(1) if switch.value() == 0: pub = 'OPEN' elif switch.value() == 1: pub = 'CLOSED' else: pub = 'ERR' # Publish message based on above, and set quality of service to 1 (see mqtt docs). client.publish(topic=t_pub, msg=pub, qos=1) client.disconnect()
def main(): do_connect_wifi() c = MQTTClient(CLIENT_ID, SERVER, PORT, USER, PASSWORD) # Subscribed messages will be delivered to this callback c.set_callback(sub_cb) c.connect(clean_session=False) c.subscribe(TOPIC, qos=1) print("Connected to %s, subscribed to %s topic" % (SERVER, TOPIC)) try: while 1: if not network.WLAN(network.STA_IF).isconnected(): do_connect_wifi() try: print('check mensage...') c.check_msg() except: print('error on check mensage...') while 1: try: print('try reconnect...') c.connect(False) break except: print('error on reconnect...') time.sleep(2) time.sleep(2) finally: c.disconnect()
class AWSShadow: def __init__(self, client_id=imei, hostname=aws_endpoint, sslp=ssl_params): self.client = MQTTClient(client_id, hostname, ssl=True, ssl_params=sslp) self.client.set_callback(delta_callback) self.shadowpath = "$aws/things/{}/shadow/".format(imei) print(self.shadowpath) self.connected = False def is_connected(self): return self.connected def connect(self): try: print("trying MQTT") self.client.connect() self.connected = True self.client.subscribe(self.shadowpath + "update/delta") print("subscribed to {}".format(self.shadowpath + "update/delta")) print("connected to MQTT") except OSError as e: print_exception(e) self.connected = False @staticmethod def _get_on_off(value): if value: return 'on' else: return 'off' def update(self, light, nightlight, lumens): try: print("updating shadow") telemetry = {"lumens": lumens} state = { "state": { "reported": { "light_state": self._get_on_off(light), "night_light_state": self._get_on_off(nightlight) }, "desired": None } } telemetry_path = "smartswitch/{}/lumens/".format(imei) shadow_path = "$aws/things/{}/shadow/".format(imei) print(shadow_path) self.client.publish(telemetry_path, ujson.dumps(telemetry)) print("updated {}".format(telemetry_path)) self.client.publish(shadow_path + "update", ujson.dumps(state)) print("updated {}".format(shadow_path)) return True except OSError: self.connected = False def check(self): self.client.check_msg()
class mqtt_client(): def __init__(self, topics, callback, client_id, mqtt_server_ip): self.server_ip = mqtt_server_ip self.id = client_id self.__mqtt_client = MQTTClient(self.id, self.server_ip) self.topics = topics print(self.topics) self.__callback = callback self.connected = False self.__connect() def __connect(self): try: # print('id', self.id, 'ip' , self.server_ip) myclient = MQTTClient(self.id, self.server_ip) self.__mqtt_client = MQTTClient(self.id, self.server_ip) self.__mqtt_client.set_callback(self.__callback) self.__mqtt_client.connect() for tpc in self.topics: print('subscribing to topic ', tpc) self.__mqtt_client.subscribe(tpc) print('connected to mqtt server at {}'.format(self.server_ip)) self.connected = True except OSError: print('unable to connect to mqtt server') self.connected = False time.sleep_ms(1000) def check_msg(self): try: self.__mqtt_client.check_msg() self.connected = True except OSError: self.connected = False def wait_msg(self): try: self.__mqtt_client.wait_msg() self.connected = True except OSError: self.connected = False def send_msg(self, topic, message): tpc = topic msg = message try: self.__mqtt_client.publish(tpc, msg, 0, True) print('published topic {}, message {}'.format(topic, message)) self.connected = True except OSError: self.connected = False def is_alive(self): # check if connected is true and reconnect if it is not. if succesful, the # function will return true, otherwise, false if not self.connected: self.__connect() return self.connected
def main(server): init() c = MQTTClient(CLIENT_ID, server) c.set_callback(sub_cb) c.connect() c.subscribe(TOPIC) while True: c.check_msg() dopattern() c.disconnect()
def mqtt_sub( server, topic, callback ): c = MQTTClient( "umqtt_client", server ) c.set_callback( callback ) c.connect() c.subscribe( topic ) try: while True: c.check_msg() finally: c.disconnect()
def mqttmain(): SERVER = '192.168.3.104' CLIENT_ID = 'PYESPCAR_A1' TOPIC = b'carcontrol' client = MQTTClient(CLIENT_ID, SERVER) client.set_callback(mqtt_callback) client.connect() client.subscribe(TOPIC) while True: client.check_msg() time.sleep(1)
class mqtt: def __init__(self, config, sub, receive): f = open('password.json', 'r') pwd = ujson.loads(f.read()) f.close() self._client = MQTTClient(client_id=ubinascii.hexlify( machine.unique_id()), server=config["server"], user=pwd["user"], password=pwd["password"], keepalive=10) self._client.set_callback(self._callback) self._client.set_last_will( topic=self.tstatus, msg=b'{"battery":0.0,"connected":false,"load":0.0}', retain=True, qos=1) self._sub = sub self._receive = receive self.wait = 1 def check(self): if self.wait == 1: try: self._client.connect() self._client.subscribe(self._sub) self.state = self._check self.wait = 0 except Exception as e: print('connect', e) self.wait = 20 elif self.wait > 0: self.wait -= 1 else: try: self._client.check_msg() except Exception as e: print('check', e) self.wait = 4 def publish(self, topic, msg, retain=False): try: self._client.publish(topic=topic, msg=msg, retain=retain) return True except Exception as e: print('publish', e) self.wait = 4 return False def _callback(self, topic, msg): print('%s -> %s' % (topic, msg)) if topic == self.tset: self._receive(msg)
def main(clientID=CLIENTID, server=SERVER, topic=PUB_TOPIC): print("Sampling time (sec):", SAMPLING_TIME) obj = {"event_data": {}} print("Client ID: %s" % clientID) print("MQTT broker server: %s" % server) print("Topic: %s" % topic) c = MQTTClient(client_id=clientID, server=server, port=PORT, user=MQTT_USERNAME, password=MQTT_password, ssl=True) c.set_callback(sub_cb) if c.connect() == 0: print('cCient connect status : Success') else: print('Client connect status : Failure') print('Publish data to the broker.') c.publish(topic, '{"event_data":{"connected":true}}') print('subscribe topic (%s)' % SUB_TOPIC) previous_time = utime.time() time_min = 0 c.subscribe(SUB_TOPIC) while True: if False: #print ('Waiting for subscribe message') # blocking wait for message c.wait_msg() else: # non blocking wait for message #print ('Waiting for subscribe message Non-blocking') c.check_msg() utime.sleep_ms(10) # 10ms for cpu process. # If button 0 is pressed, drop to REPL if repl_button.value() == 0: print("Dropping to REPL now") sys.exit() current_time = utime.time() if (current_time - previous_time) > SAMPLING_TIME: #if (current_time - previous_time) > 60: # fix the time to 1 min time_min += 1 print("Time (minutes) = ", time_min * SAMPLING_TIME / 60) previous_time = current_time obj['event_data']['heartbeat'] = 'true' print("Publish sensor data.") print(obj) c.publish(topic, json.dumps(obj)) print('Client disconnect') c.disconnect()
class BarsClient: def __init__(self, name, ip): self.c = MQTTClient(name, ip) self.c.connect(lambda topic, msg: print((topic, msg))) self.c.subscribe(b"int_resp") def __wait(self): resp = self.c.check_msg() if resp is None: pass else: return resp time.sleep(5) resp = self.c.check_msg() if resp is None: raise TimeoutError else: return resp def __send_msg(self, topic, msg): self.c.publish(topic, msg) def req_interval(self, batt): print("Requesting interval...") self.c.publish(b"interval", b"pls") self.c.publish(b"batt", batt) i = 0 print("Attempting to receive response...") while i < 3: try: print("Checking response message, attempt No." + str(i + 1) + "...") resp = self.__wait() print("Response received") return int(resp[1].decode('utf-8')) except TimeoutError: i += 1 continue return None def send_counters(self, counters, batt): print("Sending counters...") for topic, msg in counters: self.__send_msg(topic, msg) self.c.publish(b"batt", batt) print("Waiting for response...") resp = self.__wait() print("Response received:") print(resp) return int(resp[1].decode('utf-8'))
def mqtt_connect(): print("Attempting connection to MQTT broker") c = MQTTClient(secrets.mqtt_clientid, secrets.mqtt_host, 1883, secrets.mqtt_username, secrets.mqtt_password, 0, ssl=False) c.set_callback(mqtt_callback) c.connect(clean_session=False) for topic, callback in SUBSCRIPTIONS: c.subscribe(topic) c.check_msg() return c
def main(server="192.168.1.1"): utime.sleep(5) c = MQTTClient("umqtt_client", server) c.set_callback(sub_cb) c.connect() c.subscribe(b"bunnyuncle/msg") magicGPIO = 13 magicbtn = machine.Pin(magicGPIO, machine.Pin.IN, machine.Pin.PULL_UP) while True: c.check_msg() utime.sleep(2) if magicbtn.value() == 0: stop_light() c.disconnect()
def main(server=credentials.SERVER, port=credentials.PORT, user=credentials.USER, password=credentials.PASSWORD): client = MQTTClient(CLIENT_ID, server, port, user, password) client.set_callback(sub_cb) client.connect() print("Connected to MQTT broker ", SERVER) client.subscribe("otto/cmd") global lifting global door_down global incoming_msg global blank_incoming_msg last_door_down = 1 last_lifting = 0 try: while True: if opto_1 and not opto_2: door_up = True else: door_up = False if not opto_1 and not opto_2: door_down = True else: door_down = False if lifting | lowering: RLY_BEEPER.value(0) else: RLY_BEEPER.value(1) if lifting != last_lifting: if lifting: entry = time.ticks_ms() if lifting and (time.ticks_ms() >= entry + 7500): timeout = True lifting = False print("timeout!") if incoming_msg != blank_incoming_msg: client.publish(b"otto/stat", b"Got a new message") last_lifting = lifting last_door_down = door_down incoming_msg = "" blank_incoming_msg = "" client.check_msg() except KeyboardInterrupt: print("Graceful exit by keyboard interrupt") client.publish(b"otto/stat", b"Graceful exit by keyboard interrupt") finally: print("Code crashed, idle now") client.publish(b"otto/stat", b"Code stopped, ESP32 idle now")
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'], "ESP8266 is Connected") client.publish(CONFIG['TOPIC'], "off") 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 button.value() == 1: print("Button pressed") display.fill(0) display.text('Pi4IoT', 30, 0) if led.value() == 1: client.publish(CONFIG['TOPIC'], b"off") display.text('LED: OFF', 30, 20) else: client.publish(CONFIG['TOPIC'], b"on") display.text('LED: ON', 30, 20) display.show() time.sleep_ms(500) finally: client.disconnect()
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()
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() if uart_message: # Toggle the LED for every piece of serial data received # This is useful for debugging, but you might want to disable # if the data rate is high led.value(not led.value())
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() if mode == "sleep": allOff() time.sleep(1) if mode == "cycle": cycle_pallet(15) if mode == "ho": ho() if mode == "test": test(1)