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

micrOS/source/modules/LM_L298N.py

@@ -0,0 +1,161 @@
+from machine import Pin, PWM
+from microIO import bind_pin, pinmap_search
+
+
+# Cache of last set motor speeds (motor1, motor2) to ensure state() reports the latest values
+# even if hardware PWM duty readout is delayed or unsupported on some boards
+__MOTOR_SPEEDS = [0, 0] # motor1, motor2
+__L298N_OBJS = []
+
+PWM_FREQ = 50
+# Deprecated LM_L298N_DCmotor: l298speed, l298dir_1, l298dir_2
+PIN_BINDINGS = [
+    ('l298n_ENA', 10), ('l298n_INA', 12), ('l298n_INB', 11),  # motor 1
+    ('l298n_ENB', 3),  ('l298n_INC', 9),  ('l298n_IND', 40),  # motor 2
+]
+STATE_MAP = {
+    (1, 0): 'forward',
+    (0, 1): 'backward',
+    (0, 0): 'coast',
+    (1, 1): 'brake'
+}
+
+
+def __l298n_init():
+    global __L298N_OBJS
+    if not __L298N_OBJS:
+        for index, (name, pin) in enumerate(PIN_BINDINGS):
+            if index % 3 == 0: # PWM pin
+                pwm = PWM(bind_pin(name, pin), freq=PWM_FREQ)
+                pwm.duty(0)
+                __L298N_OBJS.append(pwm)
+            else:
+                p = Pin(bind_pin(name, pin), Pin.OUT)
+                p.value(0)
+                __L298N_OBJS.append(p)
+    return __L298N_OBJS
+
+
+def __get_motor_state(motor_index):
+    objlist = __l298n_init()
+    pwm_index = motor_index * 3
+    in1, in2 = objlist[pwm_index + 1].value(), objlist[pwm_index + 2].value()
+    state = STATE_MAP.get((in1, in2), 'unknown')
+    return {'speed': __MOTOR_SPEEDS[motor_index], 'state': state}
+
+
+#########################
+# Application functions #
+#########################
+
+def load(pwm_freq:int=None):
+    """
+    [i] micrOS LM naming convention
+    Load the L298N motor driver module
+    """
+    global PWM_FREQ
+    if pwm_freq is not None:
+        PWM_FREQ = pwm_freq
+    __l298n_init()
+    return "Motor driver loaded successfully."
+
+
+def state(motor=0):
+    """
+    [i] micrOS LM naming convention
+    Get the current state of a motor or all motors
+    :param motor: Motor number (1 or 2) or None for all motors
+    """
+    if motor == 1:
+        return {'motor1': __get_motor_state(0)}
+    elif motor == 2:
+        return {'motor2': __get_motor_state(1)}
+    else:
+        return {
+            'motor1': __get_motor_state(0),
+            'motor2': __get_motor_state(1)
+        }
+
+
+def _control_motor(motor, in1, in2):
+    objlist = __l298n_init()
+    motor_index = 0 if motor == 1 else 3
+    objlist[motor_index + 1].value(in1)
+    objlist[motor_index + 2].value(in2)
+
+
+def speed(motor, speed:int=1023):
+    """
+    Set the speed of a motor
+    :param motor: Motor number (1 or 2)
+    :param speed: Speed value (0-1023)
+    :return: Current motor state
+    """
+    if not (0 <= speed <= 1023):
+        return {'speed': 'value range error'}
+    pwm_index = 0 if motor == 1 else 3
+    motor_index = 0 if motor == 1 else 1
+    __l298n_init()[pwm_index].duty(speed)
+    __MOTOR_SPEEDS[motor_index] = speed
+    return state(motor)
+
+
+def direction(motor, forward: bool=True):
+    """
+    Set the direction of a motor
+    :param motor: Motor number (1 or 2)
+    :param forward: True if motor should move forward, False if backward
+    :return: Current motor state
+    """
+    _control_motor(motor, 1 if forward else 0, 0 if forward else 1)
+    return state(motor)
+
+
+def coast(motor):
+    """
+    Coast the motor
+    :param motor: Motor number (1 or 2)
+    """
+    _control_motor(motor, 0, 0)
+    return state(motor)
+
+
+def brake(motor):
+    """
+    Brake the motor
+    :param motor: Motor number (1 or 2)
+    :return: Current motor state
+    """
+    _control_motor(motor, 1, 1)
+    return state(motor)
+
+
+#######################
+# 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([name for name, _ in PIN_BINDINGS])
+
+
+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 (
+        'speed motor=<1/2> speed=<0-1023>', 
+        'direction motor=<1/2> forward=<True/False>',
+        'coast motor=<1/2>',
+        'brake motor=<1/2>',
+        'state motor=<0/1/2>',
+        'pinmap'
+    )

{toolkit/workspace/precompiled → micrOS/source/modules}/LM_L9110_DCmotor.py

@@ -1,4 +1,4 @@
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin,  pinmap_search
 
 #########################################
 #     ANALOG DIMMER CONTROLLER PARAMS   #
@@ -15,8 +15,8 @@ def __l9110_init():
     global __L9110_OBJS
     if len(__L9110_OBJS) == 0:
         from machine import Pin, PWM
-        __L9110_OBJS.append(PWM(Pin(resolve_pin('l9110dir_1')), freq=1024))
-        __L9110_OBJS.append(PWM(Pin(resolve_pin('l9110dir_2')), freq=1024))
+        __L9110_OBJS.append(PWM(Pin(bind_pin('l9110dir_1')), freq=1024))
+        __L9110_OBJS.append(PWM(Pin(bind_pin('l9110dir_2')), freq=1024))
         __L9110_OBJS[0].duty(0)     # Set default speed (PWM)
         __L9110_OBJS[1].duty(0)     # Set default speed (PWM)
     return __L9110_OBJS

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

@@ -2,8 +2,9 @@ try:
     import camera
 except Exception as e:
     camera = None
-import time
-from Common import web_endpoint, syslog
+from time import localtime, sleep
+from json import loads
+from Common import web_endpoint, syslog, exec_cmd
 from Types import resolve
 
 IN_CAPTURE = False      # Make sure single capture in progress in the same time
@@ -44,7 +45,7 @@ def load(quality='medium', freq='default', effect="NONE"):
         except Exception as e:
             syslog(f"[ERR] OV2640: {e}")
         camera.deinit()
-        time.sleep(1)
+        sleep(1)
     if not CAM_INIT:
         return "Cannot init OV2640 cam"
 
@@ -57,6 +58,8 @@ def _set_web_endpoints():
     # Register rest endpoint
     web_endpoint('cam/snapshot', _snapshot_clb)
     web_endpoint('cam/stream', _image_stream_clb)
+    web_endpoint('cam/photo', lambda: ('text/plain', photo()))
+    return "Endpoint created: /cam/snapshot, /cam/stream, /cam/photo"
 
 
 def settings(quality=None, flip=None, mirror=None, effect=None, saturation=None, brightness=None, contrast=None, whitebalace=None, q=None):
@@ -152,24 +155,54 @@ def capture():
             if buf:
                 break
             n_try += 1
-            time.sleep(0.1)
+            sleep(0.1)
     except Exception as e:
         syslog(f"[OV2640] Failed to capture: {e}")
     IN_CAPTURE = False
     return buf
 
 
-def photo(name='photo.jpg'):
-    buf = capture()
-    with open(name, 'w') as f:
+def photo(name='photo.jpeg'):
+    """
+    Beta feature - with storage limit
+    Create photo and save it under /web/<user_data>
+    """
+    def _storage_check(storage_limit=60):
+        _status, _usage = exec_cmd(cmd=['fileserver', '_disk_usage_clb'], jsonify=False, secure=True)
+        if not _status:
+            return False, f"Cannot get storage info: {_usage}"
+        # Eval hack to be able to reuse web endpoint callback for disk usage
+        usage = loads(str(eval(_usage)[-1]))
+        usage_percent = int((usage.get("used", 0) / (usage.get("free", 0) + usage.get("used", 0))) * 100)
+        print(usage_percent)
+        if usage_percent > storage_limit:
+            return False, f"Storage is full < {storage_limit}%"
+        return True, ""
+
+    status, path = exec_cmd(cmd=['fileserver', 'get_user_dir'], jsonify=False, secure=True)
+    if not status:
+        return "No shared path available: fileserver get_user_dir"
+    s, v = _storage_check()
+    if not s:
+        return v
+    t = localtime()
+    ts = "{:02d}{:02d}{:02d}-{:02d}{:02d}{:02d}".format(t[0] % 100, t[1], t[2], t[3], t[4], t[5])
+    # Create file name with time stamp
+    photo_path = f"{path}/{ts}-{name}"
+    # Take a Photo
+    _ = capture()       # Dump current cached image
+    buf = capture()     # Create new image
+    # Save the Photo
+    with open(photo_path, 'wb') as f:
         if buf:
             f.write(buf)
-            return "Image saved as photo.jpg"
-    return "Cannot save... photo.jpg"
+            return f"Image saved as {photo_path}"
+    return f"Cannot save... {photo_path}"
 
 
 def _snapshot_clb():
-    image = capture()
+    _ = capture()       # Dump current cached image
+    image = capture()   # Take new image
     if image is not None:
         return 'image/jpeg', image
     return 'text/plain', f'capture error: {image}'
@@ -179,21 +212,7 @@ def _image_stream_clb():
     return 'multipart/x-mixed-replace', {'callback': capture, 'content-type': 'image/jpeg'}
 
 
-def _img_clb(name="photo.jpg"):
-    with open(name, 'rb') as f:
-        image = f.read()
-    return 'image/jpeg', image
-
-
-def set_photo_endpoint():
-    """
-    Set photo endpoint (rest endpoint)
-    """
-    web_endpoint('photo', _img_clb)
-    return "Endpoint created: /photo"
-
-
-def __light_init():
+def _light_init():
     global FLASH_LIGHT
     if FLASH_LIGHT is None:
         from machine import Pin
@@ -205,7 +224,7 @@ def flashlight(state=None):
     Camera flashlight
     :param state: True/False/None(automatic)
     """
-    fl = __light_init()
+    fl = _light_init()
     if state is None:
         state = fl.value(not fl.value())
     else:
@@ -228,7 +247,6 @@ def help(widgets=False):
         'BUTTON settings effect=<NONE,NEG,BW,RED,GREEN,BLUE,RETRO>',
         'capture',
         'photo',
-        'set_photo_endpoint',
         'BUTTON flashlight state=None',
         '[Hint] after load you can access the /cam/snapshot and /cam/stream endpoints',
         'Thanks to :) https://github.com/lemariva/micropython-camera-driver'), widgets=widgets)

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

@@ -2,7 +2,7 @@ from micropython import const
 import ustruct
 import utime
 from machine import I2C, Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 
 __TOF_OBJ = None
 
@@ -31,7 +31,7 @@ class TimeoutError(RuntimeError):
 
 class VL53L0X:
     def __init__(self, address=57):
-        self.i2c = I2C(-1, Pin(resolve_pin('i2c_scl')), Pin(resolve_pin('i2c_sda')), freq=9600)
+        self.i2c = I2C(-1, Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')), freq=9600)
         self.address = address
         self.init()
         self._started = False
@@ -343,7 +343,7 @@ class VL53L0X:
 
 def measure():
     """
-    Experimental
+    Experimental - Time of Flight Distance Sensor
     """
     global __TOF_OBJ
     if __TOF_OBJ is None:

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

@@ -1,5 +1,5 @@
 from machine import I2C, Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import syslog
 from time import sleep
 from binascii import hexlify
@@ -24,7 +24,7 @@ def _handle_connection_error(f):
 
 class AHT10:
     def __init__(self, address = 0x38):
-        self.i2c = I2C(-1, Pin(resolve_pin('i2c_scl')), Pin(resolve_pin('i2c_sda')), freq = 9600)
+        self.i2c = I2C(-1, Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')), freq = 9600)
         self.address = address
         if not self.init_sensor():
             raise Exception("Could not initialize the sensor!")

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

@@ -6,7 +6,7 @@ https://randomnerdtutorials.com/micropython-bme280-esp32-esp8266/
 
 import utime as time
 from machine import Pin, I2C
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import notify
 from Types import resolve
 
@@ -299,7 +299,7 @@ class BME280:
 def __init_bme280_i2c():
     global BME280_OBJ
     if BME280_OBJ is None:
-        i2c = I2C(scl=Pin(resolve_pin('i2c_scl')), sda=Pin(resolve_pin('i2c_sda')), freq=10000)
+        i2c = I2C(scl=Pin(bind_pin('i2c_scl')), sda=Pin(bind_pin('i2c_sda')), freq=10000)
         BME280_OBJ = BME280(i2c=i2c)
     return BME280_OBJ
 
@@ -349,5 +349,5 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return resolve(('TEXTBOX measure ntfy=False',
+    return resolve(('TEXTBOX{"refresh": 2000} measure ntfy=False',
                              'load', 'pinmap'), widgets=widgets)

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

@@ -1,7 +1,6 @@
-from sys import platform
 from utime import sleep
-from microIO import resolve_pin, pinmap_search
-from Common import micro_task, notify
+from microIO import bind_pin, pinmap_search
+from Common import micro_task, notify, data_dir
 from Types import resolve
 
 
@@ -13,6 +12,7 @@ __BUZZER_OBJ = None
 __BUZZER_CACHE = [600]
 __PERSISTENT_CACHE = False
 __TASK_TAG = "buzzer._play"
+__FILE_CACHE = data_dir('buzzer.cache')
 CHECK_NOTIFY = False
 
 #########################################
@@ -175,22 +175,22 @@ def _builtin_tones(tone=None):
 #########################################
 
 
-def __buzzer_init():
+def __buzzer_init(pin=None):
+    """
+    :param pin: optional number to overwrite default pin
+    """
     global __BUZZER_OBJ
     if __BUZZER_OBJ is None:
         from machine import Pin, PWM
-        dimmer_pin = Pin(resolve_pin('buzzer'))
-        if platform == 'esp8266':
-            __BUZZER_OBJ = PWM(dimmer_pin, freq=600)
-        else:
-            __BUZZER_OBJ = PWM(dimmer_pin, freq=600)
+        dimmer_pin = Pin(bind_pin('buzzer', number=pin))
+        __BUZZER_OBJ = PWM(dimmer_pin, freq=600)
         __BUZZER_OBJ.duty(512)      # 50%
     return __BUZZER_OBJ
 
 
 def __persistent_cache_manager(mode='r'):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
@@ -199,12 +199,12 @@ def __persistent_cache_manager(mode='r'):
     global __BUZZER_CACHE
     if mode == 's':
         # SAVE CACHE
-        with open('buzzer.pds', 'w') as f:
+        with open(__FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in __BUZZER_CACHE]))
         return
     try:
         # RESTORE CACHE
-        with open('buzzer.pds', 'r') as f:
+        with open(__FILE_CACHE, 'r') as f:
             __BUZZER_CACHE = [int(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -270,10 +270,7 @@ def play(rtttlstr='Indiana'):
     global CHECK_NOTIFY
     if CHECK_NOTIFY and not notify():
         return "NoBipp - notify off"
-    state = micro_task(tag=__TASK_TAG, task=_play(rtttlstr))
-    if state:
-        return 'Play song'
-    return 'Song already playing'
+    return micro_task(tag=__TASK_TAG, task=_play(rtttlstr))
 
 
 def list_tones():
@@ -283,23 +280,19 @@ def list_tones():
     return '\n'.join(list(_builtin_tones()))
 
 
-def load(cache=None, check_notify=False):
+def load(check_notify=False, pin=None, cache=True):
     """
     Initialize buzzer module
-    :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
-    - Apply loaded states to gpio pins (boot function)
     :param check_notify: check notify enabled/disabled - make noise if enabled only
+    :param pin: optional number to overwrite default pin
+    :param cache: default True, store stages on disk (.cache)
     :return str: Verdict
     """
-    from sys import platform
     global __PERSISTENT_CACHE, CHECK_NOTIFY
-    if cache is None:
-        __PERSISTENT_CACHE = False if platform == 'esp8266' else True
-    else:
-        __PERSISTENT_CACHE = cache
+    __PERSISTENT_CACHE = cache
     __persistent_cache_manager('r')
     CHECK_NOTIFY = check_notify
+    __buzzer_init(pin=pin)
     return f"CACHE: {__PERSISTENT_CACHE}, check notify: {CHECK_NOTIFY}"
 
 

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

@@ -4,8 +4,8 @@
 from machine import Pin, PWM
 from sys import platform
 from utime import sleep_ms
-from Common import transition_gen, micro_task
-from microIO import resolve_pin, pinmap_search
+from Common import transition_gen, micro_task, data_dir
+from microIO import bind_pin, pinmap_search
 from random import randint
 from Types import resolve
 
@@ -18,16 +18,17 @@ class Data:
     CCT_TASK_TAG = 'cct._tran'
     HUE_TASK_TAG = 'cct._hue'
     TASK_STATE = False
+    FILE_CACHE = data_dir('cwww.cache')
 
 
 #########################################
 #      ANALOG CCT WITH 2 channel PWM    #
 #########################################
 
-def __cwww_init():
+def __cwww_init(pin_warm=None, pin_cold=None):
     if Data.CWWW_OBJS[0] is None or Data.CWWW_OBJS[1] is None:
-        cw = Pin(resolve_pin('cwhite'))
-        ww = Pin(resolve_pin('wwhite'))
+        cw = Pin(bind_pin('cwhite', pin_cold))
+        ww = Pin(bind_pin('wwhite', pin_warm))
         if platform == 'esp8266':
             Data.CWWW_OBJS = (PWM(cw, freq=1024),
                               PWM(ww, freq=1024))
@@ -39,7 +40,7 @@ def __cwww_init():
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File state cache
     modes:
         r - recover, s - save
     """
@@ -47,12 +48,12 @@ def __persistent_cache_manager(mode):
         return
     if mode == 's':
         # SAVE CACHE
-        with open('cwww.pds', 'w') as f:
+        with open(Data.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in Data.CWWW_CACHE]))
         return
     try:
         # RESTORE CACHE
-        with open('cwww.pds', 'r') as f:
+        with open(Data.FILE_CACHE, 'r') as f:
             Data.CWWW_CACHE = [float(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -72,19 +73,16 @@ def __state_machine(c, w):
 # Application functions #
 #########################
 
-def load(cache=None):
+def load(pin_warm=None, pin_cold=None, cache=True):
     """
     Initialize Cold white / Warm white LED module
-    :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
-    - Apply loaded states to gpio pins (boot function)
+    :param pin_warm: optional number to overwrite default pin
+    :param pin_cold: optional number to overwrite default pin
+    :param cache: save/load state machine to disk (.cache)
     :return str: Cache state
     """
-    from sys import platform
-    if cache is None:
-        Data.PERSISTENT_CACHE = False if platform == 'esp8266' else True
-    else:
-        Data.PERSISTENT_CACHE = cache
+    __cwww_init(pin_warm, pin_cold)
+    Data.PERSISTENT_CACHE = cache
     __persistent_cache_manager('r')        # recover data cache
     if Data.CWWW_CACHE[2] == 1:
         Data.CWWW_CACHE[2] = 0             # Force ON at boot
@@ -240,8 +238,7 @@ def transition(cw=None, ww=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     cct_gen, step_ms = transition_gen(cw_from, cw_to, ww_from, ww_to, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.CCT_TASK_TAG, task=_task(ms_period=step_ms, iterable=cct_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.CCT_TASK_TAG, task=_task(ms_period=step_ms, iterable=cct_gen))
 
 
 def hue_transition(percent, sec=1.0, wake=False):
@@ -290,8 +287,7 @@ def hue_transition(percent, sec=1.0, wake=False):
         #print("Actual percent: {}, target percent: {}".format(actual_percent, warm_percent))
         hue_gen, step_ms = transition_gen(hue_curr_percent, percent*10, interval_sec=sec)
         # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-        state = micro_task(tag=Data.HUE_TASK_TAG, task=_task(ms_period=step_ms, iterable=hue_gen))
-        return "Starting transition" if state else "Transition already running"
+        return micro_task(tag=Data.HUE_TASK_TAG, task=_task(ms_period=step_ms, iterable=hue_gen))
     else:
         return "Invalid range, percent=<0-100>"