Add IoT environmental sensor code

Author: dastels

IoT_Environment_Sensor/aio.py

@@ -0,0 +1,144 @@
+"""
+IoT environmental sensor node.
+
+Adafruit invests time and resources providing this open source code.
+Please support Adafruit and open source hardware by purchasing
+products from Adafruit!
+
+Written by Dave Astels for Adafruit Industries
+Copyright (c) 2019 Adafruit Industries
+Licensed under the MIT license.
+
+All text above must be included in any redistribution.
+"""
+
+import time
+import board
+import busio
+import gc
+from digitalio import DigitalInOut
+from adafruit_esp32spi import adafruit_esp32spi
+import adafruit_esp32spi.adafruit_esp32spi_requests as requests
+import adafruit_logging as logging
+import rtc
+
+logger = logging.getLogger('main')
+
+TIME_SERVICE = "https://io.adafruit.com/api/v2/%s/integrations/time/strftime?x-aio-key=%s"
+# our strftime is %Y-%m-%d %H:%M:%S.%L %j %u %z %Z see http://strftime.net/ for decoding details
+# See https://apidock.com/ruby/DateTime/strftime for full options
+TIME_SERVICE_STRFTIME = '&fmt=%25Y-%25m-%25d+%25H%3A%25M%3A%25S.%25L+%25j+%25u+%25z+%25Z'
+
+
+
+# Get wifi details and more from a settings.py file
+try:
+    from secrets import secrets
+except ImportError:
+    logger.critical('WiFi settings are kept in settings.py, please add them there!')
+    raise
+
+class AIO(object):
+
+    def __init__(self):
+        esp32_cs = DigitalInOut(board.D10)
+        esp32_ready = DigitalInOut(board.D9)
+        esp32_reset = DigitalInOut(board.D6)
+
+        spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
+        self._esp = adafruit_esp32spi.ESP_SPIcontrol(spi, esp32_cs, esp32_ready, esp32_reset)
+
+        if self._esp.status == adafruit_esp32spi.WL_IDLE_STATUS:
+            logger.debug('ESP32 found and in idle mode')
+        logger.info('Firmware vers. %s', self._esp.firmware_version)
+        logger.info('MAC addr: %s', ':'.join([hex(i)[2:4] for i in self._esp.MAC_address]))
+
+        requests.set_interface(self._esp)
+
+
+    def connect(self):
+        logger.debug("Connecting...")
+        while not self._esp.is_connected:
+            try:
+                self._esp.connect_AP(secrets['ssid'], secrets['password'])
+            except RuntimeError as e:
+                logger.error("could not connect to AP, retrying: %s", e)
+                continue
+
+    def post(self, feed, payload):
+        api_url = 'https://io.adafruit.com/api/v2/{0}/feeds/{1}/data'.format(secrets['aio_username'], feed)
+        logger.info('POSTing to %s', api_url)
+        logger.info('payload: %s', str(payload))
+        auth_header = {'X-AIO-KEY':secrets['aio_key']}
+        self.connect()
+        r = None
+        tries = 0
+        while True:
+            if tries == 5:
+                return False
+            tries += 1
+            try:
+                r = requests.post(api_url, headers=auth_header, json=payload)
+                logger.info('Status: %d', r.status_code)
+                if r.status_code == 200:
+                    logger.debug('Headers: %s', str(r.headers))
+                    logger.debug('Text: %s', str(r.json()))
+                else:
+                    logger.debug('Text: %s', str(r.json()))
+                break
+            except RuntimeError as err:
+                logger.error('Error posting: %s', str(err))
+                logger.info('Resetting and reconnecting')
+                self._esp.reset()
+                self.connect()
+        r.close()
+        return r.status_code == 200
+
+    def refresh_local_time(self):
+        # pylint: disable=line-too-long
+        """Fetch and "set" the local time of this microcontroller to the local time at the location, using an internet time API.
+        Copied from adafruit_pyportal
+        :param str location: Your city and country, e.g. ``"New York, US"``.
+        """
+        # pylint: enable=line-too-long
+        api_url = None
+        try:
+            aio_username = secrets['aio_username']
+            aio_key = secrets['aio_key']
+        except KeyError:
+            raise KeyError("\n\nOur time service requires a login/password to rate-limit. Please register for a free adafruit.io account and place the user/key in your secrets file under 'aio_username' and 'aio_key'")# pylint: disable=line-too-long
+
+        location = secrets['timezone']
+        if location:
+            logger.debug('Getting time for timezone %s', location)
+            api_url = (TIME_SERVICE + "&tz=%s") % (aio_username, aio_key, location)
+        else: # we'll try to figure it out from the IP address
+            logger.debug("Getting time from IP address")
+            api_url = TIME_SERVICE % (aio_username, aio_key)
+        api_url += TIME_SERVICE_STRFTIME
+        logger.debug('Requesting time from %s', api_url)
+        try:
+            self.connect()
+            response = requests.get(api_url)
+            logger.debug('Time reply: %s', response.text)
+            times = response.text.split(' ')
+            the_date = times[0]
+            the_time = times[1]
+            year_day = int(times[2])
+            week_day = int(times[3])
+            is_dst = None  # no way to know yet
+        except KeyError:
+            raise KeyError("Was unable to lookup the time, try setting secrets['timezone'] according to http://worldtimeapi.org/timezones")  # pylint: disable=line-too-long
+        year, month, mday = [int(x) for x in the_date.split('-')]
+        the_time = the_time.split('.')[0]
+        hours, minutes, seconds = [int(x) for x in the_time.split(':')]
+        now = time.struct_time((year, month, mday, hours, minutes, seconds, week_day, year_day,
+                                is_dst))
+        rtc.RTC().datetime = now
+        logger.debug('Fetched time: %s', str(now))
+
+        # now clean up
+        response.close()
+        response = None
+        gc.collect()
+        return now

IoT_Environment_Sensor/air_quality.py

@@ -0,0 +1,127 @@
+"""
+IoT environmental sensor node.
+
+Adafruit invests time and resources providing this open source code.
+Please support Adafruit and open source hardware by purchasing
+products from Adafruit!
+
+Written by Dave Astels for Adafruit Industries
+Copyright (c) 2019 Adafruit Industries
+Licensed under the MIT license.
+
+All text above must be included in any redistribution.
+"""
+
+import adafruit_logging as logging
+
+try:
+    import struct
+except ImportError:
+    import ustruct as struct
+
+logger = logging.getLogger('main')
+
+class AirQualitySensor (object):
+
+    def __init__(self, uart):
+        self._uart = uart
+        self._buffer = []
+        self._pm10_standard = 0
+        self._pm25_standard = 0
+        self._pm100_standard = 0
+        self._pm10_env = 0
+        self._pm25_env = 0
+        self._pm100_env = 0
+        self._particles_03um = 0
+        self._particles_05um = 0
+        self._particles_10um = 0
+        self._particles_25um = 0
+        self._particles_50um = 0
+        self._particles_100um = 0
+
+    def read(self):
+        data = self._uart.read(32)  # read up to 32 bytes
+        data = list(data)
+
+        self._buffer += data
+
+        while self._buffer and self._buffer[0] != 0x42:
+            self._buffer.pop(0)
+
+        if len(self._buffer) > 200:
+            self._buffer = []  # avoid an overrun if all bad data
+            return False
+        if len(self._buffer) < 32:
+            return False
+
+        if self._buffer[1] != 0x4d:
+            self._buffer.pop(0)
+            return False
+
+        frame_len = struct.unpack(">H", bytes(self._buffer[2:4]))[0]
+        if frame_len != 28:
+            self._buffer = []
+            return False
+
+        logger.debug('buffer length: %d', len(self._buffer) - 4)
+        frame = struct.unpack(">HHHHHHHHHHHHHH", bytes(self._buffer[4:32]))
+
+        self._pm10_standard, self._pm25_standard, self._pm100_standard, self._pm10_env, \
+          self._pm25_env, self._pm100_env, self._particles_03um, self._particles_05um, self._particles_10um, \
+          self._particles_25um, self._particles_50um, self._particles_100um, skip, checksum = frame
+
+        check = sum(self._buffer[0:30])
+
+        if check != checksum:
+            self._buffer = []
+            return False
+
+        return True
+
+    @property
+    def pm10_standard(self):
+        return self._pm10_standard
+
+    @property
+    def pm25_standard(self):
+        return self._pm25_standard
+
+    @property
+    def pm100_standard(self):
+        return self._pm100_standard
+
+    @property
+    def pm10_env(self):
+        return self._pm10_env
+
+    @property
+    def pm25_env(self):
+        return self._pm25_env
+
+    @property
+    def pm100_env(self):
+        return self._pm100_env
+
+    @property
+    def particles_03um(self):
+        return self._particles_03um
+
+    @property
+    def particles_05um(self):
+        return self._particles_05um
+
+    @property
+    def particles_10um(self):
+        return self._particles_10um
+
+    @property
+    def particles_25um(self):
+        return self._particles_25um
+
+    @property
+    def particles_50um(self):
+        return self._particles_50um
+
+    @property
+    def particles_100um(self):
+        return self._particles_100um