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

micrOS/source/helpers.py

@@ -0,0 +1,132 @@
+"""
+MICROPYTHON REPL micrOS Cli over UART
+    - reset()    - reboot board
+    - shell()    - start async micrOS shell (same as ShellCli)
+"""
+
+from time import sleep
+from uos import listdir
+from machine import soft_reset, reset as hard_reset
+
+try:
+    from Shell import Shell
+    from Tasks import Manager
+    from Common import micro_task
+    # --- nonblocking stdin line reader (USB serial REPL) ---
+    import sys, uselect
+    _poll = uselect.poll()
+    _poll.register(sys.stdin, uselect.POLLIN)
+    _buf = []
+except ImportError as e:
+    print(f"!!!Cannot import shell: {e}")
+    Shell = None
+
+#############################################
+#               REBOOT DEVICE               #
+#############################################
+
+def reset():
+    """
+    [HELPER] Reboot board
+    """
+    print('Device reboot now, boot micrOSloader...')
+    sleep(1)
+
+    if "main.py" in listdir():
+        soft_reset()
+    else:
+        hard_reset()
+
+#############################################
+#               SHELL in REPL               #
+#############################################
+
+def _read_line_nb(echo=True):
+    """
+    Non-blocking:
+      - returns a full line (str, without trailing newline) when '\n' received
+      - returns None if no complete line yet
+    Echoes typed characters and supports backspace locally.
+    """
+    while _poll.poll(0):              # check without waiting
+        ch = sys.stdin.read(1)
+        if not ch:
+            break
+
+        if ch == '\n':                # end-of-line (LF)
+            line = ''.join(_buf)
+            _buf.clear()
+            return line               # NOTE: we do NOT print a newline
+        if ch == '\r':                # ignore CR
+            continue
+
+        # backspace / delete
+        if ch in ('\x08', '\x7f'):
+            if _buf and echo:
+                _buf.pop()
+                sys.stdout.write('\x08 \x08')  # erase last char visually
+            elif _buf:
+                _buf.pop()
+            continue
+
+        # regular char
+        _buf.append(ch)
+        if echo:
+            sys.stdout.write(ch)
+    return None
+
+
+async def _shell_task(task_id):
+
+    class ReplShell(Shell):
+        async def a_send(self, msg):
+            print(f"\n{msg}", end='')
+
+    shell_inst = ReplShell()
+    with micro_task(task_id) as my_task:
+        # Init shell welcome msg in repl mode
+        await shell_inst.shell("help")
+        # Run shell interpreter
+        while True:
+            my_task.out = "ShellCli in REPL"
+            _msg = _read_line_nb()          # NoN Blocking ...
+            #_msg = input()                 # Blocking input handling
+            if _msg is not None:
+                state = await shell_inst.shell(_msg)
+                if not state or _msg.strip() == "exit":
+                    print(f"\nEXIT SHELL: {_msg} ({state}) [Ctrl-C to return micropython repl]")
+                    break
+            await my_task.feed(sleep_ms=10)
+    return f"Shell in REPL stopped...({state})"
+
+
+def shell():
+    """
+    [HELPER] Run Shell in REPL
+    """
+    if Shell is None:
+        return "Cannot run Shell in REPL, import error"
+    # Prepare micrOS Task manager
+    aio = Manager()
+    # Initiate Shell as repl task
+    task_id = "repl.shell"
+    aio.create_task(callback=_shell_task(task_id), tag=task_id)
+    # Run async main event loop
+    aio.run_forever()
+    return "Async Main Event Loop Stopped"
+
+
+if __name__ == "helpers":
+    # COMMAND LINE INTERFACE
+    print("\nmicrOS REPL Tools\n-----------------")
+    print("\t[0]  helpers.reset()  -  reboot board")
+    if Shell: print("\t[1]  helpers.shell()  -  Start Shell in REPL")
+    CHOICES = (reset, shell)
+    CHOICE = None
+    try:
+        CHOICE = input("Select option: ").strip()
+        CHOICE = int(CHOICE)
+        # EXEC COMMAND
+        CHOICES[CHOICE]()
+    except Exception as e:
+        print(f"Invalid input {CHOICE}: {e}")

micrOS/source/micrOS.py

@@ -4,16 +4,23 @@ dedicated to micrOS framework.
 
 Designed by Marcell Ban aka BxNxM
 """
+
+#################################################################
+#                           INIT FS                             #
+#################################################################
+from Files import init_micros_dirs
+init_micros_dirs()
+
 #################################################################
 #                           IMPORTS                             #
 #################################################################
 from Time import ntp_time, suntime
 from Tasks import Manager
-from Hooks import bootup, profiling_info
+from Hooks import bootup, profiling_info, enableESPNow
 from Network import auto_nw_config
 from Server import Server
 from Interrupts import enableInterrupt, enableCron, initEventIRQs
-from Debug import errlog_add
+from Debug import syslog
 
 
 #################################################################
@@ -26,7 +33,7 @@ def irq_handler():
         enableCron()
     except Exception as e:
         print(f"[micrOS main] InterruptHandler.enableInterrupt/CronInterrupt error: {e}")
-        errlog_add(f"[ERR] irq_handler error: {e}")
+        syslog(f"[ERR] irq_handler error: {e}")
 
 
 def external_irq_handler():
@@ -34,7 +41,7 @@ def external_irq_handler():
         initEventIRQs()
     except Exception as e:
         print(f"[micrOS main] InterruptHandler.initEventIRQs error: {e}")
-        errlog_add(f"[ERR] external_irq_handler error: {e}")
+        syslog(f"[ERR] external_irq_handler error: {e}")
 
 
 #################################################################
@@ -53,7 +60,7 @@ def micrOS():
         bootup()
     except Exception as e:
         print(f"[micrOS main] Hooks.boot() error: {e}")
-        errlog_add(f"[ERR] safe_boot: {e}")
+        syslog(f"[ERR] safe_boot: {e}")
 
     # NETWORK setup
     nwmd = auto_nw_config()
@@ -74,10 +81,13 @@ def micrOS():
 
     # [Server] as async task
     aio.create_task(Server().run_server(), tag='server')
-    profiling_info(label='[memUsage] SYSTEM IS UP')
+
+    # [ESPNow] server as async task
+    enableESPNow()
+    profiling_info(label='[memUsage] SYSTEM IS UP AND RUNNING')
 
     # [EVENT LOOP] Start async event loop
     aio.run_forever()
 
     # UNEXPECTED RESTART ???
-    errlog_add("[ERR] !!! Unexpected micrOS restart")
+    syslog("[ERR] !!! Unexpected micrOS restart")

micrOS/source/micrOSloader.py

@@ -1,5 +1,6 @@
 """
 Module is responsible for invoke micrOS or recovery webrepl mode
+[IMPORTANT] This module must never use any micrOS specific functions in main scope.
 
 Designed by Marcell Ban aka BxNxM
 """
@@ -11,11 +12,6 @@ try:
     import traceback
 except:
     traceback = None
-try:
-    from Debug import errlog_add
-except Exception as e:
-    print(f"[loader] Import error: {e}")
-    errlog_add = None
 from machine import reset
 
 
@@ -59,6 +55,8 @@ def _is_micrOS():
 
 def __recovery_mode():
     # Recovery/Update mode (webrepl) - dependencies: Network, ConfigHandler
+    from sys import path
+    path.insert(0, "/modules")
     from Network import auto_nw_config
     from Config import cfgget
     pwd = cfgget('appwd')                       # Get pwd from config
@@ -70,16 +68,13 @@ def __recovery_mode():
         import webrepl
         webrepl.start(password=pwd)
     except Exception as e:
-        if callable(errlog_add):
-            errlog_add(f"[ERR][micrOSloader] webrepl failed: {e}")
-        print("[loader] Reset .if_mode to micros and reboot")
+        print(f"[loader] webrepl failed: {e} - Reset .if_mode to micros and reboot")
         with open('.if_mode', 'w') as f:
             f.write("micros")
         # Reboot machine
         reset()
 
 
-
 def __auto_restart_event():
     """
     Poll .if_mode value main loop in case of webrepl (background) mode:
@@ -107,7 +102,7 @@ def __auto_restart_event():
         if trigger_is_active and _is_micrOS():
             print("[loader][ota-rebooter][micros][trigger: True] OTA was finished - reboot")
             # Create cleanup indicator file for ConfigHandler
-            with open('cleanup.pds', 'w') as f:
+            with open('.cleanup', 'w') as f:
                 f.write('')
             # Reboot machine
             reset()
@@ -127,8 +122,6 @@ def main():
             # Handle micrOS system crash (never happened...but) -> webrepl mode default pwd: ADmin123
             print(f"[loader][main mode] micrOS start failed: {e}")
             print("[loader][main mode] -> [recovery mode]")
-            if callable(errlog_add):
-                errlog_add(f"[ERR][micrOSloader] start failed: {e}")
     # Recovery aka webrepl mode
     __recovery_mode()
     __auto_restart_event()

micrOS/source/microIO.py

@@ -1,7 +1,8 @@
 """
-Module is responsible for board independent
-input/output handling dedicated to micrOS framework.
-- Hardware based pinout handling
+This module manages board-independent input and output operations
+for the micrOS framework, ensuring compatibility across different
+microcontrollers.
+- Handles hardware-based pin configurations.
 
 Designed by Marcell Ban aka BxNxM
 """
@@ -9,7 +10,8 @@ Designed by Marcell Ban aka BxNxM
 #                           IMPORTS                             #
 #################################################################
 from sys import platform
-from os import listdir
+from uos import uname
+from Files import ilist_fs, OSPath
 from Logger import syslog
 
 #################################################################
@@ -28,24 +30,25 @@ def detect_platform():
     """
     Unified platform detection for micrOS
     """
-    if 'esp32' in platform:
-        from os import uname
+    if 'esp32' in platform:     # esp32 family
         board = str(uname()[-1]).lower()
         if 'tinypico' in board:
-            return 'tinypico'    # esp32 family - tinypico
+            return 'tinypico'
         if 'esp32s2' in board:
-            return 'esp32s2'     # esp32 family - esp32S2
+            return 'esp32s2'
         if 'esp32s3' in board:
-            return 'esp32s3'     # esp32 family - esp32s3
+            return 'esp32s3'
         if 'esp32c3' in board:
-            return 'esp32c3'     # esp32 family - esp32c3
-        return 'esp32'           # esp32 family - general
+            return 'esp32c3'
+        if 'esp32c6' in board:
+            return 'esp32c6'
+        return 'esp32'           # esp32 family: general
     return platform              # esp8266 or something else
 
 
 def set_pinmap(map_data=None):
     """
-    Select pin map on device (init from ConfigHandler)
+    !Select pin map on device (init from ConfigHandler!!!)
     - map_data: default None (n/a), platform detection, like: esp32 -> IO_esp32.mpy
     - map_data: string input, like: my_pinmap -> IO_my_pinmap.mpy
     Parse map_data use cases:
@@ -65,18 +68,19 @@ def set_pinmap(map_data=None):
 
     # SELECT LOOKUP TABLE BASED ON PLATFORM / User input
     if isinstance(io_file, str) and io_file != 'n/a':
-        if f"IO_{io_file}" in [io.split('.')[0] for io in listdir() if io.startswith('IO_')]:
+        if f"IO_{io_file}" in [io.split('.')[0] for io in ilist_fs(OSPath.MODULES, type_filter='f', select="IO")]:
             PinMap.MAPPING_LUT = io_file
             return PinMap.MAPPING_LUT
     PinMap.MAPPING_LUT = detect_platform()
     return PinMap.MAPPING_LUT
 
 
-def resolve_pin(tag):
+def resolve_pin(tag:str) -> int:
     """
-    Used in LoadModules
-    tag - resolve pin name by logical name (like: switch_1)
+    DEPRECATED IN LoadModules - USE bind_pin(tag) wrapper instead
     This function implements IO allocation/booking (with overload protection)
+    - based on platform/custom IO_.py lookup table file
+    :parm tag: resolve pin name by logical name (like: switch_1)
     return: integer (pin number)
     """
     # Get pin number on platform by pin key/name
@@ -94,8 +98,9 @@ def resolve_pin(tag):
     return pin_num
 
 
-def register_pin(tag, number):
+def register_pin(tag:str, number:int) -> int:
     """
+    DEPRECATED IN LoadModules - USE bind_pin(tag, number) wrapper instead
     Book pin (with overload protection) without IO_platform.py file editing
     :param tag: associated pin name for pin number
     :param number: pin number as integer
@@ -114,11 +119,30 @@ def register_pin(tag, number):
     return number
 
 
-def pinmap_info():
+def bind_pin(tag, number=None) -> int:
+    """
+    Universal pin handler - assign+lock pin for a tag -> application
+    :param tag: tag for application pin booking with built-in tag detection from IO_<device>.py
+    :param number: optional parameter to overwrite default tag:pin relation
+    DO NOT HANDLE ERROR HERE - SUB ELEMENTS HAVE TO THROUGH ERROR INFO FOR LOAD MODULES
+    """
+    if number is None:
+        return resolve_pin(tag)
+    if isinstance(number, int):
+        return register_pin(tag, number)
+    raise Exception("microIO.allocate_pin number parameter must be integer!")
+
+
+def pinmap_info(show_all=False) -> dict:
     """
     Debug info function to get active pinmap and booked IO-s
     """
-    return {'map': PinMap.MAPPING_LUT, 'booked': PinMap.IO_USE_DICT, 'custom': PinMap.MAPPING}
+    inf = {'map': PinMap.MAPPING_LUT, 'booked': PinMap.IO_USE_DICT, 'custom': PinMap.MAPPING}
+    if show_all:
+        iomaps = list([iomap.replace("IO_", "").split(".")[0]
+                       for iomap in ilist_fs(OSPath.MODULES, type_filter='f', select="IO")])
+        inf.update({"known_maps": iomaps})
+    return inf
 
 
 def pinmap_search(keys):
@@ -138,7 +162,7 @@ def pinmap_search(keys):
     return pins_cache
 
 
-def __resolve_pin(name):
+def __resolve_pin(name:str):
     """
     Dynamic const lookup table handling by var name
     :param name: logical pin name, example: neop, dht, etc.

micrOS/source/modules/IO_esp32c6.py

@@ -0,0 +1,38 @@
+from micropython import const
+
+"""
+Seeed Studio XIAO ESP32-C6
+
+BOARD        MICROPYTHON
+D0/A0    -   GPIO 0
+D1/A1    -   GPIO 1
+D2/A2    -   GPIO 2
+D3       -   GPIO 21
+D4 SDA   -   GPIO 22
+D5 SCL   -   GPIO 23
+D6 TX0   -   GPIO 16
+D7 RX0   -   GPIO 17
+D8 SCK   -   GPIO 19
+D9 MISO  -   GPIO 20
+D10 MOSI -   GPIO 18
+BUILTIN LED - GPIO 15
+"""
+
+# BUILTIN LED
+builtin = const(-15)     # BUILT IN LED - progress_led
+
+
+# I2C BUS
+i2c_sda = const(22)      # D4 - data
+i2c_scl = const(23)      # D5 - clock
+
+
+# EXTERNAL EVENT IRQ
+irq1 = const(21)         # D3 - event irq1 pin
+irq2 = const(2)          # D2 - event irq2 pin
+irq3 = const(1)          # D1 - event irq3 pin
+irq4 = const(0)          # D0 - event irq4 pin
+
+
+neop = const(18)         # D10 - neopixel OneWire bus [PWM]
+

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

@@ -1,7 +1,43 @@
 from micropython import const
 
+#### DEFINE CUSTOM PROGRESS LED LOGIC ####
+class WS2812:
+    NEOPIXEL = None
+    WHEEL = None
+    PIN = const(38)                                     # BUILT IN LED - progress_led
+
+try:
+    # init ws2812
+    from machine import Pin
+    from neopixel import NeoPixel
+    WS2812.NEOPIXEL = NeoPixel(Pin(WS2812.PIN), 1)
+except Exception as e:
+    print(f"[Error] IO error, esp21se ws2812: {e}")
+
+
+def _step_ws2812(pin=False):
+    if pin:
+        return WS2812.PIN
+
+    def _color_wheel():
+        while True:
+            yield 10, 0, 0
+            yield 5, 5, 0
+            yield 0, 10, 0
+            yield 0, 5, 5
+            yield 0, 0, 10
+            yield 5, 0, 5
+
+    if WS2812.WHEEL is None:
+        WS2812.WHEEL = _color_wheel()
+    WS2812.NEOPIXEL[0] = next(WS2812.WHEEL)
+    WS2812.NEOPIXEL.write()
+    return True  # No double-blink
+
+#######################################
+
 # BUILTIN LED
-builtin = const(38)     # BUILT IN LED - progress_led
+builtin = _step_ws2812     # BUILT IN LED - progress_led
 
 # ANALOG RGB + WW + CW
 redgb = const(37)      # - rgb red channel [PWM]

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

@@ -1,7 +1,41 @@
 from micropython import const
 
+#### DEFINE CUSTOM PROGRESS LED LOGIC ####
+class WS2812:
+    NEOPIXEL = None
+    WHEEL = None
+    PIN = const(21)                                     # BUILT IN LED - progress_led
+
+try:
+    # init ws2812
+    from machine import Pin
+    from neopixel import NeoPixel
+    WS2812.NEOPIXEL = NeoPixel(Pin(WS2812.PIN), 1)
+except Exception as e:
+    print(f"[Error] IO error, esp21se ws2812: {e}")
+
+
+def _step_ws2812(pin=False):
+    if pin:
+        return WS2812.PIN
+
+    def _color_wheel():
+        while True:
+            yield 10, 0, 0
+            yield 5, 5, 0
+            yield 0, 10, 0
+            yield 0, 5, 5
+            yield 0, 0, 10
+            yield 5, 0, 5
+
+    if WS2812.WHEEL is None:
+        WS2812.WHEEL = _color_wheel()
+    WS2812.NEOPIXEL[0] = next(WS2812.WHEEL)
+    WS2812.NEOPIXEL.write()
+    return True  # No double-blink
+
 # BUILTIN LED
-builtin = const(21)    # BUILT IN LED - progress_led
+builtin = _step_ws2812    # BUILT IN LED - progress_led
 
 # ANALOG RGB + WW + CW
 redgb = const(43)      # - rgb red channel [PWM]

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

@@ -1,20 +1,26 @@
 from micropython import const
-from machine import Pin
-
 
 #### DEFINE CUSTOM PROGRESS LED LOGIC ####
+class WS2812:
+    NEOPIXEL = None
+    WHEEL = None
+    PIN = const(5)                                      # BUILT IN LED - progress_led
+    PIN_ENABLE = const(8)                               # Power ON LED
+
 try:
+    # init ws2812
     from neopixel import NeoPixel
-    Pin(8, Pin.OUT).value(1)        # Power ON LED
-    PLED_OBJ = NeoPixel(Pin(5), 1)  # Init neopixel
-    NEO_WHEEL = None
+    from machine import Pin
+    Pin(WS2812.PIN_ENABLE, Pin.OUT).value(1)            # Power ON LED
+    WS2812.NEOPIXEL = NeoPixel(Pin(WS2812.PIN), 1)      # BUILT IN LED - progress_led
 except Exception as e:
-    print(f"[PLED CUSTOM] ws2812 error: {e}")
-    PLED_OBJ = None
+    print(f"[Error] IO error, esp21se ws2812: {e}")
+
 
+def _step_ws2812(pin=False):
+    if pin:
+        return WS2812.PIN
 
-def _step_ws2812():
-    global PLED_OBJ, NEO_WHEEL
     def _color_wheel():
         while True:
             yield 10, 0, 0
@@ -23,15 +29,14 @@ def _step_ws2812():
             yield 0, 5, 5
             yield 0, 0, 10
             yield 5, 0, 5
-    if PLED_OBJ is None:
-        return False
-    if NEO_WHEEL is None:
-        NEO_WHEEL = _color_wheel()
-    PLED_OBJ[0] = next(NEO_WHEEL)
-    PLED_OBJ.write()
-    return True
-###########################################
 
+    if WS2812.WHEEL is None:
+        WS2812.WHEEL = _color_wheel()
+    WS2812.NEOPIXEL[0] = next(WS2812.WHEEL)
+    WS2812.NEOPIXEL.write()
+    return True  # No double-blink
+
+###########################################
 
 # BUILTIN LED
 builtin = _step_ws2812

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

@@ -1,5 +1,43 @@
 from micropython import const
 
+#### DEFINE CUSTOM PROGRESS LED LOGIC ####
+class APA102:
+    DOTSTAR = None
+    COLOR_WHEEL = None
+    COLOR_INDEX:int = 0
+
+try:
+    # init apa102
+    from machine import Pin
+    from machine import SoftSPI
+    from dotstar import DotStar
+    from tinypico import DOTSTAR_CLK, DOTSTAR_DATA, SPI_MISO, set_dotstar_power, dotstar_color_wheel
+    spi = SoftSPI(sck=Pin(DOTSTAR_CLK), mosi=Pin(DOTSTAR_DATA), miso=Pin(SPI_MISO))
+    # Create a DotStar instance
+    APA102.DOTSTAR = DotStar(spi, 1, brightness=0.4)  # Just one DotStar, half brightness
+    # Turn on the power to the DotStar
+    set_dotstar_power(True)
+    APA102.COLOR_WHEEL = dotstar_color_wheel
+except Exception as e:
+    print(f"[Error] IO error, tinypico apa102: {e}")
+
+def _step_apa102(pin=False):
+    if pin:
+        return None
+    # Get the R,G,B values of the next colour
+    r, g, b = APA102.COLOR_WHEEL(APA102.COLOR_INDEX*2)
+    # Set the colour on the DOTSTAR
+    APA102.DOTSTAR[0] = (int(r * 0.6), g, b, 0.4)
+    # Increase the wheel index
+    APA102.COLOR_INDEX = 0 if APA102.COLOR_INDEX > 1000 else APA102.COLOR_INDEX + 2
+    return True                  # No double-blink
+
+###################################################
+
+
+# BUILTIN LED
+builtin = _step_apa102
+
 # ANALOG RGB + WW + CW
 redgb = const(25)       # D25 - rgb red channel [PWM CH1]
 rgreenb = const(26)     # D26 - rgb green channel [PWM CH2]