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

micrOS/source/micrOS.py

@@ -4,39 +4,36 @@ 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 SocketServer
-from Interrupts import enableInterrupt, enableCron
-from Interrupts import initEventIRQs
-from Debug import errlog_add
+from Server import Server
+from Interrupts import enableInterrupt, enableCron, initEventIRQs
+from Debug import syslog
 
 
 #################################################################
 #            INTERRUPT HANDLER INTERFACES / WRAPPERS            #
 #################################################################
 
-
-def safe_boot():
-    try:
-        bootup()
-    except Exception as e:
-        print(f"[micrOS main] Hooks.boot() error: {e}")
-        errlog_add(f"[ERR] safe_boot: {e}")
-
-
 def irq_handler():
     try:
         enableInterrupt()
         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():
@@ -44,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}")
 
 
 #################################################################
@@ -59,7 +56,11 @@ def micrOS():
     aio = Manager()
 
     # BOOT TASKS: Initial LM executions
-    safe_boot()
+    try:
+        bootup()
+    except Exception as e:
+        print(f"[micrOS main] Hooks.boot() error: {e}")
+        syslog(f"[ERR] safe_boot: {e}")
 
     # NETWORK setup
     nwmd = auto_nw_config()
@@ -78,12 +79,15 @@ def micrOS():
     # SET interrupt with timirqcbf from nodeconfig
     irq_handler()
 
-    # [SocketServer] as async task
-    aio.create_task(SocketServer().run_server(), tag='server')
-    profiling_info(label='[memUsage] SYSTEM IS UP')
+    # [Server] as async task
+    aio.create_task(Server().run_server(), tag='server')
+
+    # [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,14 +12,10 @@ try:
     import traceback
 except:
     traceback = None
-try:
-    from Debug import errlog_add
-except Exception as e:
-    print(f"Import error: {e}")
-    errlog_add = None
+from machine import reset
 
 
-def __is_micrOS():
+def _is_micrOS():
     """
     Recovery mode for OTA update in case of connection/transfer failure
         .if_mode can have 2 possible values: webrepl or micros (strings)
@@ -34,7 +31,6 @@ def __is_micrOS():
         False -> webrepl
         * EOE (EndOfExecution) -> off
     """
-    mode = 'micros'
     try:
         with open('.if_mode', 'r') as f:
             mode = f.read().strip().lower()
@@ -54,12 +50,13 @@ def __is_micrOS():
         exit(0)
     # start webrepl
     print("[loader][if_mode:False] .if_mode:webrepl -> webrepl interface")
-    print("[loader][recovery mode] - manually selected in .if_mode file")
     return False
 
 
 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
@@ -71,7 +68,11 @@ def __recovery_mode():
         import webrepl
         webrepl.start(password=pwd)
     except Exception as e:
-        print(f"Webrepl import error: {e}")
+        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():
@@ -82,10 +83,6 @@ def __auto_restart_event():
             - value: micros     [update was successful - reboot is necessary]
     :return:
     """
-    from sys import platform
-    if platform == 'rp2':
-        print("[loader][ota-rebooter] SKIP on platform: rp2 (webrepl block)")
-        return
 
     from utime import sleep
     trigger_is_active = False
@@ -93,7 +90,7 @@ def __auto_restart_event():
     # Wait after webrepl started for possible ota updates (~3s*5= 15sec)
     while wait_update_tout > 0:
         # Wait for micros turns to webrepl until timeout
-        if __is_micrOS():
+        if _is_micrOS():
             # micrOS mode
             print(f"[loader][ota-rebooter][micros][{wait_update_tout}] Wait for OTA update possible start")
             wait_update_tout -= 1
@@ -102,19 +99,18 @@ def __auto_restart_event():
             # Set trigger  - if_mode changed to webrepl - ota update started - trigger wait
             trigger_is_active = True
         # Restart if trigger was activated
-        if trigger_is_active and __is_micrOS():
+        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
-            from machine import reset
             reset()
         sleep(3)
 
 
 def main():
-    if __is_micrOS():
+    if _is_micrOS():
         # Main mode
         try:
             print("[loader][main mode] Start micrOS (default)")
@@ -126,11 +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 errlog_add is not None:
-                try:
-                    errlog_add(f"[ERR][micrOSloader] start failed: {e}")
-                except:
-                    pass
     # 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,9 @@ 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
 
 #################################################################
 #                        GPI/O ON DEVICE                        #
@@ -27,24 +30,25 @@ def detect_platform():
     """
     Unified platform detection for micrOS
     """
-    if 'esp32' in platform:
-        from os import uname
-        board = uname()[-1]
-        if 'tinypico' in str(board).lower():
-            return 'tinypico'    # esp32 family - tinypico
-        if 'esp32s2' in str(board).lower():
-            return 'esp32s2'     # esp32 family - esp32S2
-        if 'esp32s3' in str(board).lower():
-            return 'esp32s3'     # esp32 family - esp32s3
-        if 'esp32c3' in str(board).lower():
-            return 'esp32c3'     # esp32 family - esp32c3
-        return 'esp32'           # esp32 family - general
+    if 'esp32' in platform:     # esp32 family
+        board = str(uname()[-1]).lower()
+        if 'tinypico' in board:
+            return 'tinypico'
+        if 'esp32s2' in board:
+            return 'esp32s2'
+        if 'esp32s3' in board:
+            return 'esp32s3'
+        if 'esp32c3' in board:
+            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:
@@ -53,99 +57,132 @@ def set_pinmap(map_data=None):
         u.c.3: esp32; dht:10; neop:15       - selected LP + manual overwrite pins
     """
 
-    # HANDLE PIN MAP PARAMS (lp_name + custom pin lut)
+    # HANDLE PIN MAP PARAMS (io_file + custom pin lut)
     parsed_data = ["n/a"] if map_data is None else map_data.strip().split(';')
-    lp_name = "n/a" if ':' in parsed_data[0] else parsed_data.pop(0)
+    io_file = "n/a" if ':' in parsed_data[0] else parsed_data.pop(0)
     # SAVE PARSED CUSTOM PIN OVERWRITE (manual mapping - MAPPING)
     try:
         PinMap.MAPPING = {pin.split(':')[0].strip(): int(pin.split(':')[1].strip()) for pin in parsed_data if ':' in pin}
     except Exception as e:
-        # PARSE ERROR !!!
-        print(f"[io] custom pin key(s) parse error: {e}")
+        syslog(f"[io] custom pin key(s) parse error: {e}")
 
     # SELECT LOOKUP TABLE BASED ON PLATFORM / User input
-    if isinstance(lp_name, str) and lp_name != 'n/a':
-        if f"IO_{lp_name}" in [lp.split('.')[0] for lp in listdir() if lp.startswith('IO_')]:
-            PinMap.MAPPING_LUT = lp_name
+    if isinstance(io_file, str) and io_file != 'n/a':
+        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 physical_pin(key):
+def resolve_pin(tag:str) -> int:
     """
-    Used in LoadModules
-    key - resolve pin number by logical name (like: switch_1)
-    This function implements protected IO allocation (overload protection)
-     for protected LM functions (IO-booking)
+    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 aka logical pin
-    pin_num = __resolve_pin_number(key)
+    # Get pin number on platform by pin key/name
+    pin_num = __resolve_pin(tag)
     if isinstance(pin_num, int):
         # Check pin is already used
         if pin_num in PinMap.IO_USE_DICT:
             key_cache = PinMap.IO_USE_DICT[pin_num]
-            if key_cache == key:
-                print(f"[io] ReInit pin: {key_cache}:{pin_num}")
-                return pin_num
-            msg = f"[io] Pin {key} is busy: {key_cache}:{pin_num}"
-            raise Exception(msg)
-        # key: pin number, value: pin key (alias)
-        PinMap.IO_USE_DICT[pin_num] = key
-        print(f"[io] Init pin: {key}:{pin_num}")
+            if key_cache == tag:
+                return pin_num      # [io] ENABLE ReInit pin with same tag name
+            raise Exception(f"[io] Pin {tag} is busy: {key_cache}:{pin_num}")
+        # tag: pin number, value: pin tag (alias)
+        PinMap.IO_USE_DICT[pin_num] = tag
+        print(f"[io] Init pin: {tag}:{pin_num}")
     return pin_num
 
 
-def get_pinmap():
+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
+    return: pin number
+    """
+    allocated_tag = PinMap.IO_USE_DICT.get(number, None)
+    if allocated_tag is None:
+        # Save custom pin - same as cstmpmap config param
+        PinMap.MAPPING[tag] = number
+        # Save pin number as used - same as resolve_pin does
+        PinMap.IO_USE_DICT[number] = tag
+    else:
+        reg_tag = PinMap.IO_USE_DICT.get(number)
+        if tag != reg_tag: # detect conflict
+            raise Exception(f"[io-register] {tag}:{number} already in use: {reg_tag}")
+    return number
+
+
+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_dump(keys):
+def pinmap_search(keys):
     """
-    keys: one or list of pin names (like: switch_1) to resolve physical pin number
-    Gives information where to connect the selected periphery to control
-    DO NOT USE RETURNED PIN NUMBERS FOR FUNC ALLOCATION IN LMs!!!
-    - USE: physical_pin function for protected IO allocation (overload protection)
+    :param keys: one or list of pin names (like: switch_1) to resolve physical pin number
+    Gives information where to connect the selected periphery to control WITHOUT PIN BOOKING
     """
     if isinstance(keys, str):
-        try:
-            num = __resolve_pin_number(keys)
-        except:
-            num = None
-        return {keys: num}
+        keys = [keys]
     pins_cache = {}
     for pin_name in keys:
         try:
-            num = __resolve_pin_number(pin_name)
+            num = __resolve_pin(pin_name)
         except:
             num = None
         pins_cache[pin_name] = num
     return pins_cache
 
 
-def __resolve_pin_number(key):
+def __resolve_pin(name:str):
     """
     Dynamic const lookup table handling by var name
-    :param key: logical pin name, example: neop, dht, etc.
+    :param name: logical pin name, example: neop, dht, etc.
     """
-    custom_pin = PinMap.MAPPING.get(key, None)          # Get user custom pin map (if any)
+    custom_pin = PinMap.MAPPING.get(name, None)          # Get user custom pin map (if any)
     if custom_pin is None:
         # [1] Handle default pin resolve from static lut
         mio = f'IO_{PinMap.MAPPING_LUT}'
         try:
             exec(f'import {mio}')
             # GET KEY PARAM VALUE
-            out = eval(f'{mio}.{key}')
+            out = eval(f'{mio}.{name}')
             # Workaround to support normal python (tuple output), micropython (exact output - int)
             return int(out[0]) if isinstance(out, tuple) else out
         except Exception as e:
             # Missing LP module - don't die
             if "No module named" in str(e):
                 return None
-            # Other issue (key not found, etc...)
+            # Other issue (name not found, etc...)
+            syslog(f"[ERR] io-resolve {name}: {e}")
             raise Exception(f"[io-resolve] error: {e}")
     # [2] Handle user custom pins from cstmpmap (overwrite default)
     return custom_pin

toolkit/simulator_lib/LP_darwin.py → micrOS/source/modules/IO_esp32.py

@@ -44,15 +44,25 @@ stppr_4 = const(27)    # D27 - stepper motor pin
 
 
 # I2C BUS
-i2c_sda = const(21)    # D22 - oled - data
-i2c_scl = const(22)    # D21 - oled - clock
+i2c_sda = const(21)    # D21 - oled - data
+i2c_scl = const(22)    # D22 - oled - clock
+# I2S BUS
+i2s_sck = const(26)    # Serial clock
+i2s_ws = const(25)     # Word select
+i2s_sd = const(33)     # Serial data
 
 
 # EXTERNAL EVENT IRQ
-irq1 = const(4)        # D4  - event irq pin
-irq2 = const(18)       # D18 - event irq pin
-irq3 = const(5)        # D19  - event irq pin
-irq4 = const(13)       # D13  - event irq pin
+irq1 = const(4)         # D4  - event irq pin
+irq2 = const(18)        # D18 - event irq pin
+irq3 = const(5)         # D19  - event irq pin
+irq4 = const(13)        # D13  - event irq pin
+
+js_right = const(4)     # oled_ui joystick
+js_left = const(18)
+js_up = const(5)
+js_down = const(13)
+js_press = const(34)    # oled_ui center/ok button
 
 touch_0 = const(13)    # D13 - touch sensor TODO
 
@@ -61,9 +71,10 @@ touch_0 = const(13)    # D13 - touch sensor TODO
 hcsrtrig = const(32)   # D32 - distance HCSR04 trigger pin
 hcsrecho = const(35)   # D35 - distance HCSR04 echo pin
 dhtpin = const(32)     # D32 - dht_pin 11 and 22
-co2 = const(35)        # D35 - CO2
-temp6000 = const(36)   # VP - light sensor TEMP6000
-ph = const(39)         # VN - PH sensor
+co2 = const(35)        # D35 - [ADC] CO2
+temp6000 = const(36)   # VP  - [ADC] light sensor TEMP6000
+ph = const(39)         # VN  - [ADC] PH sensor
 ds18 = const(19)       # D19 - DS18B20 - temp. sensor
-
-mic = const(39)
+mic = const(39)        # VN  - [ADC] microphone
+rot_dt = const(13)      # [IRQ] rotary encoder data
+rot_clk = const(12)     # [IRQ] rotary encoder clock

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

@@ -34,7 +34,12 @@ irq1 = const(5)          # event irq pin
 irq2 = const(6)          # event irq pin
 irq3 = const(7)          # event irq pin
 irq4 = const(8)          # event irq pin
-oleduibttn = const(20)   # oled_ui center/ok button
+
+js_right = const(5)      # oled_ui joystick
+js_left = const(6)
+js_up = const(7)
+js_down = const(8)
+js_press = const(20)     # oled_ui center/ok button
 
 # I2C BUS
 i2c_sda = const(8)       # oled - data

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_esp32s2.py → modules/IO_esp32s2.py}

@@ -52,7 +52,12 @@ irq1 = const(39)         # event irq pin
 irq2 = const(37)         # event irq pin
 irq3 = const(35)         # event irq pin
 irq4 = const(33)         # event irq pin
-oleduibttn = const(34)   # oled_ui center/ok button
+
+js_right = const(39)      # oled_ui joystick
+js_left = const(37)
+js_up = const(35)
+js_down = const(33)
+js_press = const(34)     # oled_ui center/ok button
 
 
 # SENSORS

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]
@@ -57,7 +93,12 @@ irq1 = const(45)        # - event irq pin
 irq2 = const(48)        # - event irq pin
 irq3 = const(47)        # - event irq pin
 irq4 = const(21)        # - event irq pin
-oleduibttn = const(20)  # - oled_ui center/ok button
+
+js_right = const(45)      # oled_ui joystick
+js_left = const(48)
+js_up = const(47)
+js_down = const(21)
+js_press = const(20)     # oled_ui center/ok button
 
 touch_0 = const(0)     # - touch sensor TODO