diff --git a/main.py b/main.py index e94c87a..5e449ab 100644 --- a/main.py +++ b/main.py @@ -1,10 +1,12 @@ import machine import time +if machine.reset_cause() != machine.DEEPSLEEP_RESET: + print("Reset detected, waiting 10 seconds to give you time to interrupt...") + time.sleep(10) + +import urequests + adc = machine.ADC(machine.Pin(32)) adc.atten(machine.ADC.ATTN_11DB) -while (1): - n = int(adc.read()/64) - print("|" + "#"*n + " "*(64-n) + "|", end="\r") - time.sleep_ms(100) \ No newline at end of file diff --git a/sensor.py b/sensor.py new file mode 100644 index 0000000..1743b3d --- /dev/null +++ b/sensor.py @@ -0,0 +1,53 @@ +from micropython import const +import machine + +SENSOR_ADC = const(0) +SENSOR_I2C = const(1) +SENSOR_SPI = const(2) + + +class Sensor: + def __init__(name, type, **kwargs): + self.name = name + self.type = type + + # Different treatment depending on sensortype + if type == SENSOR_ADC: + #ADC is fairly simple + #Only a ADC-Pin is required + if "pin" not in kwargs.keys(): + raise ValueError("Sensortype requires a pin (ADC), but no 'pin'-argument was passed") + self.pin = kwargs["pin"] + + self.adc = machine.ADC(machine.Pin(self.pin)) + + # Optionally a attenuation parameter may be supplied + # otherwise the maximum attenuation (i.e. maximum range) is used + if "attenuation" in kwargs.keys(): + adc.atten(kwargs["attenuation"]) + else: + adc.atten(machine.ADC.ATTN_11DB) + + + if type == SENSOR_I2C: + if "sda" not in kwargs.keys(): + raise ValueError("Sensortype requires pins (I2C), but no 'sda'-argument was passed") + if "scl" not in kwargs.keys(): + raise ValueError("Sensortype requires pins (I2C), but no 'scl'-argument was passed") + if "handler" not in kwargs.keys(): + raise ValueError("Sensortype requires handler-method (I2C), but no 'handler'-argument was passed") + self.sda = kwargs["sda"] + self.scl = kwargs["scl"] + self.scl = kwargs["handler"] + + + # SPI isn't used yet + if type == SENSOR_SPI: + raise NotImplementedError("SPI is not yet implemented") + + + + # Read the sensor and return data ready for appending to the POST-request to influxdb + def read(): + if type == SENSOR_ADC: + return self.name + "=" + str(self.adc.read()) \ No newline at end of file diff --git a/settings.py b/settings.py new file mode 100644 index 0000000..77842ea --- /dev/null +++ b/settings.py @@ -0,0 +1,11 @@ +node_name = "node_mpt_01" + +wifi_ssid = "espnet" +wifi_psk = "esp32net" + +influx_token = "5TQvTkulmC6C_EIBE5objHDPROqdUjhCQbqA9pDL2V-D-MDMq8HXmC4azbapB-8O_8stypSGUCdmqpITHaosow==" +influx_bucket = "sensornodes" +influx_org = "none" +influx_url = "https://influx.krumel.moe/api/v2/write?org={org}&bucket={bucket}&precision=s".format(org=influx_org, bucket=influx_bucket) +influx_header = "Authoirzation: Token {}".format(influx_token) + diff --git a/urequests.py b/urequests.py new file mode 100644 index 0000000..279a9ca --- /dev/null +++ b/urequests.py @@ -0,0 +1,125 @@ +#from: https://raw.githubusercontent.com/micropython/micropython-lib/master/urequests/urequests.py +import usocket + +class Response: + + def __init__(self, f): + self.raw = f + self.encoding = "utf-8" + self._cached = None + + def close(self): + if self.raw: + self.raw.close() + self.raw = None + self._cached = None + + @property + def content(self): + if self._cached is None: + try: + self._cached = self.raw.read() + finally: + self.raw.close() + self.raw = None + return self._cached + + @property + def text(self): + return str(self.content, self.encoding) + + def json(self): + import ujson + return ujson.loads(self.content) + + +def request(method, url, data=None, json=None, headers={}, stream=None): + try: + proto, dummy, host, path = url.split("/", 3) + except ValueError: + proto, dummy, host = url.split("/", 2) + path = "" + if proto == "http:": + port = 80 + elif proto == "https:": + import ussl + port = 443 + else: + raise ValueError("Unsupported protocol: " + proto) + + if ":" in host: + host, port = host.split(":", 1) + port = int(port) + + ai = usocket.getaddrinfo(host, port, 0, usocket.SOCK_STREAM) + ai = ai[0] + + s = usocket.socket(ai[0], ai[1], ai[2]) + try: + s.connect(ai[-1]) + if proto == "https:": + s = ussl.wrap_socket(s, server_hostname=host) + s.write(b"%s /%s HTTP/1.0\r\n" % (method, path)) + if not "Host" in headers: + s.write(b"Host: %s\r\n" % host) + # Iterate over keys to avoid tuple alloc + for k in headers: + s.write(k) + s.write(b": ") + s.write(headers[k]) + s.write(b"\r\n") + if json is not None: + assert data is None + import ujson + data = ujson.dumps(json) + s.write(b"Content-Type: application/json\r\n") + if data: + s.write(b"Content-Length: %d\r\n" % len(data)) + s.write(b"\r\n") + if data: + s.write(data) + + l = s.readline() + #print(l) + l = l.split(None, 2) + status = int(l[1]) + reason = "" + if len(l) > 2: + reason = l[2].rstrip() + while True: + l = s.readline() + if not l or l == b"\r\n": + break + #print(l) + if l.startswith(b"Transfer-Encoding:"): + if b"chunked" in l: + raise ValueError("Unsupported " + l) + elif l.startswith(b"Location:") and not 200 <= status <= 299: + raise NotImplementedError("Redirects not yet supported") + except OSError: + s.close() + raise + + resp = Response(s) + resp.status_code = status + resp.reason = reason + return resp + + +def head(url, **kw): + return request("HEAD", url, **kw) + +def get(url, **kw): + return request("GET", url, **kw) + +def post(url, **kw): + return request("POST", url, **kw) + +def put(url, **kw): + return request("PUT", url, **kw) + +def patch(url, **kw): + return request("PATCH", url, **kw) + +def delete(url, **kw): + return request("DELETE", url, **kw)