def connect_mqtt(): # Create a socket pool pool = socketpool.SocketPool(wifi.radio) # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT( broker=secrets["mqtt_broker"], port=port, socket_pool=pool, ssl_context=None, ) # Setup the callback methods above mqtt_client.on_connect = on_connect mqtt_client.on_disconnect = on_disconnect mqtt_client.on_message = on_message # Connect the client to the MQTT broker. print("Connecting to MQTT Broker...") # set will message to track status of client disconnects mqtt_client.will_set(will_status_topic, time.time(), 2, True) try: mqtt_client.connect() print('mqtt client status = ', mqtt_client.is_connected()) except Exception as sensor_err: return 'mqtt_client not connected' mqtt_client.publish(will_status_topic, 1, 2, True) mqtt_client.connected_flag = False # create flags mqtt_client.bad_connection_flag = False # mqtt_client.retry_count = 0 # return mqtt_client
def _create_mqtt_client(self) -> None: minimqtt.set_socket(self._socket, self._iface) self._logger.debug( str.replace( f"- iot_mqtt :: _on_connect :: username = {self._username}, password = {self._passwd}", "%", "%%", )) self._mqtts = minimqtt.MQTT( broker=self._hostname, username=self._username, password=self._passwd, port=8883, keep_alive=120, is_ssl=True, client_id=self._device_id, ) self._mqtts.enable_logger(logging, self._logger.getEffectiveLevel()) # set actions to take throughout connection lifecycle self._mqtts.on_connect = self._on_connect self._mqtts.on_publish = self._on_publish self._mqtts.on_disconnect = self._on_disconnect # initiate the connection using the adafruit_minimqtt library self._mqtts.connect()
def initialize(myName, motorFunc): robotName = myName esp32_cs = DigitalInOut(board.D13) esp32_ready = DigitalInOut(board.D11) esp32_reset = DigitalInOut(board.D12) spi = busio.SPI(board.SCK, board.MOSI, board.MISO) esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset) if esp.status == adafruit_esp32spi.WL_IDLE_STATUS: broadcast.send("ESP32 found") """Use below for Most Boards""" status_light = neopixel.NeoPixel( board.NEOPIXEL, 1, brightness=0.2) # Uncomment for Most Boards wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager( esp, secrets, status_light) ### Feeds ### publishes["status"] = "{}/status".format(robotName) subscribes["motor"] = "{}/cmd/motor".format(robotName) subscribe_funcs["{}/cmd/motor".format(robotName)] = motorFunc subscribes["beep"] = "{}/cmd/beep".format(robotName) subscribes["servo"] = "{}/cmd/servo".format(robotName) # Connect to WiFi broadcast.send("Connecting to WiFi...") try: wifi.connect() broadcast.send("Connected!") except: broadcast.send("Could not connect") raise # Initialize MQTT interface with the esp interface minimqtt.set_socket(socket, esp) # Set up a MiniMQTT Client global mqtt_client mqtt_client = minimqtt.MQTT( broker=secrets["mqtt_broker"], port=1883, ) # Setup the callback methods above mqtt_client.on_connect = connected mqtt_client.on_disconnect = disconnected mqtt_client.on_message = message # Connect the client to the MQTT broker. broadcast.send("Connecting to MQTT Broker {}...".format( secrets["mqtt_broker_name"])) mqtt_client.connect() broadcast.send("MQTT initialized") global MQTT MQTT = True
def __init__(self): # Get wifi details and more from a secrets.py file esp32_cs = DigitalInOut(board.D13) esp32_ready = DigitalInOut(board.D11) esp32_reset = DigitalInOut(board.D12) self.spi = busio.SPI(board.SCK, board.MOSI, board.MISO) self.esp = adafruit_esp32spi.ESP_SPIcontrol(self.spi, esp32_cs, esp32_ready, esp32_reset) if self.esp.status == adafruit_esp32spi.WL_IDLE_STATUS: print("ESP32 found and in idle mode") print("Firmware vers.", self.esp.firmware_version) print("MAC addr:", [hex(i) for i in self.esp.MAC_address]) """Use below for Most Boards""" # status_light = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2) # Uncomment for Most Boards #status_light = pygamer.pygamerNeoPixels self.wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager( self.esp, secrets) #, status_light) ### Feeds ### self.status_feed = "roger/status/#" self.motor_cmd_feed = "roger/cmd/feather/motor" self.beep_cmd_feed = "roger/cmd/feather/beep" self.servo_cmd_feed = "roger/cmd/feather/servo" # Connect to WiFi print("Connecting to WiFi...") self.wifi.connect() print("Connected!") # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, self.esp) # Set up a MiniMQTT Client self.mqtt_client = MQTT.MQTT( broker=secrets["mqtt_broker"], port=1883, ) # Setup the callback methods above self.mqtt_client.on_connect = self.connected self.mqtt_client.on_disconnect = self.disconnected self.mqtt_client.on_message = self.message # Connect the client to the MQTT broker. print("Connecting to MQTT...Broker {0}".format( secrets["mqtt_broker_name"])) self.mqtt_client.connect() print("Connected to broker {0}".format(secrets["mqtt_broker_name"]))
def mqtt_init(broker, port=1883, username=None, password=None): global mqtt_client, mqtt_connect_info mqtt_client = MQTT.MQTT( broker=broker, port=port, username=username, password=password, socket_pool=socket, ssl_context=ssl.create_default_context(), ) mqtt_client.on_connect = connect mqtt_client.on_disconnect = disconnect mqtt_client.on_message = message
def __init__(self, name, status_light): esp32_cs = DigitalInOut(board.D13) esp32_ready = DigitalInOut(board.D11) esp32_reset = DigitalInOut(board.D12) self.spi = busio.SPI(board.SCK, board.MOSI, board.MISO) self.esp = adafruit_esp32spi.ESP_SPIcontrol(self.spi, esp32_cs, esp32_ready, esp32_reset) if self.esp.status == adafruit_esp32spi.WL_IDLE_STATUS: print("ESP32 found and in idle mode") print("Firmware vers.", self.esp.firmware_version) print("MAC addr:", [hex(i) for i in self.esp.MAC_address]) self.status_light = status_light # pygamer.pygamerNeoPixels self.wifi = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(self.esp, secrets, self.status_light) ### Feeds ### self.name = name self.status_feed = "{0}/status".format(name) # Connect to WiFi print("Connecting to WiFi...") self.wifi.connect() print("Connected!") # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, self.esp) # Set up a MiniMQTT Client self.mqtt_client = MQTT.MQTT( broker=secrets["mqtt_broker"], port=1883, ) # Setup the callback methods above self.mqtt_client.on_connect = self.connected self.mqtt_client.on_disconnect = self.disconnected self.mqtt_client.on_message = self.message # Connect the client to the MQTT broker. print("Connecting to MQTT...Broker {0}".format(secrets["mqtt_broker_name"])) self.mqtt_client.connect() print("Connected to broker {0}".format(secrets["mqtt_broker_name"])) self.publish_message(self.status_feed, "{0} has connected to {1}".format(name, secrets["mqtt_broker_name"]))
def register_device(self, expiry: int) -> str: """ Registers the device with the IoT Central device registration service. Returns the hostname of the IoT hub to use over MQTT :param int expiry: The expiry time for the registration :returns: The underlying IoT Hub that this device should connect to :rtype: str :raises DeviceRegistrationError: if the device cannot be registered successfully :raises RuntimeError: if the internet connection is not responding or is unable to connect """ username = f"{self._id_scope}/registrations/{self._device_id}/api-version={constants.DPS_API_VERSION}" # pylint: disable=C0103 sr = self._id_scope + "%2Fregistrations%2F" + self._device_id sig_no_encode = compute_derived_symmetric_key(self._key, sr + "\n" + str(expiry)) sig_encoded = quote(sig_no_encode, "~()*!.'") auth_string = f"SharedAccessSignature sr={sr}&sig={sig_encoded}&se={str(expiry)}&skn=registration" minimqtt.set_socket(self._socket, self._iface) self._mqtt = minimqtt.MQTT( broker=constants.DPS_END_POINT, username=username, password=auth_string, port=8883, keep_alive=120, is_ssl=True, client_id=self._device_id, ) self._mqtt.enable_logger(logging, self._logger.getEffectiveLevel()) self._connect_to_mqtt() self._start_registration() self._wait_for_operation() self._mqtt.disconnect() return str(self._hostname)
def init_mqtt( self, broker, port=8883, username=None, password=None, use_io=False, ): """Initialize MQTT""" self.connect() self._mqtt_client = MQTT.MQTT( broker=broker, port=port, username=username, password=password, socket_pool=self._wifi.pool, ssl_context=ssl.create_default_context(), ) if use_io: self._mqtt_client = IO_MQTT(self._mqtt_client) return self._mqtt_client
def init_connect(self): self.esp.soft_reset() self.wifi = adafruit_espatcontrol_wifimanager.ESPAT_WiFiManager( self.esp, self.secrets) ### A few retries here seems to greatly improve reliability for _ in range(4): if self.debug: print("Connecting to WiFi...") try: self.wifi.connect() self.esp_version = self.esp.get_version() if self.debug: print("Connected!") break except (RuntimeError, TypeError, adafruit_espatcontrol.OKError) as ex: if self.debug: print("EXCEPTION: Failed to publish()", repr(ex)) time.sleep(RECONNECT_SLEEP) ### This uses global variables socket.set_interface(self.esp) ### MQTT Client ### pylint: disable=protected-access self.mqtt_client = MQTT.MQTT(broker="io.adafruit.com", username=self.secrets["aio_username"], password=self.secrets["aio_key"], socket_pool=socket, ssl_context=MQTT._FakeSSLContext( self.esp)) self.io = IO_MQTT(self.mqtt_client) ### Callbacks of interest on io are ### on_connect on_disconnect on_subscribe self.io.connect()
# ------------- Network Connection ------------- # # Connect to WiFi print("Connecting to WiFi...") pyportal.network.connect() print("Connected to WiFi!") # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, pyportal.network._wifi.esp) # Set up a MiniMQTT Client client = MQTT.MQTT( broker=secrets["broker"], port=1883, username=secrets["broker_user"], password=secrets["broker_pass"], ) try: client.enable_logger(logging, logging.DEBUG) except: client.attach_logger() client.set_logger_level("DEBUG") # Connect callback handlers to client client.on_connect = connect client.on_disconnect = disconnected client.on_subscribe = subscribe client.on_publish = publish client.on_message = message
mqtt_broker = "test.mosquitto.org" mqtt_topic = "hello" def handle_connect(client, userdata, flags, rc): print("Connected to {0}".format(client.broker)) mqtt_client.subscribe(mqtt_topic) def handle_subscribe(client, userdata, topic, granted_qos): print("Subscribed to {0} with QOS {1}".format(topic, granted_qos)) def handle_message(client, topic, message): print("Received on {0}: {1}".format(topic, message)) adafruit_minimqtt.set_socket(adafruit_esp32spi_socket, wifi) mqtt_client = adafruit_minimqtt.MQTT(broker=mqtt_broker, is_ssl=False) # Set callback handlers mqtt_client.on_connect = handle_connect mqtt_client.on_subscribe = handle_subscribe mqtt_client.on_message = handle_message print("\nConnecting to {0}".format(mqtt_broker)) mqtt_client.connect() while True: mqtt_client.loop()
print("Wi-Fi connected to", str(esp.ssid, "utf-8")) print("IP address", esp.pretty_ip(esp.ip_address)) def handle_connect(client, userdata, flags, rc): print("Connected to {0}".format(client.broker)) def handle_publish(client, userdata, topic, pid): print("Published to {0} with PID {1}".format(topic, pid)) adafruit_minimqtt.set_socket(adafruit_esp32spi_socket, esp) mqtt_client = adafruit_minimqtt.MQTT(broker=TS_MQTT_BROKER, is_ssl=False) # Set callback handlers mqtt_client.on_connect = handle_connect mqtt_client.on_publish = handle_publish try: # Connect to ThingSpeak print("Connecting to {0}".format(TS_MQTT_BROKER)) mqtt_client.connect() # Some test data humidity = 55 temperature = 25 # Setup topic (see https://ch.mathworks.com/help/thingspeak/publishtoachannelfeed.html)
# Set AWS Device Certificate esp.set_certificate(DEVICE_CERT) # Set AWS RSA Private Key esp.set_private_key(DEVICE_KEY) # Connect to WiFi print("Connecting to WiFi...") wifi.connect() print("Connected!") # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, esp) # Set up a new MiniMQTT Client client = MQTT.MQTT(broker=secrets["broker"], client_id=secrets["client_id"]) # Initialize AWS IoT MQTT API Client aws_iot = MQTT_CLIENT(client) # Connect callback handlers to AWS IoT MQTT Client aws_iot.on_connect = connect aws_iot.on_disconnect = disconnect aws_iot.on_subscribe = subscribe aws_iot.on_unsubscribe = unsubscribe aws_iot.on_publish = publish aws_iot.on_message = message print("Attempting to connect to %s" % client.broker) aws_iot.connect()
gfx.show_gcp_status('Plant watered!') print("Turning pump off") water_pump.value = False # Initialize Google Cloud IoT Core interface google_iot = Cloud_Core(esp, secrets) # JSON-Web-Token (JWT) Generation print("Generating JWT...") jwt = google_iot.generate_jwt() print("Your JWT is: ", jwt) # Set up a new MiniMQTT Client client = MQTT.MQTT(broker=google_iot.broker, username=google_iot.username, password=jwt, client_id=google_iot.cid) # Initialize Google MQTT API Client google_mqtt = MQTT_API(client) # Connect callback handlers to Google MQTT Client google_mqtt.on_connect = connect google_mqtt.on_disconnect = disconnect google_mqtt.on_subscribe = subscribe google_mqtt.on_unsubscribe = unsubscribe google_mqtt.on_publish = publish google_mqtt.on_message = message print('Attempting to connect to %s' % client.broker) google_mqtt.connect()
:param str message: The new value """ print("New message on topic {0}: {1}".format(topic, message)) # Connect to WiFi print("Connecting to WiFi...") wifi.connect() print("Connected!") # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, esp) # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT(broker=secrets["broker"], username=secrets["user"], password=secrets["pass"]) # Setup the callback methods above mqtt_client.on_connect = connected mqtt_client.on_disconnect = disconnected mqtt_client.on_message = message # Connect the client to the MQTT broker. print("Connecting to MQTT broker...") mqtt_client.connect() # Start a blocking message loop... # NOTE: NO code below this loop will execute # NOTE: Network reconnection is handled within this loop while True:
def publish(mqtt_client, userdata, topic, pid): # This method is called when the mqtt_client publishes data to a feed. print("Published to {0} with PID {1}".format(topic, pid)) def message(client, topic, message): print("New message on topic {0}: {1}".format(topic, message)) socket.set_interface(esp) MQTT.set_socket(socket, esp) # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT( broker=secrets["broker"], port=secrets["port"], username=secrets["username"], password=secrets["password"], ) # Connect callback handlers to mqtt_client mqtt_client.on_connect = connect mqtt_client.on_disconnect = disconnect mqtt_client.on_subscribe = subscribe mqtt_client.on_unsubscribe = unsubscribe mqtt_client.on_publish = publish mqtt_client.on_message = message print("Attempting to connect to %s" % mqtt_client.broker) mqtt_client.connect() print("Subscribing to %s" % mqtt_topic)
else: # radio, time, gs id, msg, rssi, new? new_messages[r]={"RD":r,"T":time.time(),"I":gs.ID,"MSG":hexlify(msg),"RS":gs.last_rssi,"N":1} print() radios = gs.init_radios(SAT) if new_messages: gs.msg_count = gs.msg_count + 1 # if we have wifi, connect to mqtt broker if wifi.radio.ap_info is not None: # try: # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT( broker=secrets['broker'], port=secrets['port'], socket_pool=pool, is_ssl=False, ) mqtt_client.on_connect = connected mqtt_client.on_message = mqtt_message status = { 'T':time.time(), 'I':gs.ID, '#':gs.counter, 'M':gs.msg_count, 'C':gs.msg_cache, 'B':gs.battery_voltage, 'R':wifi.radio.ap_info.rssi, }
# or if you need your Adafruit IO key.) aio_username = secrets["aio_username"] aio_key = secrets["aio_key"] print("Connecting to %s" % secrets["ssid"]) wifi.radio.connect(secrets["ssid"], secrets["password"]) print("Connected to %s!" % secrets["ssid"]) # Create a socket pool pool = socketpool.SocketPool(wifi.radio) # Initialize a new MQTT Client object mqtt_client = MQTT.MQTT( broker="io.adafruit.com", username=secrets["aio_username"], password=secrets["aio_key"], socket_pool=pool, ssl_context=ssl.create_default_context(), ) # Initialize an Adafruit IO MQTT Client io = IO_MQTT(mqtt_client) iot = Hub(display=display, io=io, nav=(up, select, down, back, submit)) iot.add_device( feed_key="lamp", default_text="Lamp: ", formatted_text="Lamp: {}", pub_method=pub_lamp, )
try: from secrets import secrets except ImportError: print("MQTT secrets are kept in secrets.py, please add them there!") raise # Connect to WiFi print("Connecting to WiFi...") wifi.wifi.connect() print("Connected!") # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, wifi.esp) # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT(broker=secrets["broker"], port=secrets["port"]) ### MQTT Code ### # Define callback methods which are called when events occur # pylint: disable=unused-argument, redefined-outer-name def connected(client, userdata, flags, rc): global Isconnected Isconnected = True # This function will be called when the client is connected # successfully to the broker. print("Connected to MQTT broker!") # Subscribe to all changes on the default_topic feed. client.subscribe("ledStrip/power") client.subscribe("ledStrip/color")
def publish(client, userdata, topic, pid): # This method is called when the client publishes data to a feed. print('Published to {0} with PID {1}'.format(topic, pid)) # Connect to WiFi wifi.connect() print("Connected to", str(esp.ssid, 'utf-8'), "\tRSSI:", esp.rssi) print("My IP address is", esp.pretty_ip(esp.ip_address)) try: # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, esp) # Set up a MiniMQTT Client client = MQTT.MQTT(broker='192.168.1.164', port=1883) # Connect callback handlers to client client.on_connect = connect client.on_disconnect = disconnect client.on_subscribe = subscribe client.on_unsubscribe = unsubscribe client.on_publish = publish print('Attempting to connect to %s' % client.broker) client.connect() print('Subscribing to %s' % mqtt_topic) client.subscribe(mqtt_topic) print('Publishing to %s' % mqtt_topic)
time.sleep(0.5) print("Attached!") while not network.is_connected: print("Connecting to network...") network.connect() time.sleep(0.5) print("Network Connected!") # Initialize MQTT interface with the cellular interface MQTT.set_socket(socket, fona) # Set up a MiniMQTT Client client = MQTT.MQTT( broker=secrets["broker"], username=secrets["user"], password=secrets["pass"], is_ssl=False, ) # Connect callback handlers to client client.on_connect = connect client.on_disconnect = disconnect client.on_subscribe = subscribe client.on_unsubscribe = unsubscribe client.on_publish = publish print("Attempting to connect to %s" % client.broker) client.connect() print("Subscribing to %s" % mqtt_topic) client.subscribe(mqtt_topic)
def disconnected(client, userdata, rc): # This method is called when the client is disconnected print("Disconnected from Adafruit IO!") def message(client, topic, message): # This method is called when a topic the client is subscribed to # has a new message. print("New message on topic {0}: {1}".format(topic, message)) # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT( broker=secrets["broker"], port=1883, username=secrets["aio_username"], password=secrets["aio_key"], socket_pool=socket, ) # Setup the callback methods above mqtt_client.on_connect = connected mqtt_client.on_disconnect = disconnected mqtt_client.on_message = message # Connect the client to the MQTT broker. print("Connecting to Adafruit IO...") mqtt_client.connect() photocell_val = 0 while True:
# Initialize MQTT interface with the esp interface MQTT.set_socket(socket, esp) # Initialize Google Cloud IoT Core interface google_iot = Cloud_Core(esp, secrets) # Optional JSON-Web-Token (JWT) Generation # print("Generating JWT...") # jwt = google_iot.generate_jwt() # print("Your JWT is: ", jwt) # Set up a new MiniMQTT Client client = MQTT.MQTT( broker=google_iot.broker, username=google_iot.username, password=secrets["jwt"], client_id=google_iot.cid, ) # Initialize Google MQTT API Client google_mqtt = MQTT_API(client) # Connect callback handlers to Google MQTT Client google_mqtt.on_connect = connect google_mqtt.on_disconnect = disconnect google_mqtt.on_subscribe = subscribe google_mqtt.on_unsubscribe = unsubscribe google_mqtt.on_publish = publish google_mqtt.on_message = message print("Attempting to connect to %s" % client.broker)
import board import terminalio from adafruit_matrixportal.matrixportal import MatrixPortal from adafruit_matrixportal.network import Network import adafruit_minimqtt.adafruit_minimqtt as MQTT import adafruit_esp32spi.adafruit_esp32spi_socket as socket from secrets import secrets # --- Display setup --- matrixportal = MatrixPortal(status_neopixel=board.NEOPIXEL, debug=False) network = matrixportal.network network.connect() mqtt = MQTT.MQTT( broker=secrets.get("mqtt_broker"), username=secrets.get("mqtt_user"), password=secrets.get("mqtt_password"), port=1883, ) MQTT.set_socket(socket, network._wifi.esp) TEAM_1_COLOR = 0x00AA00 TEAM_2_COLOR = 0xAAAAAA # Team 1 Score matrixportal.add_text( text_font=terminalio.FONT, text_position=(2, int(matrixportal.graphics.display.height * 0.75) - 3), text_color=TEAM_1_COLOR, text_scale=2, )
def message(client, topic, message): # This method is called when a topic the client is subscribed to # has a new message. print("New message on topic {0}: {1}".format(topic, message)) # Create a socket pool pool = socketpool.SocketPool(wifi.radio) # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT( broker=secrets["aio_broker"], port=secrets["aio_port"], username=secrets["aio_username"], password=secrets["aio_key"], socket_pool=pool, ssl_context=ssl.create_default_context(), ) # Setup the callback methods above mqtt_client.on_connect = connected mqtt_client.on_disconnect = disconnected mqtt_client.on_message = message # Connect the client to the MQTT broker. print("Connecting to Adafruit IO ...") mqtt_client.connect() photocell_val = 0 while True:
def message(client, topic, message): """Method callled when a client's subscribed feed has a new value. :param str topic: The topic of the feed with a new value. :param str message: The new value """ print("New message on topic {0}: {1}".format(topic, message)) # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, uart) # Set up a MiniMQTT Client mqtt_client = MQTT.MQTT(broker=secrets['broker'], port=443, username=secrets['user'], password=secrets['pass']) # Setup the callback methods above mqtt_client.on_connect = connected mqtt_client.on_disconnect = disconnected mqtt_client.on_message = message photocell_val = 0 while True: print("start_advertising") ble.start_advertising(advertisement) while not ble.connected: pass if ble.connected:
# the new value. print("Feed {0} received new value: {1}".format(feed_id, payload)) # Connect to WiFi print("Connecting to WiFi...") wifi.connect() print("Connected!") # Initialize MQTT interface with the esp interface MQTT.set_socket(socket, esp) # Initialize a new MQTT Client object mqtt_client = MQTT.MQTT( broker="io.adafruit.com", username=secrets["aio_username"], password=secrets["aio_key"], ) # Initialize an Adafruit IO MQTT Client io = IO_MQTT(mqtt_client) # Connect the callback methods defined above to Adafruit IO io.on_connect = connected io.on_disconnect = disconnected io.on_message = message # Connect to Adafruit IO io.connect() # Start a blocking message loop...
print('Subscribed to {0} with QOS level {1}'.format(topic, granted_qos)) def unsubscribe(client, userdata, topic, pid): # This method is called when the client unsubscribes from a topic. print('Unsubscribed from {0} with PID {1}'.format(topic, pid)) def publish(client, userdata, topic, pid): # This method is called when the client publishes data to a topic. print('Published to {0} with PID {1}'.format(topic, pid)) def message(client, topic, msg): # This method is called when the client receives data from a topic. print("Message from {}: {}".format(topic, msg)) # Set up a new MiniMQTT Client client = MQTT.MQTT(broker = secrets['broker'], client_id = secrets['client_id']) # Initialize AWS IoT MQTT API Client aws_iot = MQTT_CLIENT(client) # Connect callback handlers to AWS IoT MQTT Client aws_iot.on_connect = connect aws_iot.on_disconnect = disconnect aws_iot.on_subscribe = subscribe aws_iot.on_unsubscribe = unsubscribe aws_iot.on_publish = publish aws_iot.on_message = message print('Attempting to connect to %s'%client.broker) aws_iot.connect()