def iot(self,type='mqtt',group='light-group',action=None,conn=None,disc=None): from adafruit_esp32spi import adafruit_esp32spi_wifimanager import adafruit_esp32spi.adafruit_esp32spi_socket as socket import adafruit_requests as requests from adafruit_io.adafruit_io import IO_HTTP from secrets import secrets from adafruit_io.adafruit_io import IO_MQTT from adafruit_minimqtt import MQTT if not self.hardware['ESP32']: raise if not action: action=self.message if not conn: conn=self.connected if not disc: disc=self.disconnected # try: requests.set_socket(socket,self._esp) self.WIFI = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager(self._esp, secrets, status_pixel=None) self.group_name = group self.WIFI.connect() mqtt_client = MQTT( socket=socket, broker="io.adafruit.com", username=secrets["aio_username"], password=secrets["aio_key"], network_manager=self.WIFI ) self.io = IO_MQTT(mqtt_client) self.io.on_connect = conn self.io.on_disconnect = disc self.io.on_message = action # else: # return self.io.connect()
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()
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)
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() # Set data data_value = 42 # Set up metadata associated with data_value # lat, lon, ele metadata = "40.726190, -74.005334, -6"
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_subscribe = subscribe # Set up a callback for the led feed io.add_feed_callback("led", on_led_msg) # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() # Subscribe to all messages on the led feed io.subscribe("led")
# the new value. print("Feed {0} received new value: {1}".format(feed_id, payload)) # Initialize MQTT interface with the ethernet interface MQTT.set_socket(socket, eth) # Initialize a new MQTT Client object mqtt_client = MQTT.MQTT( broker="io.adafruit.com", 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...")
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_subscribe = subscribe io.on_message = message # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() display_bus = displayio.I2CDisplay(board.I2C(), device_address=0x3C) WIDTH = 128 HEIGHT = 32 BORDER = 2
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 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:
status_light.fill(color_tuple) # connect to wifi wifi.connect() # initialize MQTT client mqtt_client = MQTT( socket=socket, broker="io.adafruit.com", username=secrets["aio_username"], password=secrets["aio_key"], network_manager=wifi ) # initialize an Adafruit IO MQTT client io = IO_MQTT(mqtt_client) # init. adt7410 # temperature sensor for data logging i2c_bus = busio.I2C(board.SCL, board.SDA) adt = adafruit_adt7410.ADT7410(i2c_bus, address=0x48) adt.high_resolution = True # connect callback methods for adafruit io mqtt io.on_connect = connected io.on_disconnect = disconnected io.on_subscribe = subscribe io.on_unsubscribe = unsubscribe io.on_message = message # connect to adafruits io.connect()
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) # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() connected = True except ConnectionError: pass i2c = busio.I2C(board.SCL, board.SDA) sht = adafruit_sht4x.SHT4x(i2c) print("Found SHT4x with serial number", hex(sht.serial_number)) sht.mode = adafruit_sht4x.Mode.NOHEAT_HIGHPRECISION # Can also set the mode to enable heater
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_subscribe = subscribe io.on_unsubscribe = unsubscribe io.on_message = on_message # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() # Set up a message handler for the battery feed io.add_feed_callback("enge-1216.digital", on_digital_msg) io.add_feed_callback("enge-1216.alarm-time", on_time)
def subscribe(client, userdata, topic, granted_qos): # This method is called when the client subscribes to a new feed. print('Subscribed to {0} with QOS level {1}'.format(topic, granted_qos)) # pylint: disable=unused-argument def disconnected(client): # Disconnected function will be called if the client disconnects # from the Adafruit IO MQTT broker. print("Disconnected from Adafruit IO!") # Initialize an Adafruit IO MQTT Client io = IO_MQTT(mqtt_client) # Connect the callback methods defined above to the Adafruit IO MQTT Client io.on_connect = connected io.on_subscribe = subscribe io.on_disconnect = disconnected ## Connect to Adafruit IO #print("Connecting to Adafruit IO...") #io.connect() #label_status.text = " " #print("Connected!") fill_val = 0.0
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_subscribe = subscribe 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
cam.colorspace = adafruit_ov2640.OV2640_COLOR_YUV 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,
# 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_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_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...")
class DevBoard: def __init__(self): """ Big init routine as the whole board is brought up. """ self.hardware = { 'SDcard': False, 'ESP32': False, 'Neopixel': False, } self.payload = None self.filename = '' # Define LEDs: self._led = digitalio.DigitalInOut(board.LED) self._led.switch_to_output() # Define battery voltage # self._vbatt = analogio.AnalogIn(board.BATTERY) # Define SPI,I2C,UART self._spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) self._uart = busio.UART(board.TX2, board.RX2) # Define sdcard self._sdcs = digitalio.DigitalInOut(board.xSDCS) self._sdcs.direction = digitalio.Direction.OUTPUT self._sdcs.value = True # Initialize sdcard try: import adafruit_sdcard self._sd = adafruit_sdcard.SDCard(self._spi, self._sdcs) self._vfs = storage.VfsFat(self._sd) storage.mount(self._vfs, "/sd") sys.path.append("/sd") self.hardware['SDcard'] = True except Exception as e: print('[WARNING]', e) # Define ESP32 self._esp_dtr = digitalio.DigitalInOut(board.DTR) self._esp_rts = digitalio.DigitalInOut(board.RTS) self._esp_cs = digitalio.DigitalInOut(board.TMS) #GPIO14 self._esp_rdy = digitalio.DigitalInOut(board.TCK) #GPIO13 self._esp_cs.direction = digitalio.Direction.OUTPUT self._esp_dtr.direction = digitalio.Direction.OUTPUT self._esp_rts.direction = digitalio.Direction.OUTPUT self._esp_cs.value = True self._esp_dtr.value = False self._esp_rts.value = False # Initialize Neopixel try: self.neopixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2, pixel_order=neopixel.GRB) self.neopixel[0] = (0, 0, 0) self.hardware['Neopixel'] = True except Exception as e: print('[WARNING]', e) def esp_init(self): from adafruit_esp32spi import adafruit_esp32spi # Initialize ESP32 try: self._esp = adafruit_esp32spi.ESP_SPIcontrol( self._spi, self._esp_cs, self._esp_rdy, self._esp_rts, gpio0_pin=self._esp_dtr, debug=False) if self._esp.status == adafruit_esp32spi.WL_IDLE_STATUS: self.hardware['ESP32'] = True except Exception as e: print('[WARNING]', e, '- have you programed the ESP32?') @property def temperature_cpu(self): return microcontroller.cpu.temperature # Celsius @property def LED(self): return self._led.value @LED.setter def LED(self, value): self._led.value = value @property def RGB(self): return self.neopixel[0] @RGB.setter def RGB(self, value): if self.hardware['Neopixel']: try: self.neopixel[0] = value except Exception as e: print('[WARNING]', e) @property def brightness(self): return self.neopixel.brightness @brightness.setter def brightness(self, value): if self.hardware['Neopixel']: try: self.neopixel.brightness = value except Exception as e: print('[WARNING]', e) def unique_file(self): import os if not self.hardware['SDcard']: return False try: name = 'DATA_000' files = [] for i in range(0, 50): _filename = name[:-2] + str(int(i / 10)) + str(int( i % 10)) + '.txt' if _filename not in os.listdir('/sd/'): with open('/sd/' + _filename, "a") as f: time.sleep(0.01) self.filename = '/sd/' + _filename print('filename is:', self.filename) return True except Exception as e: print('--- SD card error ---', e) self.RGB = (255, 0, 0) return False def save(self, dataset, savefile=None): if savefile == None: savefile = self.filename try: with open(savefile, "a") as file: for item in dataset: for i in item: if isinstance(i, float): file.write(',{:.9E}'.format(i)) else: file.write(',{}'.format(i)) file.write('\n') except Exception as e: print(e) def print_file(self, filedir): try: print('--- Printing File: {} ---'.format(filedir)) with open(filedir, "r") as file: for line in file: print(line.strip()) except Exception as e: print('[WARNING]', e) def wheel(self, pos): # Input a value 0 to 255 to get a color value. # The colours are a transition r - g - b - back to r. if pos < 0 or pos > 255: r = g = b = 0 elif pos < 85: r = int(pos * 3) g = int(255 - pos * 3) b = 0 elif pos < 170: pos -= 85 r = int(255 - pos * 3) g = 0 b = int(pos * 3) else: pos -= 170 r = 0 g = int(pos * 3) b = int(255 - pos * 3) return (r, g, b) def rainbow(self): try: print('\n\tPress any key to stop') self.neopixel.auto_write = False while True: for j in range(255): if supervisor.runtime.serial_bytes_available: self.neopixel.auto_write = True self.neopixel[0] = (0, 0, 0) return else: pixel_index = (256 // 1) + j self.neopixel[0] = self.wheel(pixel_index & 255) self.neopixel.show() time.sleep(0.1) except Exception as e: print('[WARNING]', e) self.neopixel.auto_write = True def battery_voltage(self): _voltage = self._vbatt.value * 3.3 / (2**16) _voltage = _voltage / 2 # voltage divider return _voltage # in volts def esp_status(self): if self.hardware['ESP32']: try: if self._esp.status == adafruit_esp32spi.WL_IDLE_STATUS: print('\tESP32 is idle') else: print('\t', self._esp.status) except Exception as e: print('[WARNING]', e) else: print('[WARNING] ESP32 not initialized') def ap_scan(self): if self.hardware['ESP32']: try: for ap in self._esp.scan_networks(): print("\t%s\tRSSI: %d" % (str(ap['ssid'], 'utf-8'), ap['rssi'])) except Exception as e: print('[WARNING]', e) else: print('[WARNING] ESP32 not initialized') def wifi(self, ssid, pswrd): if self.hardware['ESP32']: try: print("\tConnecting to AP...") while not self._esp.is_connected: try: self._esp.connect_AP(bytes(bytearray(ssid)), bytes(bytearray(pswrd))) except RuntimeError as e: print("\t\tCould not connect to AP, retrying: ", e) continue print("\tConnected to", str(self._esp.ssid, 'utf-8'), "\tRSSI:", self._esp.rssi) print("\tMy IP address is", self._esp.pretty_ip(self._esp.ip_address)) print("\tPing google.com: %d ms" % self._esp.ping("google.com")) except Exception as e: print('[WARNING]', e) else: print('[WARNING] ESP32 not initialized') def esp_prog(self): if self.hardware['SDcard']: try: import adafruit_miniesptool esptool = adafruit_miniesptool.miniesptool(self._uart, self._esp_dtr, self._esp_rts, flashsize=4 * 1024 * 1024) esptool.debug = False #True time.sleep(0.5) esptool.sync() print("\tSynced") print("\tFound:", esptool.chip_name) if esptool.chip_name != "ESP32": raise RuntimeError("\tfor ESP32 only") esptool.baudrate = 19200 #912600 print("\tMAC ADDR: ", [hex(i) for i in esptool.mac_addr]) esptool.flash_file('/sd/NINA_W102-1.3.0_sam32.bin', 0x00) esptool.reset() time.sleep(0.5) except Exception as e: print('[WARNING]', e) else: print('[WARNING] no SD card found') def esp_repl(self): if self.hardware['ESP32']: while True: try: if self._uart.in_waiting: try: data = self._uart.read() data_string = ''.join([chr(b) for b in data]) print('\t', data_string, end='') except: pass if supervisor.runtime.serial_bytes_available: call = input() if call == 'exit': print('=== exiting ESP32 REPL ===') return self._uart.write( bytes(call, 'utf-8') + b'\x0d\x0a') #add CR+LF to end of call try: data = self._uart.read() data_string = ''.join([chr(b) for b in data]) print(data_string, end='') except: pass except Exception as e: print('[WARNING]', e) def connected(self, client): self.io.subscribe(group_key=self.group_name) def disconnected(self, client): print("Disconnected from Adafruit IO!") def message(self, client, feed_id, payload): print("Feed {0} received new value: {1}".format(feed_id, payload)) self.payload = payload def iot(self, type='mqtt', group='light-group', action=None, conn=None, disc=None): from adafruit_esp32spi import adafruit_esp32spi_wifimanager import adafruit_esp32spi.adafruit_esp32spi_socket as socket import adafruit_requests as requests from adafruit_io.adafruit_io import IO_HTTP from secrets import secrets from adafruit_io.adafruit_io import IO_MQTT from adafruit_minimqtt import MQTT if not self.hardware['ESP32']: raise if not action: action = self.message if not conn: conn = self.connected if not disc: disc = self.disconnected # try: requests.set_socket(socket, self._esp) self.WIFI = adafruit_esp32spi_wifimanager.ESPSPI_WiFiManager( self._esp, secrets, status_pixel=None) self.group_name = group self.WIFI.connect() mqtt_client = MQTT(socket=socket, broker="io.adafruit.com", username=secrets["aio_username"], password=secrets["aio_key"], network_manager=self.WIFI) self.io = IO_MQTT(mqtt_client) self.io.on_connect = conn self.io.on_disconnect = disc self.io.on_message = action # else: # return self.io.connect()
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, ) iot.add_device( feed_key="temperature", default_text="Temperature: ", formatted_text="Temperature: {:.1f} C", ) iot.add_device(feed_key="humidity",
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) io.add_feed_callback("lamp", on_lamp) # Connect the callback methods defined above to Adafruit IO io.on_connect = connected io.on_subscribe = subscribe # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() io.get("lamp") while True: io.loop()
def connected(client): # Connected function will be called when the client is connected to Adafruit IO. print('Connected to Adafruit IO!') def subscribe(client, userdata, topic, granted_qos): # This method is called when the client subscribes to a new feed. print('Subscribed to {0} with QOS level {1}'.format(topic, granted_qos)) # pylint: disable=unused-argument def disconnected(client): # Disconnected function will be called if the client disconnects # from the Adafruit IO MQTT broker. print("Disconnected from Adafruit IO!") # Initialize an Adafruit IO MQTT Client io = IO_MQTT(mqtt_client) # Connect the callback methods defined above to the Adafruit IO MQTT Client io.on_connect = connected io.on_subscribe = subscribe io.on_disconnect = disconnected # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() label_status.text = " " print("Connected!") fill_val = 0.0 def fill_water(fill_percent): """Fills the background water.
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) io.add_feed_callback("heatindex", on_hi) # Connect the callback methods defined above to Adafruit IO io.on_connect = connected io.on_subscribe = subscribe # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() io.get("heatindex") while True: io.loop()
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_subscribe = subscribe io.on_unsubscribe = unsubscribe io.on_message = on_message # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() # Set up a message handler for the battery feed io.add_feed_callback("battery", on_battery_msg)
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) io.add_feed_callback("neopixel", on_neopixel) # Connect the callback methods defined above to Adafruit IO io.on_connect = connected io.on_subscribe = subscribe # Connect to Adafruit IO print("Connecting to Adafruit IO...") io.connect() io.get("neopixel") while True: io.loop()
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
# 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 Adafruit IO MQTT "helper" io = IO_MQTT(mqtt_client) # 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.
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... # NOTE: NO code below this loop will execute # NOTE: Network reconnection is handled within this loop while True: try: io.loop()
# 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) # 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")