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

micrOS/source/LM_L298N_DCmotor.py

@@ -1,86 +0,0 @@
-from machine import Pin, PWM
-from microIO import resolve_pin, pinmap_search
-
-#########################################
-#     ANALOG DIMMER CONTROLLER PARAMS   #
-#########################################
-__L298N_OBJS = []
-# DATA: SPEED (PWM obj), dir pin1, dir pin2
-
-
-#########################################
-#         ANALOG DIMMER WITH PWM        #
-#########################################
-
-def __l298n_init():
-    global __L298N_OBJS
-    if len(__L298N_OBJS) == 0:
-        __L298N_OBJS.append(PWM(Pin(resolve_pin('l298speed')), freq=50))
-        __L298N_OBJS.append(Pin(resolve_pin('l298dir_1'), Pin.OUT))
-        __L298N_OBJS.append(Pin(resolve_pin('l298dir_2'), Pin.OUT))
-        __L298N_OBJS[0].duty(0)     # Set default speed (PWM)
-        __L298N_OBJS[1].value(0)    # Set default direction for dc motor1
-        __L298N_OBJS[2].value(1)    # Set default direction for dc motor1
-    return __L298N_OBJS
-
-
-def m1_control(direc=None, speed=None):
-    out = {}
-    if direc is not None:
-        out = set_direction(direc)
-    if speed is not None:
-        out.update(set_speed(speed))
-    return out
-
-
-def set_speed(speed=100):
-    if 0 <= speed <= 1000:
-        print(__l298n_init())
-        __l298n_init()[0].duty(speed)
-        return {'speed': speed}
-    return {'speed': 'value range error'}
-
-
-def stop():
-    return set_speed(0)
-
-
-def set_direction(direc=0):
-    """
-    direc (direction) values:
-    0: forward
-    1: backward
-    """
-    objlist = __l298n_init()
-    if direc == 0:
-        objlist[1].value(1)
-        objlist[2].value(0)
-        return {'direction': 'forward'}
-    objlist[1].value(0)
-    objlist[2].value(1)
-    return {'direction': 'backward'}
-
-
-#######################
-# 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_search(['l298speed', 'l298dir_1', 'l298dir_2'])
-
-
-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 'm1_control direc=<0/1> speed=<0-1023>', 'set_speed <0-1023>',\
-           'set_direction <0-1>', 'stop', 'pinmap'

micrOS/source/LM_catgame.py

@@ -1,75 +0,0 @@
-from random import randint
-from LM_servo import sduty, deinit, pinmap as pm
-from utime import sleep_ms
-from Types import resolve
-
-
-def load():
-    """
-    Initialize catgame-servo module
-    """
-    return "catgame-servo module - loaded"
-
-
-def game(repeat=10, delta=20):
-    """
-    Servo cat toy "mover" - left-right
-    :param repeat int: repeat servo pos change
-    :param delta int: center(75) +/-delta(35)
-    :return str: verdict
-    """
-    sduty(75)
-    for _ in range(0, repeat):
-        sduty(randint(75-delta, 75+delta))
-        sleep_ms(randint(20, 1500))
-    sduty(75)
-    return 'Game action'
-
-
-def live_game(chance=10):
-    """
-    Generate game
-    :param chance int: percent value 0-100
-    :return str: verdict (action / no action)
-    """
-    action = randint(1, 10)
-    if action <= int(chance/10):
-        return game(repeat=5)
-    return 'No action'
-
-
-def stop():
-    """
-    Stop game - home position (75) + deinit
-    :return str: servo verdict
-    """
-    out = sduty(75)
-    deinit()
-    return out
-
-
-#######################
-# 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 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 resolve(('BUTTON game repeat=10',
-                             'SLIDER live_game chance=<10-90>',
-                             'BUTTON stop', 'pinmap',
-                             'load'), widgets=widgets)

micrOS/source/LM_dashboard_be.py

@@ -1,37 +0,0 @@
-from Common import web_endpoint, syslog
-
-ENDPOINT_INITED = False
-
-def load():
-    return create_dashboard()
-
-
-def _dashboard_clb():
-    try:
-        with open('dashboard.html', 'r') as html:
-            html_content = html.read()
-        return 'text/html', html_content
-    except Exception as e:
-        syslog(f"[ERR] dashboard_be: {e}")
-        html_content = None
-    return 'text/plain', f'html_content error: {html_content}'
-
-
-def create_dashboard():
-    """
-    Create dashboard endpoint
-    """
-    global ENDPOINT_INITED
-    ENDPOINT_INITED = True
-    web_endpoint('dashboard', _dashboard_clb)
-    return 'Endpoint created: /dashboard'
-
-
-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', 'create_dashboard', 'help'

micrOS/source/LM_demo.py

@@ -1,97 +0,0 @@
-from random import randint
-from Time import uptime
-from Types import resolve
-from microIO import detect_platform
-from Common import console
-
-CNT = 0
-
-
-def _debug(func):
-    """
-    Debug wrapper
-    - console logging
-    - handled cmd counter (exec_info to get the value)
-    """
-    def __wrapper(*args, **kwargs):
-        global CNT
-        CNT += 1
-        console("debug module cmd executed")     # + Progress LED
-        return func(*args, **kwargs)
-    return __wrapper
-
-
-def load():
-    """
-    Initialize demo module
-    """
-    return "demo module - loaded"
-
-
-@_debug
-def hello(name="MrNobody"):
-    return f"Hello {name}! This is a micrOS smart endpoint ☁️, running on {detect_platform()}.\
-    \nFor more info call `demo links` function :D"
-
-
-@_debug
-def calculator(a, b, op="+"):
-    if op.strip() == "+":
-        return f"{a} + {b} = {a + b}"
-    if op.strip() == "-":
-        return f"{a} - {b} = {a - b}"
-    if op.strip() == "/":
-        return f"{a} / {b} = {round(a / b, 3)}"
-    if op.strip() == "*":
-        return f"{a} * {b} = {a * b}"
-
-
-@_debug
-def dice_cube():
-    value = randint(1, 6)
-    return f"🎲 {value}"
-
-
-@_debug
-def yes_no():
-    val = randint(0, 1)
-    return 'NO👎' if val == 0 else 'YES👍'
-
-
-@_debug
-def links():
-    descript = f"Platform: {detect_platform()}\nGITHUB: https://github.com/BxNxM/micrOS\nYOUTUBE: https://www.youtube.com/@micrOSframework\nINSTAGRAM: https://instagram.com/micros_framework"
-    return descript
-
-
-@_debug
-def source():
-    return 'https://github.com/BxNxM/micrOS/blob/master/micrOS/source/LM_demo.py'
-
-
-@_debug
-def exec_info():
-    global CNT
-    return f"Under {uptime()}: {CNT} cmd served."
-
-
-@_debug
-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 resolve(('hello name="MrNobody"',
-           'calculator a b op="+"',
-           '\t=>op: + - / *',
-           'BUTTON dice_cube',
-           'dice_cube - show number, roll a dice',
-           'BUTTON yes_no',
-           'yes_no    - show random yes/no',
-           'links     - show micrOS links',
-           'source    - show demo module source code',
-           'TEXTBOX exec_info',
-           'exec_info - Execution info, demo module usage',
-           'load'), widgets=widgets)

micrOS/source/LM_espnow.py

@@ -1,23 +0,0 @@
-import Espnow
-
-def load():
-    return Espnow.initialize()
-
-def send(peer, msg='ping'):
-    return Espnow.espnow_send(peer, msg)
-
-def start_server():
-    return Espnow.espnow_server()
-
-def stats():
-    return Espnow.stats()
-
-def add_peer(peer):
-    now = Espnow.initialize()
-    return Espnow.add_peer(now, peer)
-
-def mac_address():
-    return Espnow.mac_address()
-
-def help():
-    return 'load', 'send <peer> "ping"', 'start_server', 'add_peer <peer>', 'stats', 'mac_address'

micrOS/source/LM_intercon.py

@@ -1,57 +0,0 @@
-from InterConnect import send_cmd, host_cache
-from Common import syslog
-
-
-def sendcmd(*args, **kwargs):
-    """
-    Implements send command function towards micrOS devices
-        example: sendcmd "hello" host="IP/hostname.local") OR sendcmd host="IP/hostname.local" cmd="system rssi")
-    :param host[0]: host IP or Hostname
-    :param cmd[1]: command - module func arg(s)
-    :return str: reply
-    """
-    def __send(_host, _cmd):
-        try:
-            out = send_cmd(_host, _cmd)
-        except Exception as e:
-            out = []
-            syslog(f'[intercon] sendcmd: {e}')
-        return out
-
-    host = kwargs.get('host', None)
-    cmd = kwargs.get('cmd', None)
-
-    # Host correction (lm_exec) if keyword-arg 'host' was not found
-    if host is None:
-        host = args[0]
-        args = args[1:]
-
-    # Cmd correction (lm_exec) if keyword-arg was not found
-    if cmd is None:
-        cmd = ''.join(args)
-    return __send(host, cmd)
-
-
-def addr_cache():
-    """
-    Dump intercon connection cache
-    :return dict: device-ip pairs
-    """
-    return host_cache()
-
-
-#######################
-# LM helper functions #
-#######################
-
-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 'sendcmd "hello" host="IP/hostname.local")',\
-           'sendcmd host="IP/hostname.local" cmd="system rssi")',\
-           'example: intercon sendcmd "10.0.1.84" "system rssi" OR intercon sendcmd "system rssi" host="node01.local"', \
-           'addr_cache'

micrOS/source/LM_keychain.py

@@ -1,322 +0,0 @@
-from utime import localtime, sleep_ms
-from neopixel import NeoPixel
-from machine import Pin
-from Common import micro_task
-from microIO import resolve_pin, pinmap_search
-from LM_oled import text, show, rect, pixel, clean, line, load as oled_lni
-from LM_ds18 import measure
-from LM_system import top, ifconfig
-try:
-    from LM_gameOfLife import next_gen as gol_nextgen, reset as gol_reset
-except:
-    gol_nextgen = None      # Optional function handling
-
-class KC:
-    INITED = False          # Auto init module feature
-    DP_main_page = True     # store display logical state: ON (main page) / OFF (screen saver)
-    DP_cnt = 0              # display "count back", when 0 go to sleep -> OFF
-    DP_cnt_default = None   # store calculated sequence to sleep 30sec/period_ms
-    NEOPIXEL_OBJ = None     # Neopixel LED handler object
-    COLOR_WHEEL = None      # LED color wheel generator object for animation
-    NEOPIXEL_BR = 20        # default neopixel brightness
-
-#############################
-#    INTERNAL FUNCTIONS     #
-#############################
-
-
-async def _screen_saver(scale=2):
-    """
-    Conway's game of life screen saver simulation
-    :param scale: default (2) game of life matrix (16x32) upscale to real display size 32x64
-    """
-    # Default mode
-    if gol_nextgen is None:
-        return      # screen off - no screen saver...
-    # Screen saver mode
-    matrix = gol_nextgen(raw=True)
-    if matrix is None:
-        # Reset Game of life
-        gol_reset()
-        # quick view - show (enable) main page
-        KC.DP_main_page = True
-    else:
-        # Update display with Conway's Game of Life
-        clean()
-        for line_idx, _line in enumerate(matrix):
-            for x_idx, v in enumerate(_line):
-                if scale == 1:
-                    pixel(x_idx, line_idx, color=v)
-                else:
-                    rect(x_idx*scale, line_idx*scale, w=scale, h=scale, state=v, fill=True)
-        show()
-
-
-def __color_wheel():
-    """
-    RGB LED color wheel generator - rainbow
-    """
-    max_val = 10                    # normally up to 255, but must be limited due to heat problems (4%)
-    half_val = max_val // 2
-    colors = ((0, 0, half_val), (0, 0, max_val), (0, half_val, max_val), (0, max_val, half_val), (0, max_val, 0),
-              (half_val, max_val, 0), (max_val, half_val, 0), (max_val, 0, 0), (half_val, 0, 0), (max_val, 0, half_val),
-              (half_val, 0, max_val), (0, 0, half_val))
-    while True:
-        # Loop through the colors to generate smooth transitions
-        for i in range(len(colors) - 1):
-            start_color = colors[i]
-            end_color = colors[i + 1]
-            # Generate a smooth transition from start_color to end_color
-            for j in range(5):  # Adjust this value for smoother or faster transition
-                # Linear interpolation for each color component
-                yield tuple(int(start + (end - start) * j / 10) for start, end in zip(start_color, end_color))
-
-
-async def _main_page():
-    """
-    Run display content refresh
-        #   H:M
-         S/A: 1.92
-         40.0 C
-    """
-    def _timer():
-        # 5x5 px cube (25px overall)
-        _offset, _l_width = 2, 5                                # Initial size + positioning
-        _view = int(25*(KC.DP_cnt/KC.DP_cnt_default))           # overall pixel to be visualized
-        _complete_lines = int(_view / _l_width)                 # complete lines number
-        _sub_line = _view - (_complete_lines*_l_width)          # incomplete line width
-        for _l in range(0, 5):
-            if _l < _complete_lines:
-                line(0+_offset, _l+_offset, _l_width+_offset, _l+_offset)
-            else:
-                line(0+_offset, _l+_offset, _sub_line+_offset, _l+_offset)
-                break
-
-    def _cpu_mem():
-        sys_usage = top()
-        cpu = sys_usage.get('CPU load [%]', 100)
-        cpu = 100 if cpu > 100 else cpu                                             # limit cpu overload in visualization
-        mem = sys_usage.get('Mem usage [%]', 100)
-        _cpu_limit, _mem_limit = cpu > 90, mem > 70                                 # fill indicator (limit)
-        _offset, _height = 1, 6
-        _cpu, _mem = int(_height * (cpu/100)), int(_height * (mem/100))
-        rect(55, _height+_offset-_cpu, w=3, h=_cpu+_offset, fill=_cpu_limit)     # cpu usage indicator
-        rect(60, _height+_offset-_mem, w=3, h=_mem+_offset, fill=_mem_limit)     # memory usage indicator
-
-    # Clean display and collect input data: time, network mode, IP address
-    clean()
-    ltime = localtime()
-    h = f"0{ltime[-5]}" if len(str(ltime[-5])) < 2 else ltime[-5]
-    m = f"0{ltime[-4]}" if len(str(ltime[-4])) < 2 else ltime[-4]
-    nwmd, nwif = ifconfig()
-    nwmd, devip = nwmd[0] if len(nwmd) > 0 else "0", ".".join(nwif[0].split(".")[-2:])
-
-    # Draw data to display
-    _timer()                                                                    # Draw display timer (until screen saver)
-    _cpu_mem()                                                                  # Draw cpu and memory indicator
-    text(f"{h}:{m}", x=12, y=1)                                           # Header: time
-    text(f"{nwmd}:{devip}", x=4, y=15)                                    # Network mode and IP
-    try:
-        text(f"{round(tuple(measure().values())[0], 1)} C", x=4, y=25)    # ds18 sensor value
-    except Exception:
-        text("? C", x=4, y=25)                                            # ds18 read issue (default: ?)
-    show()
-    return "Display show"
-
-
-async def _ui_task(period_ms, tts_ms):
-    """Async display refresh task
-    - main page    (main mode)
-    - screen saver (sleep mode)
-    """
-    # Auto init keychain module (if needed) - failsafe
-    if not KC.INITED:
-        _v = load()
-        if not KC.INITED:
-            return _v
-
-    KC.DP_cnt_default = int(tts_ms / period_ms)     # After 30 sec go to sleep mode
-    KC.DP_cnt = KC.DP_cnt_default                   # Set sleep counter
-    fast_period = int(period_ms/3)                  # Calculate faster refresh period
-    fast_period = fast_period if fast_period > 100 else 100
-
-    # Run keychain main async loop, with update ID: keychain.display
-    with micro_task(tag="keychain.display") as my_task:
-        while True:
-            if KC.DP_main_page:
-                # [MAIN MODE] Execute main page
-                await _main_page()                          #1 Run main page function
-                my_task.out = f'main page: {KC.DP_cnt}'     #2 Update task data for (task show keychain.display)
-                KC.DP_cnt -= 1                              #3 Update sleep counter
-                # Async sleep - feed event loop
-                await my_task.feed(sleep_ms=period_ms)
-            else:
-                # [SLEEP MODE] Execute screen saver page
-                await _screen_saver()                       # Run sleep page function
-                # Async sleep - feed event loop
-                await my_task.feed(sleep_ms=fast_period)
-
-            # Auto sleep event handler - off event - go to (sleep mode)
-            if KC.DP_cnt <= 0:
-                KC.DP_main_page = False         #1 disable main screen
-                clean()                         #2 clean screen
-                show()                          #3 show cleaned display
-                KC.DP_cnt = KC.DP_cnt_default   #4 reset sleep counter to default
-                my_task.out = 'sleep...'
-            color_wheel()              # update neopixel color wheel
-
-
-#############################
-#      PUBLIC FUNCTIONS     #
-#############################
-
-def load(width=64, height=32, bootmsg="micrOS"):
-    """
-    Init OLED display 64x32 (default)
-    Init Neopixel LED (1 segment)
-    :param width: screen width (pixel)
-    :param height: screen height (pixel)
-    :param bootmsg: First text on page at bootup, default: "micrOS"
-    """
-    KC.COLOR_WHEEL = __color_wheel()            #1 Init neopixel color wheel generator
-    try:
-        oled_lni(width, height, brightness=20)  #2 Init oled display
-        msgbox(bootmsg, width)                  #3 Show boot page text
-        KC.INITED = True                        # Set display was successfully inited (for _task auto init)
-        return "OLED INIT OK"
-    except Exception as e:
-        KC.INITED = False                       # display init failed (for _task auto init)
-        return f"OLED INIT NOK: {e}"
-
-
-def msgbox(msg, width=64):
-    clean()
-    chunk_size, char_height, line_limit = 8, 10, 3
-    # Format message: fitting and \n parsing
-    msg = msg.split('\n')
-    chunks = [line[i:i + chunk_size] for line in msg for i in range(0, len(line), chunk_size)]
-    for i, line in enumerate(chunks):
-        if i > line_limit - 1:  # max line_limit lines of 13 char
-            break
-        start_x = int((width - len(line)*8)/2)
-        start_y = char_height * i
-        for k in range(0, len(line)):
-            text(line[0:k+1], start_x, start_y)
-            show()
-            sleep_ms(100)
-    sleep_ms(2000)
-
-
-def display(period=1000, tts=30):
-    """
-    Create keychain.display task - refresh loop
-    :param period: display refresh period in ms (min. 500ms)
-    :param tts: time to sleep (in seconds)
-    """
-    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    period_ms = 500 if period < 500 else period
-    tts_ms = 5000 if tts < 5 else tts*1000
-    state = micro_task(tag="keychain.display", task=_ui_task(period_ms, tts_ms))
-    return "Starting" if state else "Already running"
-
-
-def temperature():
-    """
-    Measure ds18B20 temperature sensor
-    """
-    return measure()
-
-
-def color_wheel(br=None):
-    """
-    Neopixel color wheel
-    :param br: brightness value 0-100 percent
-    """
-    def _init():
-        if KC.NEOPIXEL_OBJ is None:
-            neopixel_pin = Pin(resolve_pin('neop'))        # Get Neopixel pin from LED PIN pool
-            KC.NEOPIXEL_OBJ = NeoPixel(neopixel_pin, n=1)   # initialize for max 1 segment
-        return KC.NEOPIXEL_OBJ
-    # INIT
-    neo_led = _init()
-    if br is None or not isinstance(br, int):       # Optional brightness param handling (load from cache)
-        br = KC.NEOPIXEL_BR
-    else:
-        KC.NEOPIXEL_BR = br                         # update neopixel brightness cache
-    if KC.COLOR_WHEEL is None:
-        KC.COLOR_WHEEL = __color_wheel()             # init color wheel generator
-    # UPDATE
-    r, g, b = next(KC.COLOR_WHEEL)                  # get next color
-    br = br if br == 100 else br/100                # calculate brightness multiplier
-    r, g, b = int(r*br), int(g*br), int(b*br)       # apply brightness parameter
-    neo_led[0] = (r, g, b)                          # Set LED element color
-    neo_led.write()                                 # Send data to LED device
-    return {'R': r, 'G': g, 'B': b, 'S': 1, 'br': br}   # Return verdict
-
-
-def display_toggle():
-    """
-    Display mode toggle (main/screensaver)
-    """
-    KC.DP_main_page = not KC.DP_main_page
-    if not KC.DP_main_page:
-        # Reset display counter when goes to sleep
-        KC.DP_cnt = KC.DP_cnt_default
-    v = 'main view' if KC.DP_main_page else 'screensaver'
-    return f"Display mode: {v}"
-
-
-def neopixel_toggle():
-    """
-    Disable/Enable neopixel LED (brightness 0/default)
-    """
-    KC.NEOPIXEL_BR = 0 if KC.NEOPIXEL_BR > 0 else 20
-    v = 'disabled' if KC.NEOPIXEL_BR == 0 else 'enabled'
-    return f"Neopixel: {v} br: {KC.NEOPIXEL_BR}"
-
-
-def button():
-    """
-    IRQ1 keychain module control function
-    - neopixel ON/OFF
-    - display wake-up (ON)
-    """
-    # If display is ON call neopixel toggle function
-    if KC.DP_main_page:
-        # Reset display counter
-        KC.DP_cnt = KC.DP_cnt_default
-        # Neopixel color wheel disable/enable
-        return neopixel_toggle()
-    # Wake display
-    KC.DP_main_page = True
-    return "Display mode: main view"
-
-
-def pinmap():
-    """
-    PIN MAP dump
-    """
-    from LM_oled import pinmap as o_pmp
-    from LM_ds18 import pinmap as t_pmp
-    pmp = o_pmp()
-    pmp.update(t_pmp())
-    pmp.update(pinmap_search(['neop']))
-    return pmp
-
-
-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 width=64 height=32 bootmsg="micrOS"',
-            'msgbox msg="micrOS"',
-            'temperature', 
-            'display period>=1000 tts=30',
-            'button',
-            'display_toggle',
-            'neopixel_toggle',
-            'color_wheel br=<0-100>',
-            'pinmap')