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

micrOS/source/LM_neoeffects.py

@@ -1,327 +0,0 @@
-from LM_neopixel import load_n_init, segment, Data, status
-from LM_neopixel import pinmap as pm
-from random import randint
-
-
-#################################
-#  NEOPIXEL EFFECT DRAWER CLASS #
-#################################
-
-class DrawEffect:
-    __instance = None
-
-    def __new__(cls, pixcnt=24):
-        if DrawEffect.__instance is None:
-            # SocketServer singleton properties
-            DrawEffect.__instance = super().__new__(cls)
-            DrawEffect.__instance.pix_cnt = None
-            DrawEffect.__instance.index_offset = 0
-            DrawEffect.__instance.color_wheel = 0
-            DrawEffect.__instance.__init_effect(pixcnt)
-            DrawEffect.__instance.offset_gen = None
-            DrawEffect.__instance.auto_shift = False
-        return DrawEffect.__instance
-
-    def __init_effect(cls, ledcnt):
-        """
-        Set neopixel object & store pixel cnt
-        """
-        if Data.NEOPIXEL_OBJ is None:
-            load_n_init(ledcnt=ledcnt)
-            cls.pix_cnt = Data.NEOPIXEL_OBJ.n
-        if cls.pix_cnt is None:
-            cls.pix_cnt = Data.NEOPIXEL_OBJ.n
-        return cls.pix_cnt
-
-    def __offset(cls, shift):
-        def _gen():
-            while True:
-                if cls.auto_shift:
-                    # Step rotation cycle - shift True
-                    cls.index_offset += 1
-                    if cls.index_offset > cls.pix_cnt - 1:
-                        cls.index_offset = 0
-                for k in range(cls.index_offset, cls.pix_cnt):
-                    yield k
-                for k in range(0, cls.index_offset):
-                    yield k
-        cls.auto_shift = shift
-        if cls.offset_gen is None:
-            cls.offset_gen = _gen()
-        return cls.offset_gen
-
-    def draw(cls, iterable, shift=False):
-        """
-        DRAW GENERATED COLORS (RGB)
-        HELPER FUNCTION with auto shift (offset) sub function
-        :param iterable: Colors generator object / iterable
-        :param shift: automatic color map rotation
-        :return: None
-        """
-        offset_gen = cls.__offset(shift=shift)
-        r, g, b, i = 0, 0, 0, 0
-        for r, g, b in iterable:
-            # Handle index offset - rotate effect
-            i = next(offset_gen)
-            # Write data to neopixel - write / segment :)
-            segment(int(r), int(g), int(b), s=i, cache=False, write=False)
-        segment(int(r), int(g), int(b), s=i, cache=False, write=True)
-        return True
-
-
-def __color_input(r, g, b):
-    _r, _g, _b, _ = Data.DCACHE
-    r = _r if r is None else r
-    g = _g if g is None else g
-    b = _b if b is None else b
-    return r, g, b
-
-
-#################################
-#         DEFINE EFFECTS        #
-#################################
-
-def meteor(r=None, g=None, b=None, shift=True, ledcnt=24):
-    """
-    Meteor effect
-    :param r int: red value 0-1000
-    :param g int: green value 0-1000
-    :param b int: blue value 0-1000
-    :param shift bool: automatic effect shifting
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
-    :return str: verdict
-    """
-    def __effect(r, g, b, pixel):
-        """
-        Describe one full length color map
-        :param r: red target color
-        :param g: green target color
-        :param b: blue target color
-        :param pixel: number of led segments
-        :return: yield tuple with r,g,b
-        """
-        step = float(0.9 / pixel)
-        for k in range(0, pixel):
-            fade = (k+1) * step
-            data = round(r * fade), round(g * fade), round(b * fade)
-            yield data
-
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-
-    # Init custom params
-    effect = DrawEffect(pixcnt=ledcnt)
-    # Create effect data
-    cgen = __effect(r, g, b, effect.pix_cnt)
-    # Draw effect data
-    effect.draw(cgen, shift=shift)
-    return 'Meteor R{}:G{}:B{} N:{}'.format(r, g, b, effect.pix_cnt)
-
-
-def cycle(r=None, g=None, b=None, shift=True, ledcnt=24):
-    """
-    Cycle effect
-    :param r int: red value 0-1000
-    :param g int: green value 0-1000
-    :param b int: blue value 0-1000
-    :param shift bool: automatic effect shifting
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
-    :return str: verdict
-    """
-    def __effect(r, g, b, pixel):
-        """
-        Describe one full length color map
-        :param r: red target color
-        :param g: green target color
-        :param b: blue target color
-        :param pixel: number of led segments
-        :return: yield tuple with r,g,b
-        """
-        lightrgb = round(r*0.1), round(g*0.1), round(b*0.1)
-        yield lightrgb
-        yield r, g, b
-        yield lightrgb
-        for i in range(3, pixel):
-            yield 0, 0, 0
-
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-
-    effect = DrawEffect(pixcnt=ledcnt)
-    cgen = __effect(r, g, b, effect.pix_cnt)
-    effect.draw(cgen, shift=shift)
-    return 'Cycle R{}:G{}:B{} N:{}'.format(r, g, b, effect.pix_cnt)
-
-
-def rainbow(step=1, br=50, ledcnt=24):
-    """
-    Rainbow effect
-    :param step int: color weel resolution in step (default: 1)
-    :param br int: brightness in percentage
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
-    :return str: verdict
-    """
-    def __wheel(pos):
-        # Input a value 0 to 255 to get a color value.
-        # The colours are a transition r - g - b - back to r.
-        if pos < 0 or pos > 255:
-            return 0, 0, 0
-        if pos < 85:
-            return 255 - pos * 3, pos * 3, 0
-        if pos < 170:
-            pos -= 85
-            return 0, 255 - pos * 3, pos * 3
-        pos -= 170
-        return pos * 3, 0, 255 - pos * 3
-
-    def __effect(cnt, step, br):
-        """
-        :param cnt: led segment count
-        :param br: max brightness 0-100%
-        :param step: step size
-        """
-        cw = DrawEffect().color_wheel
-        DrawEffect().color_wheel = 0 if cw >= 255 else cw+step
-        for i in range(0, cnt):
-            rc_index = (i * 256 // cnt) + DrawEffect().color_wheel
-            r, g, b = __wheel(rc_index & 255)
-            yield round(r*br*0.01), round(g*br*0.01), round(b*br*0.01)
-
-    effect = DrawEffect(pixcnt=ledcnt)
-    cgen = __effect(effect.pix_cnt, step=step, br=br)
-    effect.draw(cgen, shift=True)
-    return 'Rainbow'
-
-
-def shader(size=6, offset=0, shift=False, ledcnt=24):
-    """
-    Shader for ring lamp
-    :param size int: shader size (disabled LEDs)
-    :param offset int: rotate shader 0-(ledcnt-1)
-    :param shift bool: auto shift shader effect (False)
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
-    :return str: verdict
-    """
-    def __effect(size, offset, pixcnt):
-        # Conditional value load - with neopixel cache
-        r, g, b, _ = Data.DCACHE
-        # calculate 0->24 range
-        _slice1 = pixcnt if size + offset > pixcnt else size + offset
-        # calculate 24->0-> range (overflow)
-        _slice2 = size + offset - pixcnt if size + offset > pixcnt else 0
-        for i in range(0, pixcnt):
-            if offset < i < _slice1:
-                yield 0, 0, 0
-            elif 0 <= i < _slice2:
-                yield 0, 0, 0
-            else:
-                yield r, g, b
-
-    # Init custom params
-    effect = DrawEffect(pixcnt=ledcnt)
-    # Create effect data
-    if size < effect.pix_cnt:
-        cgen = __effect(size, offset, effect.pix_cnt)
-        # Draw effect data
-        effect.index_offset = 0     # reset auto shift offset
-        effect.draw(cgen, shift=shift)
-        return 'Shader size: {} ->{} ({})'.format(size, offset, effect.pix_cnt)
-    return 'Shader invalid size: {} ({})'.format(size, effect.pix_cnt)
-
-
-def random(max_val=255):
-    """
-    Demo function: implements random color change
-    :param max_val: set channel maximum generated value: 0-255
-    :return str: rgb status - states: R, G, B
-    """
-    r = randint(0, max_val)
-    g = randint(0, max_val)
-    b = randint(0, max_val)
-    Data.DCACHE[0] = r
-    Data.DCACHE[1] = g
-    Data.DCACHE[2] = b
-    return "Set random: R:{} G: B:{}".format(r, g, b)
-
-
-def color(r=None, g=None, b=None):
-    """
-    Set color buffer - for runtime effect color change
-    :param r int: red channel 0-255 (default: None - cached value)
-    :param g int: green channel 0-255 (default: None - cached value)
-    :param b int: blue channel 0-255 (default: None - cached value)
-    :return dict: rgb status - states: R, G, B, S
-    """
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-    Data.DCACHE[0] = r
-    Data.DCACHE[1] = g
-    Data.DCACHE[2] = b
-    return status()
-
-
-def fire(r=None, g=None, b=None, ledcnt=24):
-
-    def __effect(r, g, b, pixcnt):
-        for _ in range(pixcnt):
-            rand_percent = round(randint(1, 200)/100, 2)
-
-            rgb = [
-                r * rand_percent,
-                g * rand_percent,
-                b * rand_percent
-            ]
-
-            for i, color in enumerate(rgb):
-                if color > 255:
-                    rgb[i] = 255
-                if color < 0:
-                    rgb[i] = 0
-            yield rgb
-
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-
-    effect = DrawEffect(pixcnt=ledcnt)
-    cgen = __effect(r, g, b, effect.pix_cnt)
-    effect.draw(cgen, shift=False)
-    return 'fire R{}:G{}:B{} N:{}'.format(r, g, b, effect.pix_cnt)
-
-
-#######################
-# LM helper functions #
-#######################
-
-def lmdep():
-    """
-    Show Load Module dependency
-    - List of load modules used by this application
-    :return: tuple
-    """
-    return 'neopixel'
-
-
-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 pm()
-
-
-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 'meteor r=<0-255> g=<0-255> b=<0-255> shift=True ledcnt=24',\
-           'cycle r g b shift=True ledcnt=24',\
-           'rainbow step=1 br=<5-100> ledcnt=24',\
-           'fire r=None g=None b=None ledcnt=24',\
-           'shader size=4 offset=0 shift=True ledcnt=24',\
-           'random max_val=255',\
-           'color r g b', 'pinmap'

micrOS/source/LM_pet_feeder.py

@@ -1,76 +0,0 @@
-import uasyncio as asyncio
-from LM_servo import sduty, deinit
-from LM_stepper import step
-from Common import micro_task
-
-
-class Data:
-    TASK_TAG = "pet_feeder.portion"
-
-
-async def __portion_task(portion, posmin, posmax):
-    # ASYNC TASK ADAPTER [*2] with automatic state management
-    #   [micro_task->Task] TaskManager access to task internals (out, done attributes)
-    with micro_task(tag=Data.TASK_TAG) as my_task:
-        for p in range(0, portion):
-            # [1]Run pos fill up
-            for pos in range(posmin, posmax):
-                sduty(pos)
-                await asyncio.sleep_ms(15)
-            # [2]Wait between fill up / food out
-            await asyncio.sleep_ms(500)
-            # [3]Run pos food out
-            for pos in range(posmax, posmin, -1):
-                sduty(pos)
-                await asyncio.sleep_ms(20)
-            my_task.out = "{}/{} serving".format(p+1, portion)
-    deinit()
-    my_task.out += ": {} task done".format(Data.TASK_TAG)
-
-
-def serve(portion=1, posmin=65, posmax=97):
-    """
-    Pet feeder - with servo motor
-    :param portion: number of portions (min/max positions to repeat)
-    :param posmin: servo "start" position
-    :param posmax: servo "stop" position
-    """
-    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.TASK_TAG, task=__portion_task(portion=portion, posmin=posmin, posmax=posmax))
-    return "Starting" if state else "Already running"
-
-
-def serve_w_stepper(portion=1, forward=135, back=10):
-    """
-    Pet feeder (beta) - with stepper motor
-    :param count: number of portions
-    :param forward: s
-    :param back:
-    """
-    for _ in range(portion):
-        # portion move
-        step(forward)
-        # Safety anti-block solution?
-        step(-back)
-        step(back)
-        step(-back)
-        step(back)
-
-
-def lmdep():
-    """
-    Show Load Module dependency
-    - List of load modules used by this application
-    :return: tuple
-    """
-    return 'servo', 'stepper'
-
-
-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 'serve portion=1 \t\t[info] servo control',  'serve_w_stepper portion=1 \t[info] stepper control', 'lmdep'

micrOS/source/LM_ph_sensor.py

@@ -1,51 +0,0 @@
-from time import sleep
-from microIO import physical_pin, pinmap_dump
-from Common import SmartADC
-
-"""
-https://cimpleo.com/blog/simple-arduino-ph-meter/
-ADC.ATTN_0DB — the full range voltage: 1.2V
-ADC.ATTN_2_5DB — the full range voltage: 1.5V
-ADC.ATTN_6DB — the full range voltage: 2.0V
-ADC.ATTN_11DB — the full range voltage: 3.3V
-"""
-
-
-def __measure(samples=10):
-    adc_obj = SmartADC.get_singleton(physical_pin('ph'))
-    mbuf = 0
-    for k in range(0, samples):
-        mbuf += adc_obj.get()['volt']
-        sleep(0.1)
-    voltage = round(mbuf / samples, 3)
-    return voltage
-
-
-def measure():
-    data = SmartADC.get_singleton(physical_pin('ph')).get()
-    return "ADC data: {}\nAVG V: {}".format(data, __measure())
-
-
-#######################
-# LM helper functions #
-#######################
-
-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_dump('ph')
-
-
-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 'measure', 'pinmap'
-

micrOS/source/LM_rest.py

@@ -1,40 +0,0 @@
-from urequests import get as http_get
-
-class Rest:
-    GATEWAY_HOST = None
-
-
-def load_n_init(gateway_url=None):
-    """
-    Set gateway url aka main domain
-    :param gateway_url: base url of gateway, like: http://gateway.local:5000
-    """
-    if gateway_url is None:
-        if Rest.GATEWAY_HOST is None:
-            return 'Missing Gateway url'
-        return Rest.GATEWAY_HOST
-    Rest.GATEWAY_HOST = gateway_url
-    return f'Set gateway url: {gateway_url}'
-
-
-def url(subdomain):
-    """
-    Execute rest call with given subdomain
-    :param subdomain: command parameters of url, like: /webhooks/template
-    """
-    if Rest.GATEWAY_HOST is None:
-        return 'Missing Gateway url'
-    if not subdomain.startswith('/'):
-        subdomain = '/' + subdomain
-    domain = f'{Rest.GATEWAY_HOST}{subdomain}'
-    status_code, response = http_get(domain, jsonify=True)
-    return {'status': status_code, 'response': response}
-
-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_n_init gateway_url=<http://gateway.local:5000>', 'url subdomain=</webhooks/template>'

micrOS/source/LM_robustness.py

@@ -1,73 +0,0 @@
-from LM_system import memory_usage
-from Common import socket_stream
-
-
-@socket_stream
-def raise_error(msgobj=None):
-    """
-    Test function - raise  LM exception
-    """
-    if msgobj is not None:
-        msgobj("Raise test exception")
-    raise Exception("Test exception")
-
-
-@socket_stream
-def memory_leak(cnt=160, msgobj=None):
-    """
-    Test function - allocate lot of memory
-    :param cnt: data counter, default 160 iteration
-    :return: verdict
-    """
-    dict_test = {}
-    mem_start = memory_usage()['mem_used']
-    for k in range(cnt):
-        mem = memory_usage()['percent']
-        data = "micrOS memory usage: {} %".format(mem)
-        if msgobj is not None:
-            msgobj("[{}] gen: {}".format(k, data))
-        dict_test[k] = data
-    mem_end = memory_usage()['mem_used']
-    delta = mem_start - mem_end
-    return '[{}] RAM Alloc.: {} kB {} byte'.format(len(dict_test), int(delta / 1024), int(delta % 1024))
-
-@socket_stream
-def recursion_limit(limit=14, msgobj=None):
-    cnt = 0
-    for cnt in range(1, limit+1):
-        try:
-            _recursion(cnt, msgobj=msgobj)
-        except Exception as e:
-            msgobj(f"ok error: {e}")
-            break
-    return f"Recursion limit: {cnt}"
-
-
-def _recursion(cnt, msgobj=None):
-    """
-    Test function - recursion test
-    :param cnt: recursion depth
-    :return: verdict
-    Error example:
-        node01 $  robustness recursion_limit 15
-        lm_exec LM_robustness->recursion_limit: maximum recursion depth exceeded
-    """
-    if cnt > 0:
-        remain = _recursion(cnt-1)
-        if msgobj is not None:
-            msgobj("recalled {}".format(cnt))
-    else:
-        remain = 0
-    return remain
-
-
-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 'NOTE: This is a test module to validate system robustness', \
-           'raise_error', 'memory_leak cnt=160', 'recursion_limit cnt=14'
-

micrOS/source/LM_telegram.py

@@ -1,96 +0,0 @@
-import uasyncio as asyncio
-from Notify import Telegram
-from Common import micro_task
-from Network import ifconfig
-
-#########################################
-#          micrOS Notifications         #
-#########################################
-
-# ENABLE TELEGRAM IF NW IS STA - CONNECTED TO THE WEB
-_ENABLE = True if ifconfig()[0] == "STA" else False
-if _ENABLE:
-    TELEGRAM_OBJ = Telegram()
-else:
-    # NO NETWORK CONNECTION (STA)
-    TELEGRAM_OBJ = None
-
-
-def load_n_init():
-    """
-    Set custom chat commands for Telegram
-    - /ping
-    - /cmd module function (params)
-    """
-    if TELEGRAM_OBJ is None:
-        return "Network unavailable."
-    verdict = TELEGRAM_OBJ.set_commands()
-    return "Missing telegram bot token" if verdict is None else verdict
-
-
-def send(text):
-    """
-    Send Telegram message - micrOS notification
-    :param text: text to send
-    return verdict
-    """
-    if TELEGRAM_OBJ is None:
-        return "Network unavailable."
-    verdict = TELEGRAM_OBJ.send_msg(text)
-    return "Missing telegram bot token" if verdict is None else verdict
-
-
-def receive():
-    """
-    Receive Telegram message
-    - if all value None, then no incoming messages
-    One successful msg receive is necessary to get chat_id for msg send as well!
-    """
-    if TELEGRAM_OBJ is None:
-        return "Network unavailable."
-    verdict = TELEGRAM_OBJ.get_msg()
-    return "Missing telegram bot token" if verdict is None else verdict
-
-
-async def __task():
-    cancel_cnt = 0
-    with micro_task(tag='telegram._loop') as my_task:
-        my_task.out = "[UP] Running"
-        while True:
-            # Normal task period
-            await asyncio.sleep(5)
-            try:
-                v = TELEGRAM_OBJ.receive_eval()
-                my_task.out = "Missing bot token" if v is None else v
-                cancel_cnt = 0
-            except Exception as e:
-                my_task.out = str(e)
-                # Auto scale - blocking nature - in case of serial failures (5) - hibernate task (increase async sleep)
-                cancel_cnt += 1
-                if cancel_cnt > 5:
-                    my_task.out = f"[DOWN] {e}"
-                    cancel_cnt = 5
-                    # SLOW DOWN - hibernate task
-                    asyncio.sleep(115)
-
-
-def receiver_loop():
-    """
-    Telegram msg receiver loop - automatic LM execution
-    - Only executes module (function) if the module is already loaded
-    on the endpoint / micrOS node
-    """
-    if TELEGRAM_OBJ is None:
-        return "Network unavailable."
-    state = micro_task(tag='telegram._loop', task=__task())
-    return "Starting" if state else "Already running"
-
-
-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 'send "text"', 'receive', 'receiver_loop', 'load_n_init', 'INFO: Send & Receive messages with Telegram bot'

micrOS/source/reset.py

@@ -1,11 +0,0 @@
-from os import listdir
-from time import sleep
-from machine import soft_reset, reset
-
-print('Device reboot now, boot micrOSloader...')
-sleep(1)
-
-if "main.py" in listdir():
-    soft_reset()
-else:
-    reset()