micrOSDevToolKit 2.1.5__py3-none-any.whl → 2.26.1__py3-none-any.whl

micrOS/source/modules/LM_veml7700.py

@@ -0,0 +1,159 @@
+# Copyright (c) 2019 Joseph Hopfmüller
+# This module is a fork of Christophe Rousseaus module.
+# see: https://github.com/palouf34/veml7700.git
+
+from machine import SoftI2C, Pin
+from time import sleep
+from micropython import const
+from microIO import bind_pin, pinmap_search
+from Types import resolve
+
+# start const
+# default address
+addr = const(0x10)
+
+# Write registers
+als_conf_0 = const(0x00)
+als_WH = const(0x01)
+als_WL = const(0x02)
+pow_sav = const(0x03)
+
+# Read registers
+als = const(0x04)
+white = const(0x05)
+interrupt = const(0x06)
+
+# gain            0.125                    0.25                    1                        2                         integration time
+confValues = {25: {1 / 8: bytearray([0x00, 0x13]), 1 / 4: bytearray([0x00, 0x1B]), 1: bytearray([0x00, 0x01]),
+                   2: bytearray([0x00, 0x0B])},  # 25
+              50: {1 / 8: bytearray([0x00, 0x12]), 1 / 4: bytearray([0x00, 0x1A]), 1: bytearray([0x00, 0x02]),
+                   2: bytearray([0x00, 0x0A])},  # 50
+              100: {1 / 8: bytearray([0x00, 0x10]), 1 / 4: bytearray([0x00, 0x18]), 1: bytearray([0x00, 0x00]),
+                    2: bytearray([0x00, 0x08])},  # 100
+              200: {1 / 8: bytearray([0x40, 0x10]), 1 / 4: bytearray([0x40, 0x18]), 1: bytearray([0x40, 0x00]),
+                    2: bytearray([0x40, 0x08])},  # 200
+              400: {1 / 8: bytearray([0x80, 0x10]), 1 / 4: bytearray([0x80, 0x18]), 1: bytearray([0x80, 0x00]),
+                    2: bytearray([0x80, 0x08])},  # 400
+              800: {1 / 8: bytearray([0xC0, 0x10]), 1 / 4: bytearray([0xC0, 0x18]), 1: bytearray([0xC0, 0x00]),
+                    2: bytearray([0xC0, 0x08])}}  # 800
+
+# gain               0.125,  0.25,   1,      2       integration time
+gainValues = {25: {1 / 8: 1.8432, 1 / 4: 0.9216, 1: 0.2304, 2: 0.1152},  # 25
+              50: {1 / 8: 0.9216, 1 / 4: 0.4608, 1: 0.1152, 2: 0.0576},  # 50
+              100: {1 / 8: 0.4608, 1 / 4: 0.2304, 1: 0.0288, 2: 0.0144},  # 100
+              200: {1 / 8: 0.2304, 1 / 4: 0.1152, 1: 0.0288, 2: 0.0144},  # 200
+              400: {1 / 8: 0.1152, 1 / 4: 0.0576, 1: 0.0144, 2: 0.0072},  # 400
+              800: {1 / 8: 0.0876, 1 / 4: 0.0288, 1: 0.0072, 2: 0.0036}}  # 800
+
+# fin des constante
+
+# Reference data sheet Table 1 for configuration settings
+
+interrupt_high = bytearray([0x00, 0x00])  # Clear values
+# Reference data sheet Table 2 for High Threshold
+
+interrupt_low = bytearray([0x00, 0x00])  # Clear values
+# Reference data sheet Table 3 for Low Threshold
+
+power_save_mode = bytearray([0x00, 0x00])  # clear values
+
+
+# Reference data sheet Table 4 for Power Saving Modes
+
+
+class VEML7700:
+    INSTANCE = None
+
+    def __init__(self,
+                 address=addr,
+                 i2c=None,
+                 it=25,
+                 gain=1 / 8,
+                 **kwargs):
+
+        self.address = address
+        if i2c is None:
+            raise ValueError('An I2C object is required.')
+        self.i2c = i2c
+        VEML7700.INSTANCE = self
+
+        confValuesForIt = confValues.get(it)
+        gainValuesForIt = gainValues.get(it)
+        if confValuesForIt is not None and gainValuesForIt is not None:
+            confValueForGain = confValuesForIt.get(gain)
+            gainValueForGain = gainValuesForIt.get(gain)
+            if confValueForGain is not None and gainValueForGain is not None:
+                self.confValues = confValueForGain
+                self.gain = gainValueForGain
+            else:
+                raise ValueError('Wrong gain value. Use 1/8, 1/4, 1, 2')
+        else:
+            raise ValueError('Wrong integration time value. Use 25, 50, 100, 200, 400, 800')
+
+        self.init()
+
+    def init(self):
+
+        # load calibration data
+        # self.i2c.writeto_mem(self.address, als_conf_0, bytearray([0x00,0x13]) )
+        self.i2c.writeto_mem(self.address, als_conf_0, self.confValues)
+        self.i2c.writeto_mem(self.address, als_WH, interrupt_high)
+        self.i2c.writeto_mem(self.address, als_WL, interrupt_low)
+        self.i2c.writeto_mem(self.address, pow_sav, power_save_mode)
+
+    def detect(self):
+        """ Functions is  verified is  module has detecedself.
+
+        this function not implemented for this time
+        """
+        None
+
+    def read_lux(self):
+        """ Reads the data from the sensor and returns the data.
+
+            Returns:
+               the number of lux detect by this captor.
+        """
+        # The frequency to read the sensor should be set greater than
+        # the integration time (and the power saving delay if set).
+        # Reading at a faster frequency will not cause an error, but
+        # will result in reading the previous data
+
+        self.lux = bytearray(2)
+
+        sleep(.04)  # 40ms
+
+        self.i2c.readfrom_mem_into(self.address, als, self.lux)
+        self.lux = self.lux[0] + self.lux[1] * 256
+        self.lux = self.lux * self.gain
+        return (int(round(self.lux, 0)))
+
+
+def load():
+    """
+    VEML7700 Digital light intensity sensor
+    """
+    if VEML7700.INSTANCE is None:
+        i2c = SoftI2C(Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')))
+        VEML7700.INSTANCE = VEML7700(address=0x10, i2c=i2c, it=100, gain=1/8)
+    return VEML7700.INSTANCE
+
+
+def read_lux():
+    """Read LUX value"""
+    lux = load().read_lux()
+    return {"LUX": lux}
+
+
+def pinmap():
+    """
+    [i] micrOS LM naming convention
+    Shows logical pins - pin number(s) used by this Load module
+    - info which pins to use for this application
+    :return dict: pin name (str) - pin value (int) pairs
+    """
+    return pinmap_search(['i2c_scl', 'i2c_sda'])
+
+
+def help(widgets=False):
+    return resolve(('load', 'TEXTBOX read_lux', 'pinmap', '[info] Digital light intensity sensor'), widgets=widgets)

micrOS/source/modules/LM_web.py

@@ -0,0 +1,38 @@
+"""
+Web backend loader
+    - Dynamic application dashboard
+    - Fileserver
+"""
+
+from Common import web_endpoint, web_mounts
+
+
+def load(dashboard=True, fileserver:bool=False, fs_explore:bool=False):
+    """
+    Centralized Web Backend Services Loader
+    - Dynamic application dashboard
+    - Fileserver
+    :param dashboard:  bool - enable*/disable application dashboard
+    :param fileserver: bool - enable/disable* fileserver
+    :param fs_explore: bool - enable all shared web mounts: modules, data
+    """
+    endpoints = []
+    if dashboard:
+        web_endpoint('dashboard', 'dashboard.html')
+        endpoints.append("Dashboard initialized, endpoint: /dashboard")
+    if fileserver:
+        import LM_fileserver
+        endpoints.append(LM_fileserver.load())
+        endpoints.append(web_mounts(fs_explore, fs_explore, fs_explore))
+    return endpoints
+
+
+def help(widgets=False):
+    """
+    [i] micrOS LM naming convention - built-in help message
+    :return tuple:
+        (widgets=False) list of functions implemented by this application
+        (widgets=True) list of widget json for UI generation
+    """
+    return ('load dashboard=True fileserver=False fsdir=None fs_explore=False',
+            'help')

micrOS/source/urequests.py

@@ -1,103 +1,84 @@
-from usocket import socket, getaddrinfo
-from ussl import wrap_socket
+"""
+This module implements an optimized version of requests module
+for async and sync http get and post requests.
+
+Designed by Marcell Ban aka BxNxM GitHub
+"""
+
 from json import loads, dumps
-from Debug import errlog_add
+from usocket import socket, getaddrinfo
+try:
+    from ussl import wrap_socket    # Legacy micropython ssl usage (+simulator mode)
+except ImportError:
+    from ssl import wrap_socket     # From micropython 1.23...
+from Debug import syslog
+import uasyncio as asyncio
 
 
 ADDR_CACHE = {}
 
+#############################################
+#  micropython request - helper functions   #
+#############################################
 
-def request(method, url, data=None, json=None, headers=None, sock_size=256, jsonify=False):
+
+def _host_to_addr(host, port, force=False):
     """
-    Micropython syncronous HTTP request function for REST API handling
-    :param method: GET/POST
-    :param url: URL for REST API
-    :param data: string body (handle bare string as data for POST method)
-    :param json: json body (handle json as data for POST method)
-    :param headers: define headers
-    :param sock_size: socket buffer size (chuck size), default 256 byte (micropython defualt)
-    :param jsonify: convert response body to json
+    Resolve host name to IP address
+    and cache host address to avoid slow getaddrinfo
     """
+    addr = ADDR_CACHE.get(host, None)
+    if addr is None or force:
+        addr = getaddrinfo(host, port)[0][-1]
+        ADDR_CACHE[host] = addr
+    return addr
 
-    #############################################
-    # micropython request - internal functions  #
-    #############################################
-    def _chunked(_body):
-        decoded = bytearray()
-        while _body:
-            # Find the end of the chunk size line
-            line_end = _body.find(b"\r\n")
-            if line_end < 0:
-                break
 
-            # Extract the chunk size and convert to int
-            chunk_size_str = _body[:line_end]
-            try:
-                chunk_size = int(chunk_size_str, 16)
-            except ValueError as e:
-                chunk_size = 0
+def _chunked(_body):
+    decoded = bytearray()
+    while _body:
+        # Find the end of the chunk size line
+        line_end = _body.find(b"\r\n")
+        if line_end < 0:
+            break
 
-            # Check chunk size
-            if chunk_size == 0:
-                break
+        # Extract the chunk size and convert to int
+        chunk_size_str = _body[:line_end]
+        try:
+            chunk_size = int(chunk_size_str, 16)
+        except ValueError:
+            chunk_size = 0
 
-            # Add the chunk data to the decoded data
-            chunk_data = _body[line_end + 2: line_end + 2 + chunk_size]
-            decoded += chunk_data
+        # Check chunk size
+        if chunk_size == 0:
+            break
 
-            # Move to the next chunk
-            _body = _body[line_end + 4 + chunk_size:]
+        # Add the chunk data to the decoded data
+        chunk_data = _body[line_end + 2: line_end + 2 + chunk_size]
+        decoded += chunk_data
 
-            # Check for end of message marker again
-            if not _body.startswith(b"\r\n"):
-                break
-        return decoded
-
-    def _host_to_addr(force=False):
-        """
-        Cache host address to avoid getaddrinfo (slow)
-        """
-        nonlocal host, port
-        _addr = ADDR_CACHE.get(host, None)
-        if _addr is None or force:
-            _addr = getaddrinfo(host, port)[0][-1]
-            ADDR_CACHE[host] = _addr
-        return _addr
-
-    #############################################
-    #           micropython request main        #
-    #############################################
-
-    # [_parse_url] Parse HTTP(S) URL
-    headers = {} if headers is None else headers
+        # Move to the next chunk
+        _body = _body[line_end + 4 + chunk_size:]
+
+        # Check for end of message marker again
+        if not _body.startswith(b"\r\n"):
+            break
+    return decoded
+
+
+def _parse_url(url):
     # PARSE URL -> proto (http/https), host, path + SET PORT
     proto, _, host, path = url.split('/', 3)
-
     port = 443 if proto == 'https:' else 80
     # PARSE HOST - handle direct port number as input after :
     if ':' in host:
         host, port = host.split(':', 1)
         port = int(port)
+    return host, port, proto, path
 
-    # [1] CONNECT - create socket object
-    sock = socket()
-    sock.settimeout(3)
-    # [1.1] CONNECT - resolve IP by host
-    addr = _host_to_addr()
-    # [1.2] CONNECT - if https handle ssl
-    try:
-        sock.connect(addr)
-    except Exception:
-        # Refresh host address & reconnect
-        addr = _host_to_addr(force=True)
-        sock.connect(addr)
-
-    try:
-        sock = wrap_socket(sock) if proto == 'https:' else sock
-    except Exception as e:
-        errlog_add(f'[ERR] https soc-wrap: {e}')
 
-    # [_build_request] Create request (body, headers)
+def _build_request(host, method, path, headers, data=None, json=None):
+    # Create request (body, headers)
     body = None
     if data:
         body = data.encode('utf-8')
@@ -116,6 +97,60 @@ def request(method, url, data=None, json=None, headers=None, sock_size=256, json
     http_request = '\r\n'.join(lines) + '\r\n\r\n'
     if body:
         http_request += body.decode('utf-8')
+    return http_request
+
+
+def _parse_response(response):
+    # Parse response - get body
+    headers, body = response.split(b'\r\n\r\n', 1)
+    status_code = int(headers.split(b' ')[1])
+    headers = dict(h.split(b': ') for h in headers.split(b'\r\n')[1:])
+    if headers.get(b'Transfer-Encoding', b'') == b'chunked':
+        body = _chunked(body)
+    else:
+        body = body.decode('utf-8')
+    return status_code, body
+
+
+#############################################
+#          micropython HTTP request         #
+#############################################
+
+def request(method:str, url:str, data:str=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
+    """
+    Micropython syncronous HTTP request function for REST API handling
+    :param method: GET/POST
+    :param url: URL for REST API
+    :param data: string body (handle bare string as data for POST method)
+    :param json: json body (handle json as data for POST method)
+    :param headers: define headers
+    :param sock_size: socket buffer size (chuck size), default 256 byte (micropython defualt)
+    :param jsonify: convert response body to json
+    """
+
+    # Parse HTTP(S) URL and headers
+    headers = {} if headers is None else headers
+    host, port, proto, path = _parse_url(url)
+    addr = _host_to_addr(host, port)
+
+    # [1] CONNECT - create socket object
+    sock = socket()
+    sock.settimeout(3)
+    # [1.1] CONNECT - if https handle ssl
+    try:
+        sock.connect(addr)
+    except Exception:
+        # Refresh host address & reconnect
+        addr = _host_to_addr(host, port, force=True)
+        sock.connect(addr)
+
+    try:
+        sock = wrap_socket(sock) if proto == 'https:' else sock
+    except Exception as e:
+        syslog(f'[ERR] https soc-wrap: {e}')
+
+    # [1] BUILD REQUEST
+    http_request = _build_request(host, method, path, headers, data, json)
 
     # [2] SEND REQUEST
     if proto == 'https:':
@@ -135,32 +170,94 @@ def request(method, url, data=None, json=None, headers=None, sock_size=256, json
         response += data
     sock.close()
 
-    # [_parse_response] Parse response - get body
-    headers, body = response.split(b'\r\n\r\n', 1)
-    status_code = int(headers.split(b' ')[1])
-    headers = dict(h.split(b': ') for h in headers.split(b'\r\n')[1:])
-    if headers.get(b'Transfer-Encoding', b'') == b'chunked':
-        body = _chunked(body)
-    else:
-        body = body.decode('utf-8')
+    # [4] PARSE RESPONSE
+    status_code, body = _parse_response(response)
 
-    # Return status code, headers and body (text or jsons)
-    return status_code, loads(body) if jsonify else body
+    # Return status code, body (text or json)
+    return status_code, loads(body) if jsonify and status_code == 200 else body
 
 
 #############################################
-#      Implement http get/post functions    #
+#       async micropython HTTP request      #
 #############################################
 
+async def arequest(method:str, url:str, data:str=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
+    """
+    Micropython asynchronous HTTP request function for REST API handling
+    :param method: GET/POST
+    :param url: URL for REST API
+    :param data: string body (handle bare string as data for POST method)
+    :param json: json body (handle json as data for POST method)
+    :param headers: define headers
+    :param sock_size: socket buffer size (chunk size), default 256 bytes (micropython default)
+    :param jsonify: convert response body to json
+    """
+    headers = {} if headers is None else headers
+    host, port, proto, path = _parse_url(url)
+    addr = _host_to_addr(host, port)
+    reader, writer = None, None
+
+    # Open a connection
+    try:
+        reader, writer = await asyncio.open_connection(addr[0], port, ssl=(proto == 'https:'))
+    except Exception as e:
+        # Refresh host address & reconnect
+        if "EHOSTUNREACH" in str(e):
+            addr = _host_to_addr(host, port, force=True)
+            reader, writer = await asyncio.open_connection(addr[0], port, ssl=(proto == 'https:'))
+        else:
+            syslog(f"[ERR] arequest connection: {e}")
+
+    # Send request + Wait for the response
+    try:
+        # Build the HTTP request
+        http_request = _build_request(host, method, path, headers, data, json)
+
+        # Send the request
+        writer.write(http_request.encode('utf-8'))
+        await writer.drain()
+
+        # Receive response
+        response = b''
+        while True:
+            chunk = await reader.read(sock_size)
+            if not chunk:
+                break
+            response += chunk
+
+        # Parse response
+        status_code, body = _parse_response(response)
+    except Exception as e:
+        status_code = 500
+        # https://github.com/micropython/micropython/blob/8785645a952c03315dbf93667b5f7c7eec49762f/cc3200/simplelink/include/device.h
+        if "-104" == str(e):
+            body = "[WARN] arequest: ASSOC_REJECT"
+        elif "ECONNABORTED" in str(e):
+            body = f"[WARN] arequest: {e}"
+        else:
+            body = f"[ERR] arequest: {e}"
+        syslog(body)
+    finally:
+        if writer:
+            writer.close()
+            await writer.wait_closed()
+    return status_code, loads(body) if jsonify and status_code == 200 else body
+
+
+#############################################
+#      Implement http get/post functions    #
+#############################################
 
-def get(url, headers={}, sock_size=256, jsonify=False):
+def get(url:str, headers:dict=None, sock_size=256, jsonify=False):
     """
     GENERIC HTTP GET FUNCTION
     """
+    if headers is None:
+        headers = {}
     return request('GET', url, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
-def post(url, data=None, json=None, headers={}, sock_size=256, jsonify=False):
+def post(url:str, data=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
     """
     GENERIC HTTP POST FUNCTION
     :param data: string body (handle bare string as data for POST method)
@@ -169,7 +266,23 @@ def post(url, data=None, json=None, headers={}, sock_size=256, jsonify=False):
     return request('POST', url, data=data, json=json, headers=headers, sock_size=sock_size, jsonify=jsonify)
 
 
-def host_cache():
+async def aget(url:str, headers:dict=None, sock_size=256, jsonify=False):
+    """
+    GENERIC ASYNC HTTP GET FUNCTION
+    """
+    return await arequest('GET', url, headers=headers, sock_size=sock_size, jsonify=jsonify)
+
+
+async def apost(url, data=None, json=None, headers:dict=None, sock_size=256, jsonify=False):
+    """
+    GENERIC ASYNC HTTP POST FUNCTION
+    :param data: string body (handle bare string as data for POST method)
+    :param json: json body (handle json as data for POST method)
+    """
+    return await arequest('POST', url, data=data, json=json, headers=headers, sock_size=sock_size, jsonify=jsonify)
+
+
+def host_cache() -> dict:
     """
     Return address cache
     """

{toolkit/workspace/precompiled → micrOS/source/web}/dashboard.html

@@ -31,14 +31,18 @@
             transition: border-color 0.3s ease; /* Smooth transition for border color */
         }
     </style>
-    <script src="uapi.js" defer></script>
-    <script src="uwidgets.js" defer></script>
-    <script src="udashboard.js" defer></script>
+    <script src="uapi.js" ></script>
+    <script src="uwidgets.js" ></script>
+    <script src="uwidgets_pro.js" ></script>
+    <script src="udashboard.js" ></script>
 </head>
 <body>
     <h1> micrOS dashboard </h1>
+    <div id="restInfo">
+      <div id="restInfoHeader"></div>
+    </div>
     <!-- Container for the dynamically generated list -->
-    <ul id="dynamicContent"></ul>
+    <section id="widgets-section"></section>
     <br><br><br>
     <button id="toggleDebugSection">console</button>
     <div id="debugSection" style="display: none;">
@@ -53,6 +57,7 @@
     <script>
         document.addEventListener("DOMContentLoaded", function() {
             // Init basic info from board after DOM is fully loaded
+            restInfo(showPages=false);
 
             // INIT DASHBOARD (load active modules -> build page)
             DynamicWidgetLoad();