From 5cb68151594c81da204bf048a638ecc0eec18612 Mon Sep 17 00:00:00 2001 From: janik Date: Sat, 21 Aug 2021 12:09:58 +0200 Subject: [PATCH] reworked most of the code to be simpler, albeit also less powerful --- .vscode/extensions.json | 9 ++ .vscode/settings.json | 0 deploy.rsh | 11 ++ dev-requirements.txt | 1 + micropy.json | 13 +++ requirements.txt | 0 src/bme280.py | 246 ++++++++++++++++++++++++++++++++++++++++ src/boot.py | 1 + src/main.py | 145 +++++++++++++++++++++++ 9 files changed, 426 insertions(+) create mode 100755 .vscode/extensions.json create mode 100755 .vscode/settings.json create mode 100755 deploy.rsh create mode 100755 dev-requirements.txt create mode 100755 micropy.json create mode 100755 requirements.txt create mode 100755 src/bme280.py create mode 100755 src/boot.py create mode 100755 src/main.py diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100755 index 0000000..2e8d346 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,9 @@ +{ + // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations. + // Extension identifier format: ${publisher}.${name}. Example: vscode.csharp + // List of extensions which should be recommended for users of this workspace. + "recommendations": [ + "ms-python.python", // micropy-cli: required for vscode micropython integrations + "VisualStudioExptTeam.vscodeintellicode" // micropy-cli: optional for advanced intellisense + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100755 index 0000000..e69de29 diff --git a/deploy.rsh b/deploy.rsh new file mode 100755 index 0000000..70b25a7 --- /dev/null +++ b/deploy.rsh @@ -0,0 +1,11 @@ +#call with rshell -f deploy.rsh + +connect serial /dev/ttyUSB0 + +echo Mirroring code +rsync -m src /pyboard + +echo Done. Resetting now +repl ~ import machine ~ machine.reset() ~ + +shell minicom usb0 \ No newline at end of file diff --git a/dev-requirements.txt b/dev-requirements.txt new file mode 100755 index 0000000..3603a92 --- /dev/null +++ b/dev-requirements.txt @@ -0,0 +1 @@ +micropy-cli diff --git a/micropy.json b/micropy.json new file mode 100755 index 0000000..676cd0d --- /dev/null +++ b/micropy.json @@ -0,0 +1,13 @@ +{ + "name": "smoker-thermometer", + "stubs": { + "esp32-micropython-1.15.0": "1.3.9" + }, + "dev-packages": { + "micropy-cli": "*" + }, + "packages": {}, + "config": { + "vscode": true + } +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100755 index 0000000..e69de29 diff --git a/src/bme280.py b/src/bme280.py new file mode 100755 index 0000000..10d18ef --- /dev/null +++ b/src/bme280.py @@ -0,0 +1,246 @@ +# Updated 2018 and 2020 +# This module is based on the below cited resources, which are all +# based on the documentation as provided in the Bosch Data Sheet and +# the sample implementation provided therein. +# +# Final Document: BST-BME280-DS002-15 +# +# Authors: Paul Cunnane 2016, Peter Dahlebrg 2016 +# +# This module borrows from the Adafruit BME280 Python library. Original +# Copyright notices are reproduced below. +# +# Those libraries were written for the Raspberry Pi. This modification is +# intended for the MicroPython and esp8266 boards. +# +# Copyright (c) 2014 Adafruit Industries +# Author: Tony DiCola +# +# Based on the BMP280 driver with BME280 changes provided by +# David J Taylor, Edinburgh (www.satsignal.eu) +# +# Based on Adafruit_I2C.py created by Kevin Townsend. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# + +import time +from ustruct import unpack, unpack_from +from array import array + +# BME280 default address. +BME280_I2CADDR = 0x76 + +# Operating Modes +BME280_OSAMPLE_1 = 1 +BME280_OSAMPLE_2 = 2 +BME280_OSAMPLE_4 = 3 +BME280_OSAMPLE_8 = 4 +BME280_OSAMPLE_16 = 5 + +BME280_REGISTER_CONTROL_HUM = 0xF2 +BME280_REGISTER_STATUS = 0xF3 +BME280_REGISTER_CONTROL = 0xF4 + +MODE_SLEEP = const(0) +MODE_FORCED = const(1) +MODE_NORMAL = const(3) + +BME280_TIMEOUT = const(100) # about 1 second timeout + +class BME280: + + def __init__(self, + mode=BME280_OSAMPLE_8, + address=BME280_I2CADDR, + i2c=None, + **kwargs): + # Check that mode is valid. + if mode not in [BME280_OSAMPLE_1, BME280_OSAMPLE_2, BME280_OSAMPLE_4, + BME280_OSAMPLE_8, BME280_OSAMPLE_16]: + raise ValueError( + 'Unexpected mode value {0}. Set mode to one of ' + 'BME280_OSAMPLE_1, BME280_OSAMPLE_2, BME280_OSAMPLE_4,' + 'BME280_OSAMPLE_8, BME280_OSAMPLE_16'.format(mode)) + self._mode = mode + self.address = address + if i2c is None: + raise ValueError('An I2C object is required.') + self.i2c = i2c + self.__sealevel = 101325 + + # load calibration data + dig_88_a1 = self.i2c.readfrom_mem(self.address, 0x88, 26) + dig_e1_e7 = self.i2c.readfrom_mem(self.address, 0xE1, 7) + + self.dig_T1, self.dig_T2, self.dig_T3, self.dig_P1, \ + self.dig_P2, self.dig_P3, self.dig_P4, self.dig_P5, \ + self.dig_P6, self.dig_P7, self.dig_P8, self.dig_P9, \ + _, self.dig_H1 = unpack("> 4 + raw_press = ((readout[0] << 16) | (readout[1] << 8) | readout[2]) >> 4 + # temperature(0xFA): ((msb << 16) | (lsb << 8) | xlsb) >> 4 + raw_temp = ((readout[3] << 16) | (readout[4] << 8) | readout[5]) >> 4 + # humidity(0xFD): (msb << 8) | lsb + raw_hum = (readout[6] << 8) | readout[7] + + result[0] = raw_temp + result[1] = raw_press + result[2] = raw_hum + + def read_compensated_data(self, result=None): + """ Reads the data from the sensor and returns the compensated data. + + Args: + result: array of length 3 or alike where the result will be + stored, in temperature, pressure, humidity order. You may use + this to read out the sensor without allocating heap memory + + Returns: + array with temperature, pressure, humidity. Will be the one + from the result parameter if not None + """ + self.read_raw_data(self._l3_resultarray) + raw_temp, raw_press, raw_hum = self._l3_resultarray + # temperature + var1 = (raw_temp/16384.0 - self.dig_T1/1024.0) * self.dig_T2 + var2 = raw_temp/131072.0 - self.dig_T1/8192.0 + var2 = var2 * var2 * self.dig_T3 + self.t_fine = int(var1 + var2) + temp = (var1 + var2) / 5120.0 + temp = max(-40, min(85, temp)) + + # pressure + var1 = (self.t_fine/2.0) - 64000.0 + var2 = var1 * var1 * self.dig_P6 / 32768.0 + var1 * self.dig_P5 * 2.0 + var2 = (var2 / 4.0) + (self.dig_P4 * 65536.0) + var1 = (self.dig_P3 * var1 * var1 / 524288.0 + self.dig_P2 * var1) / 524288.0 + var1 = (1.0 + var1 / 32768.0) * self.dig_P1 + if (var1 == 0.0): + pressure = 30000 # avoid exception caused by division by zero + else: + p = ((1048576.0 - raw_press) - (var2 / 4096.0)) * 6250.0 / var1 + var1 = self.dig_P9 * p * p / 2147483648.0 + var2 = p * self.dig_P8 / 32768.0 + pressure = p + (var1 + var2 + self.dig_P7) / 16.0 + pressure = max(30000, min(110000, pressure)) + + # humidity + h = (self.t_fine - 76800.0) + h = ((raw_hum - (self.dig_H4 * 64.0 + self.dig_H5 / 16384.0 * h)) * + (self.dig_H2 / 65536.0 * (1.0 + self.dig_H6 / 67108864.0 * h * + (1.0 + self.dig_H3 / 67108864.0 * h)))) + humidity = h * (1.0 - self.dig_H1 * h / 524288.0) + # humidity = max(0, min(100, humidity)) + + if result: + result[0] = temp + result[1] = pressure + result[2] = humidity + return result + + return array("f", (temp, pressure, humidity)) + + @property + def sealevel(self): + return self.__sealevel + + @sealevel.setter + def sealevel(self, value): + if 30000 < value < 120000: # just ensure some reasonable value + self.__sealevel = value + + @property + def altitude(self): + ''' + Altitude in m. + ''' + from math import pow + try: + p = 44330 * (1.0 - pow(self.read_compensated_data()[1] / + self.__sealevel, 0.1903)) + except: + p = 0.0 + return p + + @property + def dew_point(self): + """ + Compute the dew point temperature for the current Temperature + and Humidity measured pair + """ + from math import log + t, p, h = self.read_compensated_data() + h = (log(h, 10) - 2) / 0.4343 + (17.62 * t) / (243.12 + t) + return 243.12 * h / (17.62 - h) + + @property + def values(self): + """ human readable values """ + + t, p, h = self.read_compensated_data() + + return ("{:.2f}C".format(t), "{:.2f}hPa".format(p/100), + "{:.2f}%".format(h)) diff --git a/src/boot.py b/src/boot.py new file mode 100755 index 0000000..a328c7a --- /dev/null +++ b/src/boot.py @@ -0,0 +1 @@ +# boot.py - - runs on boot-up \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100755 index 0000000..f9f9459 --- /dev/null +++ b/src/main.py @@ -0,0 +1,145 @@ +import machine +import utime + +if machine.reset_cause() != machine.DEEPSLEEP_RESET: + print("Reset detected, waiting 3 seconds to give you time to interrupt...") + utime.sleep(3) + +import network +import urequests +import bme280 +import uasyncio + +#pins +PIN_LED = 22 + +BMP_SCL = 16 +BMP_SDA = 4 + +#hostname of this sensor +HOSTNAME = "SENSORNODE_02" + +#data for influxdb +INFLUX_HOST = "influx.krumel.moe" +INFLUX_BUCKET = "sensornodes" +INFLUX_ORG = "none" +INFLUX_TOKEN = "5TQvTkulmC6C_EIBE5objHDPROqdUjhCQbqA9pDL2V-D-MDMq8HXmC4azbapB-8O_8stypSGUCdmqpITHaosow==" +INFLUX_PUSH_INTERVAL = 300*1000 #in ms 300k -> 5mins + +WATCHDOG_TIMEOUT = 25*1000 #in ms -> 25s + +DEBUG = 0 + +#status led +led = machine.Pin(PIN_LED, machine.Pin.OUT) +led.value(1) + +WLAN_STATUS = 0 #global wlan status, 0 -> disconnected; 1 -> connected + +async def wlan_connection(): + global WLAN_STATUS + wlan = network.WLAN(network.STA_IF) + wlan.active(True) + + while True: + #connect to wlan + try: + if not wlan.isconnected(): + print("Trying to connect to wlan") + wlan.connect("espnet", "esp32net") + while not wlan.isconnected(): + await uasyncio.sleep_ms(500) + print("Connected: {}".format(wlan.ifconfig())) + WLAN_STATUS = 1 + except OSError as err: + print(err) + + #just sleep while wlan is connected + while wlan.isconnected(): + await uasyncio.sleep_ms(5000) + + WLAN_STATUS = 0 #set wlan as disconnected if we pass the sleeping while connected part + +async def sensor_readout(): + global WLAN_STATUS + + # wait for wlan connection + while WLAN_STATUS == 0: + await uasyncio.sleep_ms(500) + + i2c = machine.SoftI2C( + scl = machine.Pin(BMP_SCL), + sda = machine.Pin(BMP_SDA) + ) + + if DEBUG >= 2: + print("Debug active, generating bogus sensor data...") + sensor_data = (15.5, 1030.1, 53.5) + else: + sensor = bme280.BME280(i2c=i2c, + mode=bme280.BME280_OSAMPLE_16) + + sensor_data = sensor.read_compensated_data() + + print(sensor_data) + + temp, pressure, humidity = sensor_data + + print("Measured temperature: {}°C".format(temp)) + print("Measured pressure: {}Pa".format(pressure)) + print("Measured humidity: {}%".format(humidity)) + + try: + url = "https://{host}/api/v2/write?org={org}&bucket={bucket}".format(host=INFLUX_HOST, org=INFLUX_ORG, bucket=INFLUX_BUCKET) + + data = "temperature,host={host} _value={temp}".format(host=HOSTNAME, temp=temp) + data += "\npressure,host={host} _value={pressure}".format(host=HOSTNAME, pressure=pressure) + data += "\nhumidity,host={host} _value={humidity}".format(host=HOSTNAME, humidity=humidity) + + headers = {"Authorization" : "Token {}".format(INFLUX_TOKEN)} + + if DEBUG >= 1: + print("Debug is active, writing to serial instead of POSTing:") + print(url) + print(headers) + print(data) + else: + urequests.post(url, data=data, headers=headers) + except OSError as err: + print(err) + + print("Done, going to sleep normally") + + await blink_led(3) + await shutdown() + +async def watchdog_shutdown(): + await uasyncio.sleep_ms(WATCHDOG_TIMEOUT) + print("Watchdog time exceeded, going to sleep") + await blink_led(5) + await shutdown() + +async def blink_led(times): + print("Blinking {} times".format(times)) + for i in range(times): + led.value(0) + await uasyncio.sleep_ms(50) + led.value(1) + await uasyncio.sleep_ms(150) + +async def shutdown(): + print("Measurement time: {}ms".format(utime.ticks_ms())) + print("Measurement complete, going to sleep for ~{}ms".format(INFLUX_PUSH_INTERVAL - utime.ticks_ms())) + machine.deepsleep(INFLUX_PUSH_INTERVAL - utime.ticks_ms()) + +async def main(): + + uasyncio.create_task(watchdog_shutdown()) + + uasyncio.create_task(wlan_connection()) + uasyncio.create_task(sensor_readout()) + + while True: + await uasyncio.sleep(5) + +uasyncio.run(main()) \ No newline at end of file