io.on_disconnect = disconnected io.on_message = message # Connect to Adafruit IO io.connect() # Set data data_value = 42 # Set up metadata associated with data_value # lat, lon, ele metadata = "40.726190, -74.005334, -6" # Send data and location metadata to the 'location' feed print("Sending data and location metadata to IO...") io.publish("location", data_value, metadata) print("Data sent!") # Start a blocking message loop... # NOTE: NO code below this loop will execute # NOTE: Network reconnection is handled within this loop while True: try: io.loop() except (ValueError, RuntimeError) as e: print("Failed to get data, retrying\n", e) wifi.reset() io.reconnect() continue time.sleep(1)
class Network(NetworkBase): """Class representing the Adafruit FunHouse. :param status_dotstar: The initialized object for status DotStar. Defaults to ``None``, to not use the status LED :param bool extract_values: If true, single-length fetched values are automatically extracted from lists and tuples. Defaults to ``True``. :param debug: Turn on debug print outs. Defaults to False. """ # pylint: disable=too-many-instance-attributes, too-many-locals, too-many-branches, too-many-statements def __init__( self, *, status_dotstar=None, extract_values=True, debug=False, ): super().__init__( WiFi(status_dotstar=status_dotstar), extract_values=extract_values, debug=debug, ) self._mqtt_client = None def init_io_mqtt(self): """Initialize MQTT for Adafruit IO""" try: aio_username = self._secrets["aio_username"] aio_key = self._secrets["aio_key"] except KeyError: raise KeyError( "Adafruit IO secrets are kept in secrets.py, please add them there!\n\n" ) from KeyError return self.init_mqtt(IO_MQTT_BROKER, 8883, aio_username, aio_key, True) # pylint: disable=too-many-arguments 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 # pylint: enable=too-many-arguments def _get_mqtt_client(self): print(self._mqtt_client) if self._mqtt_client is not None: return self._mqtt_client raise RuntimeError("Please initialize MQTT before using") def mqtt_loop(self, *args, suppress_mqtt_errors=True, **kwargs): """Run the MQTT Loop""" self._get_mqtt_client() if suppress_mqtt_errors: try: if self._mqtt_client is not None: self._mqtt_client.loop(*args, **kwargs) except MQTT.MMQTTException as err: print("MMQTTException: {0}".format(err)) except OSError as err: print("OSError: {0}".format(err)) else: if self._mqtt_client is not None: self._mqtt_client.loop(*args, **kwargs) def mqtt_publish(self, *args, suppress_mqtt_errors=True, **kwargs): """Publish to MQTT""" self._get_mqtt_client() if suppress_mqtt_errors: try: if self._mqtt_client is not None: self._mqtt_client.publish(*args, **kwargs) except OSError as err: print("OSError: {0}".format(err)) else: if self._mqtt_client is not None: self._mqtt_client.publish(*args, **kwargs) def mqtt_connect(self, *args, **kwargs): """Connect to MQTT""" self._get_mqtt_client() if self._mqtt_client is not None: self._mqtt_client.connect(*args, **kwargs) @property def on_mqtt_connect(self): """ Get or Set the MQTT Connect Handler """ if self._mqtt_client: return self._mqtt_client.on_connect return None @on_mqtt_connect.setter def on_mqtt_connect(self, value): self._get_mqtt_client() self._mqtt_client.on_connect = value @property def on_mqtt_disconnect(self): """ Get or Set the MQTT Disconnect Handler """ if self._mqtt_client: return self._mqtt_client.on_disconnect return None @on_mqtt_disconnect.setter def on_mqtt_disconnect(self, value): self._get_mqtt_client().on_disconnect = value @property def on_mqtt_subscribe(self): """ Get or Set the MQTT Subscribe Handler """ if self._mqtt_client: return self._mqtt_client.on_subscribe return None @on_mqtt_subscribe.setter def on_mqtt_subscribe(self, value): self._get_mqtt_client().on_subscribe = value @property def on_mqtt_unsubscribe(self): """ Get or Set the MQTT Unsubscribe Handler """ if self._mqtt_client: return self._mqtt_client.on_unsubscribe return None @on_mqtt_unsubscribe.setter def on_mqtt_unsubscribe(self, value): self._get_mqtt_client().on_unsubscribe = value @property def on_mqtt_message(self): """ Get or Set the MQTT Message Handler """ if self._mqtt_client: return self._mqtt_client.on_message return None @on_mqtt_message.setter def on_mqtt_message(self, value): self._get_mqtt_client().on_message = value @property def enabled(self): """ Return whether the WiFi is enabled """ return self._wifi.enabled
fill_water(moisture_percentage) print("disp filled..") print("temp: " + str(temp) + " moisture: " + str(moisture)) # Play water level alarms if moisture <= SOIL_LEVEL_MIN: print("Playing low water level warning...") pyportal.play_file(wav_water_low) elif moisture >= SOIL_LEVEL_MAX: print("Playing high water level warning...") pyportal.play_file(wav_water_high) if now - initial > (DELAY_PUBLISH * 60): try: print("Publishing data to Adafruit IO...") label_status.text = "Sending to IO..." io.publish("moisture", moisture) io.publish("temperature", temp) print("Published") label_status.text = "Data Sent!" # reset timer initial = now except (ValueError, RuntimeError) as e: label_status.text = "ERROR!" print("Failed to get data, retrying...\n", e) wifi.reset() time.sleep(DELAY_SENSOR)
# Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() # Subscribe to all messages on the led feed io.subscribe("led") prv_refresh_time = 0.0 while True: # Poll for incoming messages try: io.loop() except (ValueError, RuntimeError) as e: print("Failed to get data, retrying\n", e) wifi.reset() io.reconnect() continue # Send a new temperature reading to IO every 30 seconds if (time.monotonic() - prv_refresh_time) > 30: # take the cpu's temperature cpu_temp = cpu.temperature # truncate to two decimal points cpu_temp = str(cpu_temp)[:5] print("CPU temperature is %s degrees C" % cpu_temp) # publish it to io print("Publishing %s to temperature feed..." % cpu_temp) io.publish("temperature", cpu_temp) print("Published!") prv_refresh_time = time.monotonic()
height=HEIGHT) splash = displayio.Group(max_size=10) display.show(splash) digital_label = label.Label(terminalio.FONT, text="Battery Percent: ", color=0xFFFFFF, x=4, y=4) splash.append(digital_label) alarm_label = label.Label(terminalio.FONT, text="Voltage: ", color=0xFFFFFF, x=4, y=14) splash.append(alarm_label) sensor = LC709203F(board.I2C()) start = 0 while True: io.loop() percent = sensor.cell_percent if time.time() - start > 60: io.publish("battery", int(percent)) start = time.time() splash[0].text = f"Percent: {str(int(percent))}%" splash[1].text = f"Voltage: {str(sensor.cell_voltage)}" time.sleep(1)
username=secrets["aio_user"], 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_subscribe = subscribe io.on_unsubscribe = unsubscribe io.on_message = message # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() # Below is an example of manually publishing a new value to Adafruit IO. last = 0 print("Publishing a new message every 10 seconds...") while True: # Explicitly pump the message loop. io.loop() # Send a new message every 10 seconds. if (time.monotonic() - last) >= 5: value = randint(0, 100) print("Publishing {0} to DemoFeed.".format(value)) io.publish("DemoFeed", value) last = time.monotonic()
class DataWarehouse(): SECRETS_REQUIRED = ("ssid", "password", "aio_username", "aio_key") def __init__( self, secrets_, *, esp01_pins=[], esp01_uart=None, esp01_baud=115200, pub_prefix="", debug=False ### pylint: disable=redefined-outer-name ): if esp01_uart: self.esp01_uart = esp01_uart else: self.esp01_uart = busio.UART(*esp01_pins, receiver_buffer_size=2048) self.debug = debug self.esp = adafruit_espatcontrol.ESP_ATcontrol(self.esp01_uart, esp01_baud, debug=debug) self.esp_version = "" self.wifi = None try: _ = [secrets_[key] for key in self.SECRETS_REQUIRED] except KeyError: raise RuntimeError("secrets.py must contain: " + " ".join(self.SECRETS_REQUIRED)) self.secrets = secrets_ self.io = None self.pub_prefix = pub_prefix self.pub_name = {} self.init_connect() 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() def reset_and_reconnect(self): self.wifi.reset() self.io.reconnect() def update_pub_name(self, field_name): pub_name = self.pub_prefix + field_name return pub_name def poll(self): dw_poll_ok = False try_reconnect = False for _ in range(2): try: ### Process any incoming messages if try_reconnect: self.reset_and_reconnect() try_reconnect = False self.io.loop() dw_poll_ok = True except (ValueError, RuntimeError, AttributeError, MQTT.MMQTTException, adafruit_espatcontrol.OKError, AdafruitIO_MQTTError) as ex: if self.debug: print("EXCEPTION: Failed to get data in loop()", repr(ex)) try_reconnect = True return dw_poll_ok def publish(self, p_data, p_fields): ok = [False] * len(p_fields) try_reconnect = False if self.debug: print("publish()") for idx, field_name in enumerate(p_fields): try: pub_name = self.pub_name[field_name] except KeyError: pub_name = self.update_pub_name(field_name) for _ in range(2): try: if try_reconnect: self.reset_and_reconnect() try_reconnect = False self.io.publish(pub_name, p_data[field_name]) ok[idx] = True break except (ValueError, RuntimeError, AttributeError, MQTT.MMQTTException, adafruit_espatcontrol.OKError, AdafruitIO_MQTTError) as ex: if self.debug: print("EXCEPTION: Failed to publish()", repr(ex)) try_reconnect = True time.sleep(RECONNECT_SLEEP) return all(ok)
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 # Group name group_name = "weatherstation" # Feeds within the group temp_feed = "weatherstation.temperature" humid_feed = "weatherstation.humidity" # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() print("Publishing new messages to group feeds every 5 seconds...") while True: io.loop() temp_reading = randint(0, 100) print("Publishing value {0} to feed: {1}".format(temp_reading, temp_feed)) io.publish(temp_feed, temp_reading) humid_reading = randint(0, 100) print("Publishing value {0} to feed: {1}".format(humid_reading, humid_feed)) io.publish(humid_feed, humid_reading) time.sleep(5)
print("Connecting to WIFI") wifi.radio.connect(secrets["ssid"], secrets["password"]) pool = socketpool.SocketPool(wifi.radio) print("Connecting to Adafruit IO") 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(), ) mqtt_client.connect() io = IO_MQTT(mqtt_client) # Blank out any previously published message io.publish(feed_name, "\ufeff") qrdecoder = qrio.QRDecoder(cam.width, cam.height) bitmap = displayio.Bitmap(cam.width, cam.height, 65536) # Create a greyscale palette pal = displayio.Palette(256) for i in range(256): pal[i] = 0x10101 * i label = Label( font=FONT, text="Scan QR Code...", color=0xFFFFFF, background_color=0x0, padding_top=2,
# Set up the callback methods above io.on_connect = connected io.on_message = message timestamp = 0 while True: try: # If Adafruit IO is not connected... if not io.is_connected: # Connect the client to the MQTT broker. print("Connecting to Adafruit IO...") io.connect() # Explicitly pump the message loop. io.loop() # Obtain the "random" value, print it and publish it to Adafruit IO every 10 seconds. if (time.monotonic() - timestamp) >= 10: random_number = "{}".format(randint(0, 255)) print("Current 'random' number: {}".format(random_number)) io.publish("random", random_number) timestamp = time.monotonic() # Adafruit IO fails with internal error types and WiFi fails with specific messages. # This except is broad to handle any possible failure. except Exception as e: # pylint: disable=broad-except print("Failed to get or send data, or connect. Error:", e, "\nBoard will hard reset in 30 seconds.") time.sleep(30) microcontroller.reset()
# 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 to Adafruit IO print("Connecting to Adafruit IO...") io.connect() while True: switch.update() print(switch.state) if switch.rose: print("Door is open") io.publish("door", 0) print("sent") if switch.fell: print("Door is closed") io.publish("door", 1) print("sent")
magtag.add_text( text_position=(50, (2 * 128) / 4,), text_scale=2, ) magtag.add_text( text_position=(50, (3 * 128) / 4,), text_scale=2, ) temperature, relative_humidity = sht.measurements magtag.set_text("Temperature: %0.1f C" % temperature, 0, False) magtag.set_text("Humidity: %0.1f %%" % relative_humidity, 1, False) T = temperature * 1.8 + 32 humidity = relative_humidity HI = ( -42.379 + 2.04901523 * T + 10.14333127 * humidity - 0.22475541 * T * humidity - 0.00683783 * T * T - 0.05481717 * humidity ** 2 + 0.00122874 * T * T * humidity + 0.00085282 * T * humidity ** 2 - 0.00000199 * T * T * humidity ** 2 ) magtag.set_text("Feels like: %0.1f F" % HI, 2) if connected: io.publish("temperature", temperature) io.publish("humidity", relative_humidity) io.publish("heatindex", HI) magtag.exit_and_deep_sleep(600)
io.on_message = message # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() plant_feed = "plant" START = 0 while True: # read moisture level through capacitive touch pad touch = seesaw.moisture_read() # read temperature from the temperature sensor temp = seesaw.get_temp() if touch < MIN: if not LOW: io.publish(plant_feed, touch) print("published") LOW = True elif touch >= MIN and time.time() - START > 10: io.publish(plant_feed, touch) print("published to Adafruit IO") START = time.time() LOW = False print("temp: " + str(temp) + " moisture: " + str(touch)) time.sleep(1)
# 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_subscribe = subscribe io.on_unsubscribe = unsubscribe io.on_message = message io.add_feed_callback("alarm-clock.alarm", on_alarm) # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() io.get("alarm-clock.alarm") LAST = 0 while True: io.loop() if ALARM and time.monotonic() - LAST >= 0.2: led.value = not led.value LAST = time.monotonic() if btn1.value: io.publish("alarm-clock.alarm", "False") led.value = False led.value = True time.sleep(1) led.value = False
# Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() START = 0 LOW = False MIN = 500 while True: # read moisture level through capacitive touch pad touch = seesaw.moisture_read() # read temperature from the temperature sensor temp = seesaw.get_temp() if touch < MIN: if not LOW: io.publish("plant", touch) print("published") LOW = True elif touch >= MIN and time.time() - START > 10: io.publish("plant", touch) print("published to Adafruit IO") START = time.time() LOW = False print("temp: " + str(temp) + " moisture: " + str(touch)) time.sleep(1)