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

micrOS/source/modules/LM_qmi8658.py

@@ -0,0 +1,204 @@
+"""
+A simple driver for the QMI8658 IMU.
+https://github.com/echo-lalia/qmi8658-micropython/blob/main/qmi8685.py
+"""
+
+import struct
+import time
+from machine import Pin, I2C
+from micropython import const
+from microIO import bind_pin, pinmap_search
+
+
+# Sensor constants
+_QMI8685_PARTID = const(0x05)
+_REG_PARTID = const(0x00)
+_REG_REVISION = const(0x01)
+
+_REG_CTRL1 = const(0x02)  # Serial interface and sensor enable
+_REG_CTRL2 = const(0x03)  # Accelerometer settings
+_REG_CTRL3 = const(0x04)  # Gyroscope settings
+_REG_CTRL4 = const(0x05)  # Magnetomer settings (support not implemented in this driver yet)
+_REG_CTRL5 = const(0x06)  # Sensor data processing settings
+_REG_CTRL6 = const(0x07)  # Attitude Engine ODR and Motion on Demand
+_REG_CTRL7 = const(0x08)  # Enable Sensors and Configure Data Reads
+
+_REG_TEMP = const(0x33)  # Temperature sensor.
+
+_REG_AX_L = const(0x35)  # Read accelerometer
+_REG_AX_H = const(0x36)
+_REG_AY_L = const(0x37)
+_REG_AY_H = const(0x38)
+_REG_AZ_L = const(0x39)
+_REG_AZ_H = const(0x3A)
+
+_REG_GX_L = const(0x3B)  # read gyro
+_REG_GX_H = const(0x3C)
+_REG_GY_L = const(0x3D)
+_REG_GY_H = const(0x3E)
+_REG_GZ_L = const(0x3F)
+_REG_GZ_H = const(0x40)
+
+_QMI8658_I2CADDR_DEFAULT = const(0X6B)
+
+
+_ACCELSCALE_RANGE_2G = const(0b00)
+_ACCELSCALE_RANGE_4G = const(0b01)
+_ACCELSCALE_RANGE_8G = const(0b10)
+_ACCELSCALE_RANGE_16G = const(0b11)
+
+_GYROSCALE_RANGE_16DPS = const(0b000)
+_GYROSCALE_RANGE_32DPS = const(0b001)
+_GYROSCALE_RANGE_64DPS = const(0b010)
+_GYROSCALE_RANGE_128DPS = const(0b011)
+_GYROSCALE_RANGE_256DPS = const(0b100)
+_GYROSCALE_RANGE_512DPS = const(0b101)
+_GYROSCALE_RANGE_1024DPS = const(0b110)
+_GYROSCALE_RANGE_2048DPS = const(0b111)
+
+_ODR_8000HZ = const(0b0000)
+_ODR_4000HZ = const(0b0001)
+_ODR_2000HZ = const(0b0010)
+_ODR_1000HZ = const(0b0011)
+_ODR_500HZ = const(0b0100)
+_ODR_250HZ = const(0b0101)
+_ODR_125HZ = const(0b0110)
+_ODR_62_5HZ = const(0b0111)
+
+
+class QMI8658:
+    """QMI8658 inertial measurement unit."""
+    INSTANCE = None
+
+    def __init__(
+            self,
+            i2c_bus: I2C,
+            address: int = _QMI8658_I2CADDR_DEFAULT,
+            accel_scale: int = _ACCELSCALE_RANGE_8G,
+            gyro_scale: int = _GYROSCALE_RANGE_256DPS):
+        """Read from a sensor on the given I2C bus, at the given address."""
+        self.i2c = i2c_bus
+        self.address = address
+        # Cache the sensor instance globally for easy access
+        QMI8658.INSTANCE = self
+
+        # Verify sensor part ID
+        if self._read_u8(_REG_PARTID) != _QMI8685_PARTID:
+            raise AttributeError("Cannot find a QMI8658")
+
+        # Setup initial configuration
+        self._configure_sensor(accel_scale, gyro_scale)
+
+        # Configure scales/divisors for the driver
+        self.acc_scale_divisor = {
+            _ACCELSCALE_RANGE_2G: 1 << 14,
+            _ACCELSCALE_RANGE_4G: 1 << 13,
+            _ACCELSCALE_RANGE_8G: 1 << 12,
+            _ACCELSCALE_RANGE_16G: 1 << 11,
+        }[accel_scale]
+
+        self.gyro_scale_divisor = {
+            _GYROSCALE_RANGE_16DPS: 2048,
+            _GYROSCALE_RANGE_32DPS: 1024,
+            _GYROSCALE_RANGE_64DPS: 512,
+            _GYROSCALE_RANGE_128DPS: 256,
+            _GYROSCALE_RANGE_256DPS: 128,
+            _GYROSCALE_RANGE_512DPS: 64,
+            _GYROSCALE_RANGE_1024DPS: 32,
+            _GYROSCALE_RANGE_2048DPS: 16,
+        }[gyro_scale]
+
+
+    def _configure_sensor(self, accel_scale: int, gyro_scale: int):
+        # Initialize accelerometer and gyroscope settings
+        self._write_u8(_REG_CTRL1, 0x60)  # Set SPI auto increment and big endian (Ctrl 1)
+        self._write_u8(_REG_CTRL2, (accel_scale << 4) | _ODR_1000HZ)  # Accel Config
+        self._write_u8(_REG_CTRL3, (gyro_scale << 4) | _ODR_1000HZ)  # Gyro Config
+        self._write_u8(_REG_CTRL5, 0x01)  # Low-pass filter enable
+        self._write_u8(_REG_CTRL7, 0x03)  # Enable accel and gyro
+        time.sleep_ms(100)
+
+
+    # Helper functions for register operations
+    def _read_u8(self, reg:int) -> int:
+        return self.i2c.readfrom_mem(self.address, reg, 1)[0]
+
+    def _read_xyz(self, reg:int) -> tuple[int, int, int]:
+        data = self.i2c.readfrom_mem(self.address, reg, 6)
+        return struct.unpack('<hhh', data)
+
+    def _write_u8(self, reg: int, value: int):
+        self.i2c.writeto_mem(self.address, reg, bytes([value]))
+
+
+    @property
+    def temperature(self) -> float:
+        """Get the device temperature."""
+        temp_raw = self._read_u8(_REG_TEMP)
+        return temp_raw / 256
+
+    @property
+    def acceleration(self) -> tuple[float, float, float]:
+        """Get current acceleration reading."""
+        raw_accel = self._read_xyz(_REG_AX_L)
+        return tuple(val / self.acc_scale_divisor for val in raw_accel)
+
+    @property
+    def gyro(self) -> tuple[float, float, float]:
+        """Get current gyroscope reading."""
+        raw_gyro = self._read_xyz(_REG_GX_L)
+        return tuple(val / self.gyro_scale_divisor for val in raw_gyro)
+
+#######################
+#   Public functions  #
+#######################
+
+def load():
+    """
+    Load the QMI8658 sensor instance.
+    The QMI8658 is a motion sensor that measures acceleration, angular velocity (gyroscope), and temperature
+    """
+    if QMI8658.INSTANCE is None:
+        QMI8658(I2C(0, sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl'))))
+    return QMI8658.INSTANCE
+
+
+def temperature():
+    return load().temperature
+
+
+def acceleration():
+    return load().acceleration
+
+
+def gyro():
+    return load().gyro
+
+
+def measure():
+    inst = load()
+    return {"temp": inst.temperature, "accel": inst.acceleration, "gyro": inst.gyro}
+
+
+#######################
+# 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):
+    """
+    [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 'load', 'temperature', 'acceleration', 'gyro', 'measure', 'pinmap'

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

@@ -1,7 +1,7 @@
 from machine import Pin
 import micropython
 from Common import socket_stream, syslog
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Types import resolve
 
 # https://www.coderdojotc.org/micropython/sensors/10-rotary-encoder/
@@ -76,7 +76,7 @@ def load(min_val=0, max_val=20):
     """
     if Data.ROTARY_OBJ is None:
         # GPIO Pins 33 and 35 are for the encoder pins.
-        Data.ROTARY_OBJ = Rotary(resolve_pin('rot_dt'), resolve_pin('rot_clk'))
+        Data.ROTARY_OBJ = Rotary(bind_pin('rot_dt'), bind_pin('rot_clk'))
         Data.MIN_VAL = min_val
         Data.MAX_VAL = max_val
         Data.VAL = min_val

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

@@ -1,4 +1,3 @@
-import uasyncio as asyncio
 from urequests import get as http_get
 from urequests import aget as http_aget
 from Common import micro_task
@@ -11,7 +10,7 @@ class Rest:
 def load(gateway_url=None):
     """
     Set gateway url aka main domain
-    :param gateway_url: base url of gateway, like: http://gateway.local:5000
+    :param gateway_url: base url of gateway, like: http://gateway.local:5005
     """
     if gateway_url is None:
         if Rest.GATEWAY_HOST is None:
@@ -67,8 +66,7 @@ def aurl(subdomain):
     tag = "rest." + subdomain.replace("http://", '').replace("https://", '')
     if len(tag) > 50:
         tag = tag[0:50]
-    state = micro_task(tag=tag, task=__task(subdomain, tag))
-    return f"Starting" if state else f"Already running"
+    return micro_task(tag=tag, task=__task(subdomain, tag))
 
 
 def help(widgets=False):
@@ -78,6 +76,6 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return ('load gateway_url=<http://gateway.local:5000>',
+    return ('load gateway_url=<http://gateway.local:5005>',
             'url subdomain=</webhooks/template>',
-            'aurl subdomain=</webhooks/template>')
+            'aurl subdomain=</webhooks/template>')

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

@@ -2,10 +2,9 @@
 #       ANALOG rgb CONTROLLER PARAMS    #
 #########################################
 from machine import Pin, PWM
-from sys import platform
-from Common import transition_gen, micro_task
+from Common import transition_gen, micro_task, data_dir
 from utime import sleep_ms
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from random import randint
 from Types import resolve
 
@@ -20,31 +19,27 @@ class Data:
     CH_MAX = 1000                          # maximum value per channel
     TASK_STATE = False
     RGB_TASK_TAG = "rgb._tran"
+    FILE_CACHE = data_dir('rgb.cache')
 
 
 #########################################
 #      ANALOG rgb WITH 3 channel PWM    #
 #########################################
 
-def __RGB_init():
+def __RGB_init(red_pin=None, green_pin=None, blue_pin=None):
     if Data.RGB_OBJS[0] is None or Data.RGB_OBJS[1] is None or Data.RGB_OBJS[2] is None:
-        red = Pin(resolve_pin('redgb'))
-        green = Pin(resolve_pin('rgreenb'))
-        blue = Pin(resolve_pin('rgbue'))
-        if platform == 'esp8266':
-            Data.RGB_OBJS = (PWM(red, freq=1024),
-                          PWM(green, freq=1024),
-                          PWM(blue, freq=1024))
-        else:
-            Data.RGB_OBJS = (PWM(red, freq=20480),
-                          PWM(green, freq=20480),
-                          PWM(blue, freq=20480))
+        red = Pin(bind_pin('redgb', red_pin))
+        green = Pin(bind_pin('rgreenb', green_pin))
+        blue = Pin(bind_pin('rgbue', blue_pin))
+        Data.RGB_OBJS = (PWM(red, freq=20480),
+                         PWM(green, freq=20480),
+                         PWM(blue, freq=20480))
     return Data.RGB_OBJS
 
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File state cache
     modes:
         r - recover, s - save
     """
@@ -52,12 +47,12 @@ def __persistent_cache_manager(mode):
         return
     if mode == 's':
         # SAVE CACHE
-        with open('rgb.pds', 'w') as f:
+        with open(Data.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in Data.RGB_CACHE]))
         return
     try:
         # RESTORE CACHE
-        with open('rgb.pds', 'r') as f:
+        with open(Data.FILE_CACHE, 'r') as f:
             Data.RGB_CACHE = [float(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -73,20 +68,18 @@ def __state_machine(r, g, b):
     __persistent_cache_manager('s')
 
 
-def load(cache=None):
+def load(red_pin=None, green_pin=None, blue_pin=None, cache=True):
     """
     Initiate RGB 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 red_pin: optional red color pin to overwrite built-in
+    :param green_pin: optional green color pin to overwrite built-in
+    :param blue_pin: optional blue color pin to overwrite built-in
+    :param cache: file state machine cache: True/False (.cache), default=True
     :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
+    Data.PERSISTENT_CACHE = cache
     __persistent_cache_manager('r')     # recover data cache if enabled
+    __RGB_init(red_pin, green_pin, blue_pin)
     if Data.RGB_CACHE[3] == 1:
         Data.RGB_CACHE[3] = 0           # Force ON at boot
         toggle(True)
@@ -253,8 +246,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     rgb_gen, step_ms = transition_gen(r_from, r, g_from, g, b_from, b, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
 
 
 def random(smooth=True, max_val=1000):

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

@@ -2,7 +2,7 @@ from utime import sleep_ms
 from random import randint
 import LM_servo as servo
 from LM_switch import set_state, pinmap as switch_pinmap
-from Common import transition, micro_task
+from Common import transition, micro_task, data_dir
 from Types import resolve
 
 
@@ -13,23 +13,24 @@ class RoboArm:
     SPEED_MS = 10                           # Set default speed between steps (ms)
     MOVE_RECORD = []                        # Buffer for XY move record/replay
     PLAY_TAG = 'roboarm._play'
+    FILE_CACHE = data_dir('rarm.cache')
 
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File state cache
     modes:
         r - recover, s - save
     """
 
     if mode == 's':
         # SAVE CACHE
-        with open('rarm.pds', 'w') as f:
+        with open(RoboArm.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in RoboArm.MOVE_RECORD]))
         return
     try:
         # RESTORE CACHE
-        with open('rarm.pds', 'r') as f:
+        with open(RoboArm.FILE_CACHE, 'r') as f:
             RoboArm.MOVE_RECORD = [int(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -203,11 +204,10 @@ def play(*args, s=None, delay=None, deinit=True):
 
     # Start play - servo XY in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=RoboArm.PLAY_TAG, task=_play(args, deinit, delay))
-    if state:
-        return 'Play: {} steps'.format(int(len(args)/2))
-    return 'Play - already running'
 
+    state:dict = micro_task(tag=RoboArm.PLAY_TAG, task=_play(args, deinit, delay))
+    state.update({"Play steps": int(len(args)/2)})
+    return state
 
 def record(clean=False, rec_limit=8):
     """

micrOS/source/modules/LM_robustness.py

@@ -0,0 +1,137 @@
+from LM_system import memory_usage
+from Common import socket_stream, syslog, micro_task
+from Auth import sudo
+
+
+@socket_stream
+def raise_error(msgobj=None):
+    """
+    Test function - raise  LM exception
+    """
+    if msgobj is not None:
+        msgobj("Raise test exception")
+    state = syslog('Robustness TeSt ErRoR')
+    raise Exception(f"Test exception: {'OK' if state else 'NOK'}")
+
+
+@socket_stream
+def memory_leak(cnt=160, msgobj=None):
+    """
+    Test function - allocate lot of memory
+    :param cnt: data counter, default 160 iteration
+    :return: verdict
+    """
+    dict_test = {}
+    mem_start = memory_usage()['mem_used']
+    for k in range(cnt):
+        mem = memory_usage()['percent']
+        data = "micrOS memory usage: {} %".format(mem)
+        if msgobj is not None:
+            msgobj("[{}] gen: {}".format(k, data))
+        dict_test[k] = data
+    mem_end = memory_usage()['mem_used']
+    delta = mem_start - mem_end
+    return '[{}] RAM Alloc.: {} kB {} byte'.format(len(dict_test), int(delta / 1024), int(delta % 1024))
+
+@socket_stream
+def recursion_limit(limit=14, msgobj=None):
+    cnt = 0
+    for cnt in range(1, limit+1):
+        try:
+            _recursion(cnt, msgobj=msgobj)
+        except Exception as e:
+            msgobj(f"ok error: {e}")
+            break
+    return f"Recursion limit: {cnt}"
+
+
+def _recursion(cnt, msgobj=None):
+    """
+    Test function - recursion test
+    :param cnt: recursion depth
+    :return: verdict
+    Error example:
+        node01 $  robustness recursion_limit 15
+        lm_exec LM_robustness->recursion_limit: maximum recursion depth exceeded
+    """
+    if cnt > 0:
+        remain = _recursion(cnt-1)
+        if msgobj is not None:
+            msgobj("recalled {}".format(cnt))
+    else:
+        remain = 0
+    return remain
+
+################## TEST micro_task UCs ##########################
+
+async def __task(tag, period_ms):
+    counter = 0
+    with micro_task(tag=tag) as my_task:
+        while True:
+            # DO something here in the async loop...
+            counter += 1
+
+            # Store data in task cache (task show mytask)
+            my_task.out = f'MyTask Counter: {counter}'
+
+            # Async sleep - feed event loop
+            await my_task.feed(sleep_ms=period_ms)
+            # [i] feed same as "await asyncio.sleep_ms(period_ms)" with micrOS features (WDT)
+
+def create_task():
+    """
+    Legacy way of task creation (with exact task tagging)
+    """
+    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    task_tag = "microtask.run"
+    return micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
+
+
+@micro_task("microtask", _wrap=True)
+async def mytask(tag, period_ms=30):
+    """
+    New shorter way of task creation
+     with decorator function
+    """
+    counter = 0
+    with micro_task(tag=tag) as my_task:
+        while True:
+            # DO something here in the async loop...
+            counter += 1
+
+            # Store data in task cache (task show mytask)
+            my_task.out = f'MyTask Counter: {counter}'
+
+            # Async sleep - feed event loop
+            await my_task.feed(sleep_ms=period_ms)
+            # [i] feed same as "await asyncio.sleep_ms(period_ms)" with micrOS features (WDT)
+
+
+@sudo
+def func_sudo():
+    """
+    Function execution requires pwd=<...>
+    """
+    return "Access granted"
+
+
+@sudo(_force_only=(True, 0))
+def func_sudo_force(force=False):
+    """
+    Function requires pwd=<...> when force=True
+    """
+    return f"Access granted, force flag: {force}"
+
+##############################################################################
+
+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 'NOTE: This is a test module to validate system robustness', \
+           'raise_error', 'memory_leak cnt=160', 'recursion_limit cnt=14', \
+           'create_task', 'mytask', "func_sudo", "func_sudo_force"
+

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

@@ -1,5 +1,5 @@
 from machine import Pin, PWM
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 
 
 class Data:
@@ -16,7 +16,7 @@ class Data:
 def __servo_init():
     if Data.S_OBJ is None:
         try:
-            pin = Pin(resolve_pin('servo_1'))
+            pin = Pin(bind_pin('servo_1'))
             Data.S_OBJ = PWM(pin, freq=50)
             del pin
         except Exception as e:
@@ -64,7 +64,7 @@ def sdemo():
 def __servo2_init():
     if Data.S_OBJ2 is None:
         try:
-            pin = Pin(resolve_pin('servo_2'))     # Alternative wiring
+            pin = Pin(bind_pin('servo_2'))     # Alternative wiring
             Data.S_OBJ2 = PWM(pin, freq=50)
             del pin
         except Exception as e:

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

@@ -2,7 +2,7 @@
 
 from utime import sleep_ms
 from machine import Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 STEPPER_INST = None
 
 
@@ -30,10 +30,10 @@ class StepperULN2003:
                          [1, 0, 0, 1]]
             self.delay = 2
         # Init stepper pins
-        self.pin1 = Pin(resolve_pin('stppr_1'), Pin.OUT)
-        self.pin2 = Pin(resolve_pin('stppr_2'), Pin.OUT)
-        self.pin3 = Pin(resolve_pin('stppr_3'), Pin.OUT)
-        self.pin4 = Pin(resolve_pin('stppr_4'), Pin.OUT)
+        self.pin1 = Pin(bind_pin('stppr_1'), Pin.OUT)
+        self.pin2 = Pin(bind_pin('stppr_2'), Pin.OUT)
+        self.pin3 = Pin(bind_pin('stppr_3'), Pin.OUT)
+        self.pin4 = Pin(bind_pin('stppr_4'), Pin.OUT)
         # Initialize all value to 0 - "OFF"
         self.reset()
 

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

@@ -1,5 +1,6 @@
 from machine import Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
+from Common import data_dir
 from Types import resolve
 
 #########################################
@@ -8,6 +9,7 @@ from Types import resolve
 __SWITCH_OBJ = [None, None, None, None]
 __PERSISTENT_CACHE = False
 __SWITCH_STATE = [0, 0, 0, 0]
+__FILE_CACHE = data_dir('switch.cache')
 
 
 #########################################
@@ -16,7 +18,7 @@ __SWITCH_STATE = [0, 0, 0, 0]
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
@@ -25,12 +27,12 @@ def __persistent_cache_manager(mode):
     global __SWITCH_STATE
     if mode == 's':
         # SAVE CACHE
-        with open('switch.pds', 'w') as f:
+        with open(__FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in __SWITCH_STATE]))
         return
     try:
         # RESTORE CACHE
-        with open('switch.pds', 'r') as f:
+        with open(__FILE_CACHE, 'r') as f:
             __SWITCH_STATE = [int(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -54,7 +56,7 @@ def load(cache=None, ch_init=None):
     """
     Initiate switch module (4 switch pack)
     :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
+    - Load .cache (state machine cache) for this load module
     - Apply loaded states to gpio pins (boot function)
     :return str: Cache state
     """
@@ -82,7 +84,7 @@ def load(cache=None, ch_init=None):
 
 def __switch_init():
     if __SWITCH_OBJ[0] is None:
-        __SWITCH_OBJ[0] = Pin(resolve_pin('switch_1'), Pin.OUT)
+        __SWITCH_OBJ[0] = Pin(bind_pin('switch_1'), Pin.OUT)
     return __SWITCH_OBJ[0]
 
 
@@ -118,7 +120,7 @@ def toggle():
 
 def __switch2_init():
     if __SWITCH_OBJ[1] is None:
-        __SWITCH_OBJ[1] = Pin(resolve_pin('switch_2'), Pin.OUT)
+        __SWITCH_OBJ[1] = Pin(bind_pin('switch_2'), Pin.OUT)
     return __SWITCH_OBJ[1]
 
 
@@ -153,7 +155,7 @@ def toggle2():
 
 def __switch3_init():
     if __SWITCH_OBJ[2] is None:
-        __SWITCH_OBJ[2] = Pin(resolve_pin('switch_3'), Pin.OUT)
+        __SWITCH_OBJ[2] = Pin(bind_pin('switch_3'), Pin.OUT)
     return __SWITCH_OBJ[2]
 
 
@@ -188,7 +190,7 @@ def toggle3():
 
 def __switch4_init():
     if __SWITCH_OBJ[3] is None:
-        __SWITCH_OBJ[3] = Pin(resolve_pin('switch_4'), Pin.OUT)
+        __SWITCH_OBJ[3] = Pin(bind_pin('switch_4'), Pin.OUT)
     return __SWITCH_OBJ[3]