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

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

@@ -1,5 +1,5 @@
 from machine import Pin, PWM
-from microIO import physical_pin
+from microIO import bind_pin, PinMap
 from Common import SmartADC
 from random import randint
 
@@ -10,22 +10,24 @@ from random import randint
 
 class IObjects:
     PIN_OBJS = {}
+    DENY_TAG_INPUT = True
 
     @staticmethod
-    def _check_obj(pin, tag):
-        if IObjects.PIN_OBJS.get(pin, None) is None:
-            return False    # Obj not exists
-        elif IObjects.PIN_OBJS.get(pin)[0] != tag:
-            return False    # Obj not exists
-        return True         # Obj exists
+    def store_obj(pin:int, obj:object) -> None:
+        IObjects.PIN_OBJS[pin] = obj
 
     @staticmethod
-    def _store_obj(pin, tag, obj):
-        IObjects.PIN_OBJS[pin] = (tag, obj)
+    def get_obj(pin:int) -> object:
+        return IObjects.PIN_OBJS[pin]
 
     @staticmethod
-    def _get_obj(pin):
-        return IObjects.PIN_OBJS[pin][1]
+    def is_unassigned(pin_number):
+        return IObjects.PIN_OBJS.get(pin_number, None) is None
+
+    @staticmethod
+    def protect_builtins(pin_num, tag):
+        if pin_num is None and IObjects.DENY_TAG_INPUT:
+            raise Exception(f"pin must be integer not {type(tag)}: {tag}")
 
 
 ##################################
@@ -36,37 +38,39 @@ def __digital_out_init(pin):
     """
     Init Digital output
     """
-    if not isinstance(pin, int):
-        pin = physical_pin(pin)
-    if not IObjects._check_obj(pin, 'out'):
-        pin_obj = Pin(pin, Pin.OUT)
-        IObjects._store_obj(pin, 'out', pin_obj)
-    return IObjects._get_obj(pin)
+    pin_tag, pin = (pin, None) if isinstance(pin, str) else (f"OUT{pin}", pin)
+    IObjects.protect_builtins(pin, pin_tag)
+    pin_num = bind_pin(pin_tag, pin)
+    if IObjects.is_unassigned(pin_number=pin_num):
+        pin_obj = Pin(pin_num, Pin.OUT)
+        IObjects.store_obj(pin_num, pin_obj)
+    return IObjects.get_obj(pin_num)
 
 
 def __digital_in_init(pin):
     """
     Init Digital output
     """
-    if not isinstance(pin, int):
-        pin = physical_pin(pin)
-    if not IObjects._check_obj(pin, 'in'):
-        pin_obj = Pin(pin, Pin.IN, Pin.PULL_UP)
-        IObjects._store_obj(pin, 'in', pin_obj)
-    return IObjects._get_obj(pin)
+    pin_tag, pin = (pin, None) if isinstance(pin, str) else (f"IN{pin}", pin)
+    IObjects.protect_builtins(pin, pin_tag)
+    pin_num = bind_pin(pin_tag, pin)
+    if IObjects.is_unassigned(pin_number=pin_num):
+        pin_obj = Pin(pin_num, Pin.IN, Pin.PULL_UP)
+        IObjects.store_obj(pin_num, pin_obj)
+    return IObjects.get_obj(pin_num)
 
 
 def __pwm_init(pin, freq):
     """
     Init PWM signal
     """
-    if not isinstance(pin, int):
-        pin = physical_pin(pin)
-    tag = 'pwm{}'.format(freq)
-    if not IObjects._check_obj(pin, tag):
-        pin_obj = PWM(Pin(pin), freq=freq)
-        IObjects._store_obj(pin, tag, pin_obj)
-    return IObjects._get_obj(pin)
+    pin_tag, pin = (pin, None) if isinstance(pin, str) else (f"PWM{pin}", pin)
+    IObjects.protect_builtins(pin, pin_tag)
+    pin_num = bind_pin(pin_tag, pin)
+    if IObjects.is_unassigned(pin_number=pin_num):
+        pin_obj = PWM(Pin(pin_num), freq=freq)
+        IObjects.store_obj(pin_num, pin_obj)
+    return IObjects.get_obj(pin_num)
 
 
 ##################################
@@ -118,7 +122,10 @@ def get_adc(pin, key=None):
     :param key: select adc parameter by key
     :return dict: adc volt, percent, raw
     """
-    data = SmartADC.get_singleton(pin).get()
+    pin_tag, pin = (pin, None) if isinstance(pin, str) else (f"ADC{pin}", pin)
+    IObjects.protect_builtins(pin, pin_tag)
+    pin = bind_pin(pin_tag, pin)
+    data = SmartADC.get_instance(pin).get()
     data["pin"] = pin
     if key is None:
         return data
@@ -134,11 +141,17 @@ def get_in(pin):
     return {'pin': pin, 'state': __digital_in_init(pin).value()}
 
 
-def genio_pins():
+def load(allow_tags=False):
     """
-    Get used pins in genIO module
+    Optional load function to set
+    tag input besides pin numbers.
+    [WARNING] allow_tag=True can be dangerous
+    - it can overwrite existing I/O based on
+    the provided tag
+    :param allow_tag: default False
     """
-    return IObjects.PIN_OBJS
+    IObjects.DENY_TAG_INPUT = not allow_tags
+    return "[WARNING] allow_tag=True can be dangerous, use it consciously!!!" if allow_tags else "Loaded"
 
 
 #######################
@@ -156,4 +169,5 @@ def help(widgets=False):
            'set_random_pwm pin min_duty max_duty freq=20480)',\
            'set_out pin=<int> state=<None/True/False>',\
            'get_adc pin key=None',\
-           'get_in pin', 'genio_pins'
+           'get_in pin',\
+           'load allow_tags=False'

micrOS/source/modules/LM_haptic.py

@@ -0,0 +1,111 @@
+from microIO import bind_pin, pinmap_search
+from Types import resolve
+from machine import Pin, PWM
+from utime import sleep_ms
+
+class Haptic:
+    HAPTIC_OBJ = None
+    # Haptic vibration motor settings
+    LOW = 700
+    HIGH = 1000
+    STOP = 0
+    WAIT_TO_STOP_MS = 100
+    INTENSITY = "low"
+
+def load(intensity=None):
+    """
+    Init haptic engine
+    :param intensity: low / high / None haptic feedback intensity
+    """
+    if Haptic.HAPTIC_OBJ is None:
+        dimmer_pin = Pin(bind_pin('haptic'))
+        Haptic.HAPTIC_OBJ = PWM(dimmer_pin, freq=20480)
+        Haptic.HAPTIC_OBJ.duty(0)
+    if intensity in ("high", "low"):
+        Haptic.INTENSITY = intensity
+    return Haptic.HAPTIC_OBJ
+
+
+def tap():
+    """
+    Tap - buzz effect
+    """
+    haptic = load()
+    if Haptic.INTENSITY == "low":
+        haptic.duty(Haptic.LOW)
+        sleep_ms(150)
+        haptic.duty(Haptic.STOP)
+        return "Tap: low"
+    if Haptic.INTENSITY == "high":
+        haptic.duty(Haptic.HIGH)
+        sleep_ms(150)
+        haptic.duty(Haptic.STOP)
+        return "Tap: high"
+
+def gen(intensity=Haptic.LOW, wait=200, stop_wait=100, repeat=2):
+    """
+    Generate effect
+    :param intensity: 600-1000
+    :param wait: wait after intensity was set [ms]
+    :param stop_wait: wait for top the motor [ms]
+    :param repeat: repeat cycle
+    """
+    haptic = load()
+    for _ in range(repeat):
+        # Wait to run
+        haptic.duty(intensity)
+        sleep_ms(wait)
+        # Wait to stop
+        haptic.duty(0)
+        sleep_ms(stop_wait)
+    haptic.duty(0)
+    return f"finished: {(wait+stop_wait)*repeat}ms:{intensity}:{wait}:{repeat}"
+
+
+def effect1():
+    haptic = load()
+    haptic.duty(Haptic.HIGH)
+    sleep_ms(150)
+    haptic.duty(Haptic.LOW)
+    sleep_ms(100)
+    haptic.duty(Haptic.HIGH)
+    sleep_ms(100)
+    haptic.duty(Haptic.STOP)
+    return "finished: 350ms"
+
+
+def effect2():
+    haptic = load()
+    haptic.duty(Haptic.HIGH)
+    sleep_ms(150)
+    for i in range(Haptic.HIGH, 300, -100):
+        haptic.duty(i)
+        sleep_ms(50)
+    haptic.duty(Haptic.STOP)
+    return "finished: 400ms"
+
+
+def deinit():
+    Haptic.HAPTIC_OBJ.deinit()
+    Haptic.HAPTIC_OBJ = None
+    return "Deinited"
+
+
+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('haptic')
+
+
+def help(widgets=False):
+    return resolve(("load intensity='low/high'/None",
+                             "BUTTON tap",
+                             "BUTTON effect1",
+                             "BUTTON effect2",
+                             "gen max=<600-1000> wait=200 stop_wait=100 repeat=2",
+                             "deinit",
+                             "pinmap"), widgets=widgets)

micrOS/source/modules/LM_i2c.py

@@ -0,0 +1,61 @@
+from microIO import bind_pin, pinmap_search
+
+__I2C = None
+
+
+def __init():
+    global __I2C
+    if __I2C is None:
+        from machine import Pin, I2C
+        __I2C = I2C(-1, Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')))
+    return __I2C
+
+
+def scan():
+    """
+    I2C scan function - experimental
+    :return list: list of devices
+    """
+    devices = [ hex(device) for device in  __init().scan() ]
+    return devices
+
+
+def discover():
+    """
+    Discover devices
+    """
+    known_addresses = {hex(0x0A): "TRACKBALL", hex(0x3c): "OLED",
+                       hex(0x76): "BME280", hex(0x10): 'VEML7700',
+                       hex(0x6b): "QMI8658", hex(0x29): 'TCS3472'}
+    devices = scan()
+    output = {"unknown": []}
+    for k in devices:
+        if k in known_addresses:
+            device_name = known_addresses[k]
+            output[device_name] = k
+        else:
+            output["unknown"].append(k)
+    return output
+
+#######################
+# 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(['i2c_scl', 'i2c_sda'])
+
+
+def help(widgets=False):
+    """
+    [BETA][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 'scan', 'discover', 'pinmap'

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

@@ -1,16 +1,14 @@
 from ustruct import unpack
-from microIO import physical_pin, pinmap_dump
-from Common import micro_task, rest_endpoint
+from microIO import bind_pin, pinmap_search
+from Common import micro_task, web_endpoint, manage_task
 from machine import I2S, Pin
-from Debug import console_write
-from Tasks import TaskBase
 import uasyncio as asyncio
 
 
 class Data:
-    SCK_PIN = Pin(physical_pin('i2s_sck'))  # Serial clock
-    WS_PIN = Pin(physical_pin('i2s_ws'))    # Word select
-    SD_PIN = Pin(physical_pin('i2s_sd'))    # Serial data
+    SCK_PIN = Pin(bind_pin('i2s_sck'))  # Serial clock
+    WS_PIN = Pin(bind_pin('i2s_ws'))    # Word select
+    SD_PIN = Pin(bind_pin('i2s_sd'))    # Serial data
     I2S_CHANNEL = 1
     FORMAT = I2S.STEREO
     SAMPLING_RATE = 8000
@@ -26,7 +24,7 @@ class Data:
     CONTROL_TASK_TAG = 'i2s._mic_control'
     CONTROL_BUTTON_PIN = None
 
-    # To be initialized by load_n_init
+    # To be initialized by load
     I2S_AUDIO_IN = None
     SREADER = None
 
@@ -51,18 +49,18 @@ async def __control_task(ms_period=50):
     querying samples. Pushing the button again reinitializes the
     microphone without having to restart dependent load modules.
     """
-    with micro_task(tag=Data.CONTROL_TASK_TAG):
+    with micro_task(tag=Data.CONTROL_TASK_TAG) as my_task:
         while True:
             if Data.CONTROL_BUTTON_PIN.value():
                 Data.MIC_ENABLED = not Data.MIC_ENABLED
-                console_write(f'Microphone enabled: {Data.MIC_ENABLED}')
+                print(f'Microphone enabled: {Data.MIC_ENABLED}')
 
                 if Data.MIC_ENABLED:
-                    load_n_init()
+                    load()
 
                 # Debounce
-                await asyncio.sleep_ms(500)
-            await asyncio.sleep_ms(ms_period)
+                await my_task.feed(sleep_ms=500)
+            await my_task.feed(sleep_ms=ms_period)
 
 
 ###########################
@@ -78,7 +76,7 @@ async def __task(ms_period):
             recording_task.out = 'Capturing'
             while Data.MIC_ENABLED:
                 await Data.SREADER.readinto(sample_mv)
-                await asyncio.sleep_ms(ms_period)
+                await recording_task.feed(sleep_ms=ms_period)
             recording_task.out = 'Finished'
 
         except Exception as e:
@@ -96,8 +94,7 @@ def background_capture():
     if not Data.MIC_ENABLED:
         return "Microphone is disabled"
 
-    state = micro_task(tag=Data.TASK_TAG, task=__task(ms_period=1))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=Data.TASK_TAG, task=__task(ms_period=1))
 
 
 def get_from_buffer(capture_duration=Data.CAPTURE_DURATION,
@@ -139,8 +136,8 @@ async def _capture(capture_duration = Data.CAPTURE_DURATION,
     if not Data.MIC_ENABLED:
         return bytearray()
     
-    if TaskBase.is_busy(Data.TASK_TAG):
-        console_write('[i2s_mic] Warning: micro task is already running, capturing directly is not possible. '\
+    if manage_task(Data.TASK_TAG, 'isbusy'):
+        print('[i2s_mic] Warning: micro task is already running, capturing directly is not possible. '\
                       'Use get_from_buffer() instead.')
         return bytearray()
 
@@ -247,7 +244,7 @@ def set_volume(shift_size=0):
     Data.SHIFT_SIZE = shift_size
 
 
-def load_n_init(buf_length=Data.BUF_LENGTH, sampling_rate=Data.SAMPLING_RATE,
+def load(buf_length=Data.BUF_LENGTH, sampling_rate=Data.SAMPLING_RATE,
                 capture_duration=Data.CAPTURE_DURATION, shift_size = Data.SHIFT_SIZE,
                 sample_size = Data.SAMPLE_SIZE, i2s_channel = Data.I2S_CHANNEL,
                 default_channel = Data.DEFAULT_CHANNEL, sound_format = Data.FORMAT,
@@ -278,7 +275,7 @@ def load_n_init(buf_length=Data.BUF_LENGTH, sampling_rate=Data.SAMPLING_RATE,
     
     if control_button:
         micro_task(tag=Data.CONTROL_TASK_TAG, task=__control_task())
-        Data.CONTROL_BUTTON_PIN = Pin(physical_pin(control_button), Pin.IN)
+        Data.CONTROL_BUTTON_PIN = Pin(bind_pin(control_button), Pin.IN)
 
     Data.BUF_LENGTH = buf_length
     Data.SAMPLING_RATE = sampling_rate
@@ -296,7 +293,7 @@ def load_n_init(buf_length=Data.BUF_LENGTH, sampling_rate=Data.SAMPLING_RATE,
     Data.SREADER = asyncio.StreamReader(Data.I2S_AUDIO_IN)
 
     if enable_endpoint:
-        rest_endpoint('mic/stream', _record_clb)
+        web_endpoint('mic/stream', _record_clb)
 
     if Data.RECORD_TASK_ENABLED:
         background_capture()
@@ -315,7 +312,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['sck', 'ws', 'sd'])
+    return pinmap_search(['i2s_sck', 'i2s_ws', 'i2s_sd'])
 
 
 def help(widgets=False):
@@ -325,7 +322,7 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'load_n_init buf_length=16000 '\
+    return 'load buf_length=16000 '\
            'sampling_rate=8000 capture_duration=0.25 shift_size=6 '\
            'sample_size=16 i2s_channel=1 default_channel=\'right\' '\
            'sound_format=I2S.STEREO downsampling=1 control_button='' enable_endpoint=True',\

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

@@ -17,9 +17,9 @@
 
 from machine import Pin, UART
 import utime
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
 
-ser = UART(1, baudrate = 256000, tx=Pin(physical_pin('tx')), rx=Pin(physical_pin('rx')), timeout = 1)
+ser = UART(1, baudrate = 256000, tx=Pin(bind_pin('tx')), rx=Pin(bind_pin('rx')), timeout = 1)
 HEADER = bytes([0xfd, 0xfc, 0xfb, 0xfa])
 TERMINATOR = bytes([0x04, 0x03, 0x02, 0x01])
 NULLDATA = bytes([])
@@ -190,7 +190,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['tx', 'rx'])
+    return pinmap_search(['tx', 'rx'])
 
 
 def help(widgets=False):

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

@@ -5,14 +5,9 @@ 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
 """
-import uasyncio as asyncio
-from Common import SmartADC, micro_task
+from Common import SmartADC, micro_task, exec_cmd
 from Types import resolve
-try:
-    import LM_intercon as InterCon
-except:
-    InterCon = None
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
 
 
 ADC = None
@@ -24,10 +19,18 @@ def __init_tempt6000():
     """
     global ADC
     if ADC is None:
-        ADC = SmartADC(physical_pin('temp6000'))
+        ADC = SmartADC(bind_pin('temp6000'))
     return ADC
 
 
+def load():
+    """
+    Initialize TEMPT6000 light sensor module
+    """
+    __init_tempt6000()
+    return "TEMPT6000 light sensor module - loaded"
+
+
 def intensity():
     """
     Measure light intensity in %
@@ -69,21 +72,17 @@ async def _task(on, off, threshold, tolerance=2, check_ms=5000):
             # TURN ON
             if percent <= threshold:
                 if on != last_ev:
-                    if InterCon is not None:
-                        host = on[0]
-                        cmd = ' '.join(on[1:])
-                        InterCon.send_cmd(host, cmd)
-                    my_task.out = f"{percent}% <= threshold: {threshold}% - ON"
+                    host = on[0]
+                    state, _ = exec_cmd(on[1:] + [f">>{host}"], jsonify=True)
+                    my_task.out = f"{percent}% <= threshold: {threshold}% - ON [{'OK' if state else 'NOK'}]"
                     last_ev = on
             elif percent > threshold+tolerance:     # +tolerance to avoid "on/off/on/off" on threshold limit
                 if off != last_ev:
-                    if InterCon is not None:
-                        host = off[0]
-                        cmd = ' '.join(off[1:])
-                        InterCon.send_cmd(host, cmd)
-                    my_task.out = f"{percent}% > threshold: {threshold+tolerance}% - OFF"
+                    host = off[0]
+                    state, _ = exec_cmd(off[1:] + [f">>{host}"], jsonify=True)
+                    my_task.out = f"{percent}% > threshold: {threshold+tolerance}% - OFF [{'OK' if state else 'NOK'}]"
                     last_ev = off
-            await asyncio.sleep_ms(check_ms)        # Sample every <check_ms> sec
+            await my_task.feed(sleep_ms=check_ms)   # Sample every <check_ms> sec
 
 
 def subscribe_intercon(on, off, threshold=4, tolerance=2, sample_sec=60):
@@ -97,11 +96,8 @@ def subscribe_intercon(on, off, threshold=4, tolerance=2, sample_sec=60):
     """
     # Start play - servo XY in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag="light_sensor.intercon", task=_task(on, off, threshold, tolerance=tolerance,
+    return micro_task(tag="light_sensor.intercon", task=_task(on, off, threshold, tolerance=tolerance,
                                                                check_ms=sample_sec*1000))
-    if state:
-        return 'Light sensor remote trigger starts'
-    return 'Light sensor remote trigger - already running'
 
 
 #######################
@@ -115,7 +111,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump('temp6000')
+    return pinmap_search('temp6000')
 
 
 def help(widgets=False):
@@ -126,6 +122,6 @@ def help(widgets=False):
         (widgets=True) list of widget json for UI generation
     """
     return resolve(('TEXTBOX intensity', 'TEXTBOX illuminance',
-                             'subscribe_intercon on off threshold=1 tolerance=2 sample_sec=60',\
-                             'pinmap', 'INFO sensor:TEMP600'), widgets=widgets)
+                             'subscribe_intercon on off threshold=1 tolerance=2 sample_sec=60',
+                             'pinmap', 'load', '[Info] sensor:TEMP600'), widgets=widgets)