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

micrOS/source/{LM_stepper.py → modules/LM_stepper.py}

@@ -2,7 +2,7 @@
 
 from utime import sleep_ms
 from machine import Pin
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
 STEPPER_INST = None
 
 
@@ -30,10 +30,10 @@ class StepperULN2003:
                          [1, 0, 0, 1]]
             self.delay = 2
         # Init stepper pins
-        self.pin1 = Pin(physical_pin('stppr_1'), Pin.OUT)
-        self.pin2 = Pin(physical_pin('stppr_2'), Pin.OUT)
-        self.pin3 = Pin(physical_pin('stppr_3'), Pin.OUT)
-        self.pin4 = Pin(physical_pin('stppr_4'), Pin.OUT)
+        self.pin1 = Pin(bind_pin('stppr_1'), Pin.OUT)
+        self.pin2 = Pin(bind_pin('stppr_2'), Pin.OUT)
+        self.pin3 = Pin(bind_pin('stppr_3'), Pin.OUT)
+        self.pin4 = Pin(bind_pin('stppr_4'), Pin.OUT)
         # Initialize all value to 0 - "OFF"
         self.reset()
 
@@ -86,7 +86,7 @@ def __init_stepper(mode='HALF'):
     return STEPPER_INST
 
 
-def load_n_init(mode="HALF"):
+def load(mode="HALF"):
     """
     Init stepper motor module
     :param mode: step mode: HALF/FULL
@@ -141,7 +141,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['stppr_1', 'stppr_2', 'stppr_3', 'stppr_4'])
+    return pinmap_search(['stppr_1', 'stppr_2', 'stppr_3', 'stppr_4'])
 
 
 def help(widgets=False):
@@ -154,5 +154,5 @@ def help(widgets=False):
     return 'angle dg=+/-360 speed=<ms>',\
            'step st=+/-2 speed=<ms>',\
            'standby',\
-           'load_n_init mode=<"HALF"/"FULL">', 'pinmap'\
+           'load mode=<"HALF"/"FULL">', 'pinmap'\
            'Info: stepper: 28byj-48 driver: ULN2003'

micrOS/source/{LM_switch.py → modules/LM_switch.py}

@@ -1,5 +1,7 @@
 from machine import Pin
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
+from Common import data_dir
+from Types import resolve
 
 #########################################
 #           DIGITAL IO SWITCH           #
@@ -7,6 +9,7 @@ from microIO import physical_pin, pinmap_dump
 __SWITCH_OBJ = [None, None, None, None]
 __PERSISTENT_CACHE = False
 __SWITCH_STATE = [0, 0, 0, 0]
+__FILE_CACHE = data_dir('switch.cache')
 
 
 #########################################
@@ -15,7 +18,7 @@ __SWITCH_STATE = [0, 0, 0, 0]
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
@@ -24,12 +27,12 @@ def __persistent_cache_manager(mode):
     global __SWITCH_STATE
     if mode == 's':
         # SAVE CACHE
-        with open('switch.pds', 'w') as f:
+        with open(__FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in __SWITCH_STATE]))
         return
     try:
         # RESTORE CACHE
-        with open('switch.pds', 'r') as f:
+        with open(__FILE_CACHE, 'r') as f:
             __SWITCH_STATE = [int(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -49,11 +52,11 @@ def __init_switches_state(state=None, ch_init=None):
         set_state4(state)
 
 
-def load_n_init(cache=None, ch_init=None):
+def load(cache=None, ch_init=None):
     """
     Initiate switch module (4 switch pack)
     :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
+    - Load .cache (state machine cache) for this load module
     - Apply loaded states to gpio pins (boot function)
     :return str: Cache state
     """
@@ -81,7 +84,7 @@ def load_n_init(cache=None, ch_init=None):
 
 def __switch_init():
     if __SWITCH_OBJ[0] is None:
-        __SWITCH_OBJ[0] = Pin(physical_pin('switch_1'), Pin.OUT)
+        __SWITCH_OBJ[0] = Pin(bind_pin('switch_1'), Pin.OUT)
     return __SWITCH_OBJ[0]
 
 
@@ -117,7 +120,7 @@ def toggle():
 
 def __switch2_init():
     if __SWITCH_OBJ[1] is None:
-        __SWITCH_OBJ[1] = Pin(physical_pin('switch_2'), Pin.OUT)
+        __SWITCH_OBJ[1] = Pin(bind_pin('switch_2'), Pin.OUT)
     return __SWITCH_OBJ[1]
 
 
@@ -152,7 +155,7 @@ def toggle2():
 
 def __switch3_init():
     if __SWITCH_OBJ[2] is None:
-        __SWITCH_OBJ[2] = Pin(physical_pin('switch_3'), Pin.OUT)
+        __SWITCH_OBJ[2] = Pin(bind_pin('switch_3'), Pin.OUT)
     return __SWITCH_OBJ[2]
 
 
@@ -187,7 +190,7 @@ def toggle3():
 
 def __switch4_init():
     if __SWITCH_OBJ[3] is None:
-        __SWITCH_OBJ[3] = Pin(physical_pin('switch_4'), Pin.OUT)
+        __SWITCH_OBJ[3] = Pin(bind_pin('switch_4'), Pin.OUT)
     return __SWITCH_OBJ[3]
 
 
@@ -250,7 +253,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['switch_1', 'switch_2', 'switch_3', 'switch_4'])
+    return pinmap_search(['switch_1', 'switch_2', 'switch_3', 'switch_4'])
 
 
 def help(widgets=False):
@@ -260,10 +263,10 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'set_state state=<0,1>', 'toggle', \
-           'set_state2 state=<0,1>', 'toggle2', \
-           'set_state3 state=<0,1>', 'toggle3', \
-           'set_state4 state=<0,1>', 'toggle4', \
-           'load_n_init cache=None<True/False> ch_init=[1,2,3,4]',\
-           'status',\
-           'pinmap'
+    return resolve(('set_state state=<0,1>', 'BUTTON toggle',
+                             'set_state2 state=<0,1>', 'BUTTON toggle2',
+                             'set_state3 state=<0,1>', 'BUTTON toggle3',
+                             'set_state4 state=<0,1>', 'BUTTON toggle4',
+                             'load cache=None<True/False> ch_init=[1,2,3,4]',
+                             'status',
+                             'pinmap'), widgets=widgets)

micrOS/source/{LM_system.py → modules/LM_system.py}

@@ -1,9 +1,13 @@
-from os import statvfs, getcwd
+from uos import statvfs, getcwd, uname
 from utime import localtime
-from Common import socket_stream
-from Network import get_mac
+from network import WLAN, STA_IF, AP_IF
+from binascii import hexlify
+from Common import socket_stream, console
+from Network import get_mac, ifconfig as network_config
 from Time import ntp_time, set_time, uptime
 from Tasks import Manager
+from Types import resolve
+from Notify import Notify
 
 try:
     from gc import mem_free, mem_alloc, collect
@@ -51,13 +55,12 @@ def info():
     - cpu clock, ram, free fs, upython, board, mac addr, uptime
     """
     from machine import freq
-    from os import uname
 
     buffer = top()
     buffer.update({'CPU clock [MHz]': int(freq() * 0.0000001), 'upython': uname()[3],
               'board': uname()[4], 'uptime': uptime()})
     try:
-        buffer['mac'] = get_mac()
+        buffer['mac'] = hexlify(get_mac(), ':').decode()
     except:
         buffer['mac'] = 'n/a'
     return buffer
@@ -79,6 +82,7 @@ def heartbeat():
     """
     Test function for built-in led blinking and test reply message
     """
+    console("<3 heartbeat <3")
     return "<3 heartbeat <3"
 
 
@@ -120,18 +124,18 @@ def sun(refresh=False):
     return Sun.TIME
 
 
-def setclock(year, month, mday, hour, min, sec):
+def setclock(year, month, mday, hour, minute, sec):
     """
     Set Localtime + RTC Clock manually
     :param year
     :param month
     :param mday
     :param hour
-    :param min
+    :param minute
     :param sec
     :return: localtime
     """
-    set_time(year, month, mday, hour, min, sec)
+    set_time(year, month, mday, hour, minute, sec)
     return localtime()
 
 
@@ -139,78 +143,109 @@ def rssi():
     """
     Show Wifi RSSI - wifi strength
     """
-    from network import WLAN, STA_IF
-    value = WLAN(STA_IF).status('rssi')
-    if value > -67:
-        return {'Amazing': value}
-    if value > -70:
-        return {'VeryGood': value}
-    if value > -80:
-        return {'Okay': value}
-    if value > -90:
-        return {'NotGood': value}
-    return {'Unusable': value}
-
-
-def pinmap(key='builtin'):
+    if ifconfig()[0] == "STA":
+        value = WLAN(STA_IF).status('rssi')
+        if value > -67:
+            return {'Amazing': value}
+        if value > -70:
+            return {'VeryGood': value}
+        if value > -80:
+            return {'Okay': value}
+        if value > -90:
+            return {'NotGood': value}
+        return {'Unusable': value}
+    return {'Unavailable': -90}
+
+
+def list_stations():
+    """
+    AccessPoint mode "router"
+    - list connected devices
+    """
+    if ifconfig()[0] == "AP":
+        ap = WLAN(AP_IF)
+        stations = ap.status('stations')
+        connected_devices = []
+        for sta in stations:
+            mac_address, mac_rssi = '', ''
+            if len(sta) > 0:
+                mac_bytes = sta[0]
+                mac_address = hexlify(mac_bytes, ':').decode()
+            elif len(sta) > 1:
+                mac_rssi = sta(1)
+            connected_devices.append((mac_address, mac_rssi))
+        return connected_devices
+    return [("NoAP", '')]
+
+
+def pinmap(keys:str=None) -> dict:
     """
     Get Logical pin by key runtime
-    :param key str: logical pin name to resolve
+    :param keys: logical pin name or names to resolve
+        example: 'builtin irq1 irq2 irq3 irq4'
     :return dict: key map
     """
-    from microIO import pinmap_dump, get_pinmap
-    map = get_pinmap()
-    map[key] = pinmap_dump(key)[key]
-    return map
+    from microIO import pinmap_search, pinmap_info
+    if keys is None:
+        map = pinmap_info(show_all=True)                 # map, booked, custom, known_maps
+        return map
+    keys = keys.replace(',', '').split()
+    return pinmap_search(keys)
+
 
 @socket_stream
-def alarms(clean=False, test=False, msgobj=None):
+def alarms(clean=False, msgobj=None):
     """
     Show micrOS alarms - system error list
     :param clean bool: clean alarms, default: False
-    :param test bool: create test alarms, set True
     :return dict: verdict
     """
-    from Debug import errlog_get, errlog_add, errlog_clean
-    if test:
-        errlog_add('[ERR] TeSt ErRoR')
+    from Logger import log_clean, syslog
     if clean:
-        errlog_clean(msgobj=msgobj)
-    errcnt = errlog_get(msgobj=msgobj)
+        log_clean(msgobj=msgobj)
+    errcnt = -1 if syslog is None else syslog(msgobj=msgobj)
     return {'NOK alarm': errcnt} if errcnt > 0 else {'OK alarm': errcnt}
 
 
-def dat_dump():
+def ifconfig():
     """
-    Generic .dat file dump
-    - logged data from LMs
+    Show network ifconfig
     """
-    from os import listdir
-    dats = (f for f in listdir() if f.endswith('.dat'))
-    out = {}
-    for dat in dats:
-        with open(dat, 'r') as f:
-            out[dat] = f.read()
-    return out
+    return network_config()
 
 
-def ifconfig():
+def hosts():
     """
-    Show network ifconfig
+    Dump cached hosts
+    - urequests (only memory cache)
+    - intercon connection cache
     """
-    from Network import ifconfig
-    return ifconfig()
+    from urequests import host_cache
+    from InterConnect import host_cache as ihost_cache
+    return {"urequests": host_cache(), "intercon":  ihost_cache()}
 
 
-def urequests_host_cache():
+def notifications(enable=None):
     """
-    Debug function for urequests address caching
-    - returns all known http(s) host addresses
-    - cache only in memory
+    Global notifications control for micrOS
+    :param enable: True: Enable notifications / False: Disable notifications
+    return: show state verdict and available notification handlers
     """
-    from urequests import host_cache
-    return host_cache()
+    return Notify.notifications(state=enable)
 
+def notify(msg, *args, **kwargs):
+    """
+    Send notification over registered notification handlers
+    :param msg: notification message
+    :param channels (optional): select communication interface(s) by class name
+       e.g. "Telegram", "MQTT" or an iterable of these.
+       If omitted or empty, sends over all available channels.
+    :param *: optional interface dependent options (topic, chat_id, etc...)
+    Control with:
+        system notifications enable=True
+        system notifications enable=False
+    """
+    return Notify.notify(msg, *args, **kwargs)
 
 #######################
 # LM helper functions #
@@ -223,8 +258,10 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'info', 'top', 'gclean', 'heartbeat', 'clock',\
-           'setclock year month mday hour min sec',\
-           'ntp', 'rssi', 'pinmap key="dhtpin"/None', 'alarms clean=False',\
-           'sun refresh=False', 'ifconfig', 'memory_usage',\
-           'disk_usage', 'dat_dump', 'urequests_host_cache'
+    return resolve(('info', 'TEXTBOX top', 'gclean', 'heartbeat', 'clock',
+                    'setclock year month mday hour minute sec',
+                    'ntp', 'rssi', 'list_stations', 'pinmap key="builtin"', 'alarms clean=False',
+                    'notifications enable=<None,True,False>',
+                    'notify "msg" *',
+                    'sun refresh=False', 'ifconfig', 'memory_usage',
+                    'disk_usage', 'hosts'), widgets=widgets)

micrOS/source/modules/LM_tcs3472.py

@@ -0,0 +1,187 @@
+"""
+A MicroPython library for the TCS3472 light sensing chip
+https://github.com/tti0/tcs3472-micropython
+
+Copyright (c) 2021 tti0
+Licensed under the MIT License
+"""
+
+from struct import unpack
+from time import sleep
+from machine import I2C, Pin, PWM
+from microIO import bind_pin, pinmap_search
+from Types import resolve
+
+from LM_neopixel import load as neo_load, color as neo_color, toggle as neo_toggle    # local neopixel light indicator
+from LM_cluster import run as cluster_run                                             # DEMO: neomatrix cluster
+
+CURRENT_ANIMATION_INDEX = 0                                                           # DEMO: neomatrix cluster animation
+
+class TCS3472:
+    INSTANCE = None
+
+    def __init__(self, address=0x29, led_pin=None):
+        self._bus = I2C(sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl')))
+        self._i2c_address = address
+        self._bus.writeto(self._i2c_address, b'\x80\x03')
+        self._bus.writeto(self._i2c_address, b'\x81\x2b')
+        self.led = PWM(Pin(bind_pin('led', led_pin), Pin.OUT), freq=20480)
+        self.led_brightness = 20
+        TCS3472.INSTANCE = self
+
+    def scaled(self, saturation=1.5):
+        """
+        Normalize by strongest color, then adjust saturation.
+        saturation = 1.0 -> normal
+        saturation > 1.0 -> more vibrant
+        saturation < 1.0 -> more pastel
+        """
+        _, r, g, b = self.raw()
+        m = max(r, g, b)
+        if m == 0:
+            return 0.0, 0.0, 0.0
+
+        # Normalize by strongest channel
+        r, g, b = r / m, g / m, b / m
+
+        # Grayscale = average of channels
+        gray = (r + g + b) / 3
+
+        # Interpolate between gray and color
+        r = gray + (r - gray) * saturation
+        g = gray + (g - gray) * saturation
+        b = gray + (b - gray) * saturation
+
+        # Clamp to 0..1
+        return max(0, min(1, r)), max(0, min(1, g)), max(0, min(1, b))
+
+    def rgb(self):
+        return tuple(int(x * 255) for x in self.scaled())
+
+    def light(self):
+        return self.raw()[0]
+
+    def brightness(self, level=65.535):
+        return int((self.light() / level))
+
+    def valid(self):
+        self._bus.writeto(self._i2c_address, b'\x93')
+        return self._bus.readfrom(self._i2c_address, 1)[0] & 1
+
+    def raw(self):
+        self._bus.writeto(self._i2c_address, b'\xb4')
+        return unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
+
+
+############################ Exposed functions ############################
+
+def load(led_pin=20):
+    """
+    Load the TCS3472 Color sensor instance.
+    """
+    if TCS3472.INSTANCE is None:
+        TCS3472(led_pin=led_pin)
+        neo_load(ledcnt=1)
+        led(False)
+    return TCS3472.INSTANCE
+
+
+def pinmap():
+    """
+    Show used pin mapping for this module.
+    """
+    return pinmap_search(['i2c_scl', 'i2c_sda', 'led'])
+
+
+def measure():
+    """
+    MEASURE sensor
+    """
+    sensor = load()
+    measurement = {"rgb": sensor.rgb(), "light": sensor.light(), "brightness": sensor.brightness()}
+    return measurement
+
+
+def led(state:bool=None, br:int=None):
+    """
+    SENSOR LED toggle
+    :param state: None-automatic, True-ON, False-OFF
+    :param br: brightness 0-100
+    """
+    def _set_duty(_br):
+        _br = sensor.led_brightness if _br is None else _br
+        sensor.led.duty(int(_br * 10))
+        if _br != 0:
+            sensor.led_brightness = _br
+
+    sensor = load()
+    if state is None:
+        # INVERT STATE
+        led_current_state = sensor.led.duty() > 0
+        if led_current_state:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+        else:
+            _set_duty(br)
+            neo_toggle(True)
+    else:
+        # SET STATE: ON/OFF
+        if state:
+            _set_duty(br)
+            neo_toggle(True)
+        else:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+    return f"LED on, {sensor.led_brightness}%" if sensor.led.duty()>0 else f"LED off"
+
+
+def indicator(br=5):
+    """
+    Color indicator Neopixel LED update
+    :param br: brightness 0-100
+    """
+    r, g, b = measure()['rgb']
+    br = float(br / 100)
+    _r, _g, _b = int(r*br), int(g*br), int(b*br)
+    neo_color(_r, _g, _b, smooth=False)
+    return r, g, b
+
+
+def neomatrix_update():
+    """
+    DEMO - Send color codes for all neomatrix devices over espnow cluster
+    """
+    r, g, b = indicator()
+    command = f"neomatrix color_fill {r} {g} {b}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
+
+
+def neomatrix_animation():
+    """
+    DEMO - Set random animation on neomatrix espnow cluster
+    """
+    global CURRENT_ANIMATION_INDEX
+    animations = ('spiral', 'snake', 'noise')
+
+    next_animation = CURRENT_ANIMATION_INDEX + 1
+    CURRENT_ANIMATION_INDEX = 0 if next_animation >= len(animations) else next_animation
+    command = f"neomatrix {animations[CURRENT_ANIMATION_INDEX]}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
+
+
+def help(widgets=False):
+    """
+    TCS3472 Color sensor
+    """
+    return resolve(('load led_pin=20',
+                    'TEXTBOX measure',
+                    'BUTTON led state=<True,False>',
+                    'SLIDER led state=True br=<0-100-5>',
+                    'indicator br=<0-100>',
+                    'BUTTON neomatrix_update',
+                    'BUTTON neomatrix_animation',
+                    'pinmap'), widgets=widgets)