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

micrOS/source/modules/IO_m5stamp.py

@@ -0,0 +1,86 @@
+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 = _step_ws2812    # BUILT IN LED - progress_led
+
+# ANALOG RGB + WW + CW
+redgb = const(43)      # - rgb red channel [PWM]
+rgreenb = const(44)    # - rgb green channel [PWM]
+rgbue = const(0)      # - rgb blue channel [PWM]
+
+wwhite = const(39)	   # - warm white [PWM]
+cwhite = const(40)	   # - cold white [PWM]
+
+# DIGITAL LED
+neop = const(0)       # - neopixel OneWire bus [PWM]
+
+# ACTUATORS
+servo_1 = const(44)    # - servo(1) [PWM]
+servo_2 = const(42)    # - servo(2) [PWM]
+
+switch_1 = const(39)   # - switch(1) [simple]
+switch_2 = const(40)   # - switch(2) [simple]
+switch_3 = const(41)    # - switch(3) [simple]
+switch_4 = const(16)    # - switch(4) [simple]
+
+dim_1 = const(43)      # - dimmer(1) [PWM]
+
+buzzer = const(1)      # - Buzzer pin - sound generator
+
+# I2C BUS
+i2c_sda = const(13)    # - oled - data
+i2c_scl = const(15)    # - oled - clock
+# I2S BUS
+i2s_sck = const(5)    # Serial clock
+i2s_ws = const(7)     # Word select
+i2s_sd = const(9)     # Serial data
+
+
+# EXTERNAL EVENT IRQ
+irq1 = const(15)        # - event irq pin
+irq2 = const(13)        # - event irq pin
+irq3 = const(14)        # - event irq pin
+irq4 = const(12)        # - event irq pin
+
+touch_0 = const(1)     # - touch sensor TODO
+
+# SENSORS
+hcsrtrig = const(1)   # - distance HCSR04 trigger pin
+hcsrecho = const(3)   # - distance HCSR04 echo pin
+dhtpin = const(43)     # - dht_pin 11 and 22
+ds18 = const(0)       # - DS18B20 - temp. sensor
+mic = const(3)         # - [ADC] microphone

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():
-    global PLED_OBJ, NEO_WHEEL
+def _step_ws2812(pin=False):
+    if pin:
+        return WS2812.PIN
+
     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
@@ -77,7 +82,12 @@ irq1 = const(13)         # MO  - event irq pin
 irq2 = const(12)         # MI - event irq pin
 irq3 = const(14)         # SCK  - event irq pin
 irq4 = const(7)          # TX  - event irq pin
-oleduibttn = const(32)   # TX - oled_ui center/ok button
+
+js_right = const(13)      # oled_ui joystick
+js_left = const(12)
+js_up = const(14)
+js_down = const(7)
+js_press = const(32)     # oled_ui center/ok button
 
 
 # SENSORS

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]
@@ -9,7 +47,7 @@ wwhite = const(15)		# D15 - warm white [PWM CH4]
 cwhite = const(14)		# D14 - cold white [PWM CH5]
 
 # DIGITAL LED
-neop = const(23)       # D23 - WS2812 - neopixel OneWire bus [PWM]
+neop = const(26)       # D26 - WS2812 - neopixel OneWire bus [PWM]
 
 
 # ACTUATORS
@@ -28,12 +66,14 @@ l298dir_2 = const(19)  # D19 - DC motor direction (2)
 l9110dir_1 = const(18) # D18 - DC motor direction (1)
 l9110dir_2 = const(19) # D25 - DC motor direction (2)
 
-buzzer = const(18)     # D18 - Buzzer pin - sound generator
+buzzer = const(33)     # D33 - Buzzer pin - sound generator
+haptic = const(32)     # D32 - Haptic - vibration motor
 
 
 # I2C BUS
 i2c_sda = const(21)    # D22 - data
 i2c_scl = const(22)    # D21 - clock
+trackball_int = const(25)    # D25 - event interrupt
 
 
 # EXTERNAL EVENT IRQ
@@ -41,7 +81,12 @@ irq1 = const(5)         # D5  - event irq pin
 irq2 = const(18)        # D18 - event irq pin
 irq3 = const(19)        # D19  - event irq pin
 irq4 = const(23)        # D23  - event irq pin
-oleduibttn = const(32)  # D32 - oled_ui center/ok button
+
+js_right = const(23)     # oled_ui joystick
+js_left = const(5)
+js_up = const(18)
+js_down = const(19)
+js_press = const(32)    # oled_ui center/ok button
 
 touch_0 = const(32)     # D32 - builtin touch sensor	TODO
 

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 physical_pin, pinmap_dump
+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(physical_pin('l9110dir_1')), freq=1024))
-        __L9110_OBJS.append(PWM(Pin(physical_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
@@ -45,7 +45,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['l9110dir_1', 'l9110dir_2'])
+    return pinmap_search(['l9110dir_1', 'l9110dir_2'])
 
 
 def help(widgets=False):

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

@@ -2,9 +2,9 @@ try:
     import camera
 except Exception as e:
     camera = None
-import time
-from Debug import console_write
-from Common import rest_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
@@ -12,7 +12,7 @@ CAM_INIT = False
 FLASH_LIGHT = None      # Flashlight object
 
 
-def load_n_init(quality='medium', freq='default', effect="NONE"):
+def load(quality='medium', freq='default', effect="NONE"):
     """
     Load Camera module OV2640
     :param quality: high (HD), medium (SVGA), low (240x240)
@@ -30,7 +30,7 @@ def load_n_init(quality='medium', freq='default', effect="NONE"):
         return CAM_INIT
 
     for cnt in range(0, 3):
-        console_write(f"Init OV2640 cam {cnt+1}/3")
+        print(f"Init OV2640 cam {cnt+1}/3")
         try:
             # ESP32-CAM (default configuration) - https://bit.ly/2Ndn8tN
             if freq.strip().lower() == 'high':
@@ -45,7 +45,7 @@ def load_n_init(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"
 
@@ -56,8 +56,10 @@ def load_n_init(quality='medium', freq='default', effect="NONE"):
 
 def _set_web_endpoints():
     # Register rest endpoint
-    rest_endpoint('cam/snapshot', _snapshot_clb)
-    rest_endpoint('cam/stream', _image_stream_clb)
+    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):
@@ -138,7 +140,7 @@ def settings(quality=None, flip=None, mirror=None, effect=None, saturation=None,
 def capture():
     if camera is None:
         return "Non supported feature - use esp32cam image!"
-    load_n_init()
+    load()
     global IN_CAPTURE
     # Capture image
     buf = False
@@ -153,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}'
@@ -180,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)
-    """
-    rest_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
@@ -206,20 +224,13 @@ 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:
         state = fl.value(state)
     return {'S': state}
 
-def lmdep():
-    """
-    Show Load Module dependency
-    - List of load modules used by this application
-    :return: tuple
-    """
-    return 'dashboard_be'
 
 def help(widgets=False):
     """
@@ -228,14 +239,14 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return resolve(('load_n_init quality="medium/low/high" freq="default/high"',
+    return resolve(('load quality="medium/low/high" freq="default/high"',
         'settings quality=None flip=None mirror=None effect="NONE"',
         'SLIDER settings saturation=<0-100>',
         'SLIDER settings brightness=<0-100>',
         'SLIDER settings contrast=<0-100>',
+        'BUTTON settings effect=<NONE,NEG,BW,RED,GREEN,BLUE,RETRO>',
         'capture',
         'photo',
-        'set_photo_endpoint',
         'BUTTON flashlight state=None',
-        '[Hint] after load_n_init you can access the /cam/snapshot and /cam/stream endpoints',
+        '[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 physical_pin, pinmap_dump
+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(physical_pin('i2c_scl')), Pin(physical_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:
@@ -365,12 +365,12 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['i2c_scl', 'i2c_sda'])
+    return pinmap_search(['i2c_scl', 'i2c_sda'])
 
 
 def help(widgets=False):
     """
-    [i] micrOS LM naming convention - built-in help message
+    [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