micrOSDevToolKit 2.10.6__py3-none-any.whl → 2.13.0__py3-none-any.whl

toolkit/DevEnvCompile.py

@@ -133,12 +133,13 @@ class Compile:
 
     def __cleanup_precompiled_dir(self):
         self.console("Delete precompiled components: {}".format(self.precompiled_micrOS_dir_path))
-        for source in [pysource for pysource in LocalMachine.FileHandler.list_dir(self.precompiled_micrOS_dir_path)
-                       if check_all_extensions(pysource)]:
+        for source in LocalMachine.FileHandler.list_dir(self.precompiled_micrOS_dir_path):
             to_remove_path = os.path.join(self.precompiled_micrOS_dir_path, source)
-            self.console("\t|-remove: {}".format(to_remove_path), state='imp')
-            if not self.dry_run:
-                LocalMachine.FileHandler.remove(to_remove_path)
+            if check_all_extensions(source) or LocalMachine.FileHandler.path_is_exists(to_remove_path)[1] == "d":
+                self.console("\t|-remove: {}".format(to_remove_path), state='imp')
+                if not self.dry_run:
+                    if not LocalMachine.FileHandler.remove(to_remove_path):
+                        self.console(f"\t\t|-ERROR: Failed to remove {to_remove_path}", state="err")
 
     def get_micros_version_from_repo(self):
         # Get repo version
@@ -235,17 +236,21 @@ class Compile:
         workdir_handler = LocalMachine.SimplePopPushd()
         workdir_handler.pushd(self.micrOS_dir_path)
 
-        self.console("COPY additional resources")
-        # Filter component source
-        for source in [pysource for pysource in LocalMachine.FileHandler.list_dir(self.micrOS_dir_path) if
-                       check_web_extensions(pysource)]:
+        self.console("COPY additional resources...", state="ok")
+        for source in LocalMachine.FileHandler.list_dir(self.micrOS_dir_path):
             source_path = os.path.join(self.micrOS_dir_path, source)
-            if self.dry_run:
-                state = True
-            else:
-                state = LocalMachine.FileHandler.copy(source_path, self.precompiled_micrOS_dir_path)
-            if not state:
-                self.console("Copy error", state='err')
+            # COPY DIRECTORY RESOURCES (/web)
+            if (LocalMachine.FileHandler.path_is_exists(source_path)[1] == 'd' and
+                    not (source.startswith("_") or source.startswith("."))):
+                if self.dry_run:
+                    state = True
+                else:
+                    target_dir = os.path.join(self.precompiled_micrOS_dir_path, source)
+                    self.console(f"|- COPY DIR: {source_path} -> {target_dir}", state="ok")
+                    state = LocalMachine.FileHandler.copy(source_path, target_dir)
+                if not state:
+                    self.console("Copy error", state='err')
+
         workdir_handler.popd()
 
 

toolkit/DevEnvOTA.py

@@ -5,22 +5,26 @@ MYPATH = os.path.dirname(__file__)
 print("Module [DevEnvOTA] path: {} __package__: {} __name__: {} __file__: {}".format(
     sys.path[0], __package__, __name__, MYPATH))
 
+from pprint import pprint
+
 try:
     from .DevEnvCompile import Compile
     from . import socketClient
     from .lib import LocalMachine
     from .lib.TerminalColors import Colors
     from .lib.SafeInput import input_with_timeout
-    from .lib.file_extensions import check_all_extensions
+    from .lib.file_extensions import check_all_extensions, check_web_extensions, check_python_extensions
     from .lib.Repository import git_clone_archive, git_clone
+    from .MicrosFiles import micros_resource_list
 except Exception as e:
     print("Import warning __name__:{}: {}".format(__name__, e))
     from DevEnvCompile import Compile
     from lib import LocalMachine
     from lib.TerminalColors import Colors
     from lib.SafeInput import input_with_timeout
-    from lib.file_extensions import check_all_extensions
+    from lib.file_extensions import check_all_extensions, check_web_extensions, check_python_extensions
     from lib.Repository import git_clone_archive, git_clone
+    from MicrosFiles import micros_resource_list
 
 sys.path.append(MYPATH)
 import socketClient
@@ -241,9 +245,9 @@ class OTA(Compile):
         self.console("  loader update: {}".format(force_mode), state='OK')
 
         # Parse files from precompiled dir
-        resource_list_to_upload = [os.path.join(self.precompiled_micrOS_dir_path, pysource) for pysource in
-                                   LocalMachine.FileHandler.list_dir(self.precompiled_micrOS_dir_path)
-                                   if check_all_extensions(pysource)]
+        resource_list_to_upload, dir_list_to_create = micros_resource_list(self.precompiled_micrOS_dir_path)
+        # LIMITATION: WEBREPL Cannot create directories with remote command...
+
         # Apply upload settings on parsed resources
         for index, source in enumerate(resource_list_to_upload):
             source_name = os.path.basename(source)
@@ -268,7 +272,8 @@ class OTA(Compile):
             # Add source to upload
             upload_path_list.append(source)
         # Upload files / sources
-        return self.ota_webrepl_update_core(device, upload_path_list=upload_path_list, ota_password=webrepl_password)
+        return self.ota_webrepl_update_core(device, upload_path_list=upload_path_list,
+                                            ota_password=webrepl_password, upload_root_dir=self.precompiled_micrOS_dir_path)
 
     def _enable_micros_ota_update_via_webrepl(self, device=None, ota_password=None):
         # Get specific device from device list
@@ -401,7 +406,8 @@ class OTA(Compile):
             print(f"[SIM] 'OTA' COPY FILES... {source} -> {target}")
             LocalMachine.FileHandler().copy(source, target)
 
-    def ota_webrepl_update_core(self, device=None, upload_path_list=[], ota_password='ADmin123', force_lm=False):
+    def ota_webrepl_update_core(self, device=None, upload_path_list=None, ota_password='ADmin123',
+                                force_lm=False, upload_root_dir=None):
         """
         Generic file uploader for micrOS - over webrepl
             info: https://techoverflow.net/2020/02/22/how-to-upload-files-to-micropython-using-webrepl-using-webrepl_cli-py/
@@ -410,7 +416,11 @@ class OTA(Compile):
         upload_path_list: file path list to upload
         ota_password - accessing webrepl to upload files
         force_lm - use prefix as 'LM_' for every file - for user file upload / GUI drag n drop
+        upload_root_dir - root directory to upload files (subdir support)
         """
+        if upload_path_list is None:
+            upload_path_list = []
+
         if device[0] == "__simulator__":
             OTA.sim_ota_update(upload_path_list, force_lm)
             return
@@ -457,7 +467,18 @@ class OTA(Compile):
             # Copy retry mechanism
             exitcode = -1
             source_name = os.path.basename(source)
-            source_name_target = source_name
+            if upload_root_dir is None:
+                # Drag-n-Drop file upload file type check and folder adjustment
+                if check_web_extensions(source_name):
+                    source_name_target = os.path.join('web', source_name)
+                elif not check_python_extensions(source_name) and not source_name.endswith("node_config.json"):
+                    source_name_target = os.path.join('data', source_name)
+                else:
+                    # Copy file to micrOS root folder (.mpy and .py or node_config.json)
+                    source_name_target = source_name
+            else:
+                # MAIN USE-CASE
+                source_name_target = source.replace(upload_root_dir, '')
 
             # Force LM update - user load modules - drag n drop files
             if force_lm and not source_name.startswith('LM_') and source_name.endswith('.py'):

toolkit/DevEnvUSB.py

@@ -13,12 +13,14 @@ try:
     from .lib import LocalMachine
     from .lib.TerminalColors import Colors
     from .lib.SerialDriverHandler import install_usb_serial_driver
+    from .MicrosFiles import micros_resource_list
 except Exception as e:
     print("Import warning __name__:{}: {}".format(__name__, e))
     from DevEnvCompile import Compile
     from lib import LocalMachine
     from lib.TerminalColors import Colors
     from lib.SerialDriverHandler import install_usb_serial_driver
+    from MicrosFiles import micros_resource_list
 
 
 class USB(Compile):
@@ -77,6 +79,11 @@ class USB(Compile):
                   'deploy': '{esptool_interface} --chip esp32c3 --port {dev} --baud 460800 write_flash -z 0x0 {micropython}',
                   'mpremote_cmd': 'mpremote',
                   'cmd_line_info': '[!HINT!] Fully automatic deployment...'},
+             'esp32c6':
+                 {'erase': '{esptool_interface} --chip esp32c6 --port {dev} erase_flash',
+                  'deploy': '{esptool_interface} --chip esp32c6 --port {dev} --baud 460800 write_flash -z 0x0 {micropython}',
+                  'mpremote_cmd': 'mpremote',
+                  'cmd_line_info': '[!HINT!] Fully automatic deployment...'},
              }
         if not USB.usb_driver_ok:
             # Optimization - driver check
@@ -202,6 +209,38 @@ class USB(Compile):
             self.console("Deployment failed.\n{} - {}".format(stdout, stderr), state='err')
             return False
 
+    def _mkdir_on_dev(self, folders:list):
+        mpremote_cmd = self.dev_types_and_cmds[self.selected_device_type]['mpremote_cmd']
+        device = self.get_devices()[0]
+        if mpremote_cmd is None:
+            # Legacy ampy command (esp32 auto reboot tolerance...)
+            mkdir_cmd = self.dev_types_and_cmds[self.selected_device_type]['ampy_cmd'].format(dev=device, args=f'mkdir')
+        else:
+            mkdir_cmd = f'{mpremote_cmd} fs mkdir'
+
+        status = 0
+        for folder in folders:
+            _mkdir_cmd = f"{mkdir_cmd} {folder}"
+            self.console(f"Create directory on device: {_mkdir_cmd}")
+            if self.dry_run:
+                pass
+            else:
+                try:
+                    exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(_mkdir_cmd, shell=True)
+                    if exitcode != 0:
+                        verdict = stdout + stderr
+                        if "File exists" in verdict or "Directory already exists" in verdict:
+                            exitcode = 0
+                        else:
+                            self.console(f"MKDIR ERROR:\n{stdout}\n{stderr}", state="err")
+                except Exception as e:
+                    self.console(f"MKDIR ERROR {_mkdir_cmd}: {e}", state="err")
+                    exitcode = 1
+                status += exitcode
+
+        return True if status == 0 else False
+
+
     def put_micros_to_dev(self):
         self.select_board_n_micropython()
         status = True
@@ -218,17 +257,20 @@ class USB(Compile):
                 self.console(f"... wait for reset {10-k} sec", state='imp')
                 time.sleep(1)
 
-        mpremote_cmd = self.dev_types_and_cmds[self.selected_device_type]['mpremote_cmd']
-        device = self.get_devices()[0]
-        source_to_put_device = LocalMachine.FileHandler.list_dir(self.precompiled_micrOS_dir_path)
+        # Parse micrOS resources with folders
+        _source_to_put_device, dir_list_to_create = micros_resource_list(self.precompiled_micrOS_dir_path)
+        self.console(f"CREATE FOLDERS: {dir_list_to_create}", state="ok")
+        # Create sub folders
+        if not self._mkdir_on_dev(dir_list_to_create):
+            self.console(f"Error creating directories on device: {dir_list_to_create}")
+            sys.exit(1)
+        # Generate resource list to be put on the device
+        source_to_put_device = list([s.replace(self.precompiled_micrOS_dir_path + "/", '') for s in _source_to_put_device])
         # Set source order - main, boot
-        source_to_put_device.append(source_to_put_device.pop(source_to_put_device.index('main.py')))
-        try:
-            # PIP deployment generates this ...
-            source_to_put_device.remove('__pycache__')      # remove if accidentally left here
-        except:
-            pass
+        source_to_put_device.append(source_to_put_device.pop(source_to_put_device.index("main.py")))
 
+        mpremote_cmd = self.dev_types_and_cmds[self.selected_device_type]['mpremote_cmd']
+        device = self.get_devices()[0]
         # Change workdir
         workdir_handler = LocalMachine.SimplePopPushd()
         workdir_handler.pushd(self.precompiled_micrOS_dir_path)
@@ -238,7 +280,7 @@ class USB(Compile):
             self.console("[{}%] micrOS deploy via USB - {}".format(percent, device))
             if mpremote_cmd is None:
                 # Legacy ampy command (esp32 auto reboot tolerance...)
-                command = self.dev_types_and_cmds[self.selected_device_type]['ampy_cmd'].format(dev=device, args=f'put {source}')
+                command = self.dev_types_and_cmds[self.selected_device_type]['ampy_cmd'].format(dev=device, args=f'put {source} /{source}')
             else:
                 command = f'{mpremote_cmd} fs cp {source} :{source}'     # new mpremote <1.24.1
             if ' ' in source:

toolkit/LM_to_compile.dat

@@ -40,3 +40,4 @@ LM_oledui.py
 LM_haptic.py
 LM_distance.py
 LM_veml7700.py
+LM_neomatrix.py

toolkit/MicrOSDevEnv.py

@@ -62,8 +62,16 @@ class MicrOSDevTool(OTA, USB):
                 if f.endswith('.json'):
                     continue
                 f_path = os.path.join(self.micrOS_dir_path, f)
-                self.console("[SIM] Copy micrOS resources: {} -> {}".format(f_path, self.micros_sim_workspace))
-                LocalMachine.FileHandler().copy(f_path, self.micros_sim_workspace)
+                if f.startswith("_") or f.startswith("."):
+                    # SKIP files startswith `_` and `.`
+                    continue
+                _, f_type = LocalMachine.FileHandler.path_is_exists(f_path)
+                target_dir = self.micros_sim_workspace
+                if f_type == "d":
+                    target_dir = os.path.join(self.micros_sim_workspace, f)
+                self.console(f"[SIM] Copy micrOS resources: {f_path} -> {target_dir}")
+                if not LocalMachine.FileHandler().copy(f_path, target_dir):
+                    self.console(f"[ERROR] Failed to copy: {f_path}")
 
             if prepare_only:
                 # In case of automatic node_conf creation

toolkit/MicrosFiles.py

@@ -0,0 +1,26 @@
+import os
+
+try:
+    from .lib import LocalMachine
+    from .lib.file_extensions import check_all_extensions, check_web_extensions
+except Exception as e:
+    print("Import warning __name__:{}: {}".format(__name__, e))
+    from lib import LocalMachine
+    from lib.file_extensions import check_all_extensions, check_web_extensions
+
+def micros_resource_list(root_folder):
+    resources_path = []
+    subfolders = []
+    for source in LocalMachine.FileHandler.list_dir(root_folder):
+        source_full_path = os.path.join(root_folder, source)
+        # [1] / Root directory source files and folders.
+        if check_all_extensions(source):
+            resources_path.append(source_full_path)
+        # [2] /dir Handle sub dictionary sources
+        elif LocalMachine.FileHandler.path_is_exists(source_full_path)[1] == 'd':
+            subfolders.append(source)
+            for sub_source in LocalMachine.FileHandler.list_dir(source_full_path):
+                sub_source_full_path = os.path.join(source_full_path, sub_source)
+                if check_all_extensions(sub_source):
+                    resources_path.append(sub_source_full_path)
+    return resources_path, subfolders

toolkit/dashboard_apps/NeoEffectsDemo.py

@@ -25,40 +25,33 @@ def app(devfid=None, pwd=None):
     status, answer = CLIENT.run(args)
     time.sleep(2)
 
-    status, answer = CLIENT.run(['neoeffects rainbow &&'])
+    status, answer = CLIENT.run(['neoeffects rainbow'])
     time.sleep(2)
-    status, answer = CLIENT.run(['task kill neoeffects.rainbow'])
 
     status, answer = CLIENT.run(['neoeffects color 122 18 0'])
 
-    status, answer = CLIENT.run(['neoeffects cycle &&'])
+    status, answer = CLIENT.run(['neoeffects cycle'])
     time.sleep(2)
-    status, answer = CLIENT.run(['task kill neoeffects.cycle'])
 
-    status, answer = CLIENT.run(['neoeffects meteor &&'])
+    status, answer = CLIENT.run(['neoeffects meteor'])
     time.sleep(2)
-    status, answer = CLIENT.run(['task kill neoeffects.meteor'])
 
-    status, answer = CLIENT.run(['neoeffects fire &&'])
+    status, answer = CLIENT.run(['neoeffects fire'])
     time.sleep(2)
-    status, answer = CLIENT.run(['task kill neoeffects.fire'])
 
-    time.sleep(1)
 
     status, answer = CLIENT.run(['neoeffects random &&500'])
 
-    status, answer = CLIENT.run(['neoeffects cycle &&'])
+    status, answer = CLIENT.run(['neoeffects cycle'])
     time.sleep(3)
-    status, answer = CLIENT.run(['task kill neoeffects.cycle'])
 
-    status, answer = CLIENT.run(['neoeffects meteor &&'])
+    status, answer = CLIENT.run(['neoeffects meteor'])
     time.sleep(3)
-    status, answer = CLIENT.run(['task kill neoeffects.meteor'])
 
-    status, answer = CLIENT.run(['neoeffects fire &&'])
+    status, answer = CLIENT.run(['neoeffects fire'])
     time.sleep(3)
-    status, answer = CLIENT.run(['task kill neoeffects.fire'])
 
+    status, answer = CLIENT.run(['task kill neoeffects.player'])
     status, answer = CLIENT.run(['task kill neoeffects.random'])
     status, answer = CLIENT.run(['neopixel color 122 18 0'])
 

toolkit/dashboard_apps/QMI8685_GYRO.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import json
+import time
+import multiprocessing as mp
+
+MYPATH = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.join(MYPATH, '../lib/'))
+
+try:
+    from ._app_base import AppBase
+except ImportError:
+    from _app_base import AppBase
+
+def print_table(data):
+    os.system('cls' if os.name == 'nt' else 'clear')
+    print(f"{'Sensor':<10} {'X':>10} {'Y':>10} {'Z':>10}")
+    for sensor in ['accel', 'gyro']:
+        x, y, z = data[sensor]
+        print(f"{sensor:<10} {x:10.2f} {y:10.2f} {z:10.2f}")
+    if 'temp' in data:
+        print(f"{'temp':<10} {data['temp']:>10.2f}")
+
+
+def app(devfid=None, pwd=None):
+    CLIENT = AppBase(device=devfid, password=pwd)
+    measure_cmd = 'qmi8685 measure >json'
+
+    mp.set_start_method('spawn', force=True)
+    queue = mp.Queue()
+
+    # Start GUI process
+    from ._gyro_visualizer import visualizer_main
+    p = mp.Process(target=visualizer_main, args=(queue,))
+    p.start()
+
+    try:
+        for _ in range(10000):
+            output = CLIENT.execute([measure_cmd])
+            status, result = output[0], output[1]
+
+            if status:
+                try:
+                    parsed = json.loads(result)
+                    print_table(parsed)
+                    queue.put(parsed)
+                except Exception as e:
+                    print(f"[Visualizer queue issue] {e}")
+                    break
+            else:
+                print(f"[WARN] {result}")
+
+            time.sleep(0.05)
+
+    except KeyboardInterrupt:
+        print("Interrupted by user.")
+
+    finally:
+        if p.is_alive():
+            p.terminate()
+            p.join()
+
+
+
+if __name__ == "__main__":
+    app()

toolkit/dashboard_apps/_app_base.py

@@ -20,10 +20,10 @@ class AppBase:
     def get_device(self):
         return self.device
 
-    def execute(self, cmd_list, tout=5):
+    def execute(self, cmd_list, tout=5, verbose=False):
         cmd_args = self.base_cmd() + cmd_list
         print(f"Execute: {cmd_args}")
-        return socketClient.run(cmd_args, timeout=tout)
+        return socketClient.run(cmd_args, timeout=tout, verbose=verbose)
 
     def run(self, cmd_list):
         """Legacy"""

toolkit/dashboard_apps/_gyro_visualizer.py

@@ -0,0 +1,78 @@
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import multiprocessing as mp
+from collections import deque
+from datetime import datetime
+import matplotlib.dates as mdates
+
+def visualizer_main(queue):
+    # Make figure wider and a bit taller
+    fig, (ax_accel, ax_gyro) = plt.subplots(2, 1, figsize=(14, 8))
+    plt.subplots_adjust(top=0.88, bottom=0.12, hspace=0.3)
+
+    history = 100
+    accel_data = {'x': deque([0] * history, maxlen=history),
+                  'y': deque([0] * history, maxlen=history),
+                  'z': deque([0] * history, maxlen=history)}
+    gyro_data = {'x': deque([0] * history, maxlen=history),
+                 'y': deque([0] * history, maxlen=history),
+                 'z': deque([0] * history, maxlen=history)}
+    time_axis = deque([datetime.now()] * history, maxlen=history)
+
+    # Increase line width here
+    line_width = 2.5
+
+    accel_lines = {
+        axis: ax_accel.plot([], [], label=f'accel_{axis}', linewidth=line_width)[0]
+        for axis in 'xyz'
+    }
+    gyro_lines = {
+        axis: ax_gyro.plot([], [], label=f'gyro_{axis}', linewidth=line_width)[0]
+        for axis in 'xyz'
+    }
+
+    ax_accel.set_ylim(-2, 2)
+    ax_gyro.set_ylim(-300, 300)
+
+    for ax in [ax_accel, ax_gyro]:
+        ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
+        ax.legend()
+        ax.grid(True)
+        ax.set_xlabel("Time (H:M:S)")
+
+    ax_accel.set_title("Acceleration")
+    ax_gyro.set_title("Gyroscope")
+
+    def update(_):
+        try:
+            while not queue.empty():
+                data = queue.get_nowait()
+                current_time = datetime.now()
+                time_axis.append(current_time)
+
+                for axis, val in zip('xyz', data['accel']):
+                    accel_data[axis].append(val)
+                for axis, val in zip('xyz', data['gyro']):
+                    gyro_data[axis].append(val)
+        except Exception as e:
+            print(f"Visualizer error: {e}")
+            return
+
+        for axis in 'xyz':
+            accel_lines[axis].set_data(time_axis, accel_data[axis])
+            gyro_lines[axis].set_data(time_axis, gyro_data[axis])
+
+        for ax in [ax_accel, ax_gyro]:
+            ax.set_xlim(time_axis[0], time_axis[-1])
+            ax.figure.autofmt_xdate()
+
+        return list(accel_lines.values()) + list(gyro_lines.values())
+
+    ani = animation.FuncAnimation(fig, update, interval=50)
+    plt.show()
+
+
+if __name__ == "__main__":
+    mp.set_start_method('spawn')
+    queue = mp.Queue()
+    visualizer_main(queue)

toolkit/lib/LocalMachine.py

@@ -186,11 +186,13 @@ class FileHandler:
                     os.remove(path)
                 elif type_ == 'd':
                     shutil.rmtree(path)
+                return True
         except Exception as e:
             if ignore:
                 debug_print("[DEBUG] Removing " + path + " is forced to ignore failure: " + str(e))
             else:
                 raise Exception("Cannot remove " + path + ": " + str(e))
+        return False
 
     @staticmethod
     def extract_tar(targz, extract_path):
@@ -210,7 +212,10 @@ class FileHandler:
     def copy(from_path, to_path):
         debug_print("[DEBUG] Copy " + from_path + " to " + to_path)
         try:
-            shutil.copy(from_path, to_path)
+            if os.path.isdir(from_path):
+                shutil.copytree(from_path, to_path, dirs_exist_ok=True)
+            else:
+                shutil.copy(from_path, to_path)
             return True
         except Exception as e:
             debug_print("Copy error: {}".format(e))

toolkit/lib/file_extensions.py

@@ -1,7 +1,7 @@
 
-
-ENABLED_EXTENSIONS = ('py', 'mpy', 'js', 'css', 'html')
-WEB_ONLY = ('js', 'html', 'css')
+PYTHON_EXTENSIONS = ('py', 'mpy')
+WEB_ONLY = ('js', 'html', 'css', 'json', 'ico', 'jpeg', 'png')
+ENABLED_EXTENSIONS = PYTHON_EXTENSIONS + WEB_ONLY
 
 def check_all_extensions(path):
     extension = path.split('.')[-1]
@@ -13,4 +13,10 @@ def check_web_extensions(path):
     extension = path.split('.')[-1]
     if extension in WEB_ONLY:
         return True
+    return False
+
+def check_python_extensions(path):
+    extension = path.split('.')[-1]
+    if extension in PYTHON_EXTENSIONS:
+        return True
     return False

toolkit/micrOSlint.py

@@ -222,7 +222,9 @@ def _run_pylint(file_name):
         '--disable=broad-exception-caught',         # Disable BROAD exception
         '--disable=broad-exception-raised',         # Disable BROAD exception
         '--disable=too-many-return-statements',     # :D I don't think so :D
-        '--disable=too-many-branches'               # :D I don't think so :D
+        '--disable=too-many-branches',              # :D I don't think so :D
+        '--disable=too-many-positional-arguments',  # :D I don't think so :D
+        '--disable=too-many-instance-attributes'    # :D I don't think so :D
     ]
     if file_name in ['Tasks.py', 'microIO.py', 'Types.py']:
         pylint_opts.append('--disable=exec-used')   # Disable micrOS execution core exec/eval warning

toolkit/simulator_lib/machine.py

@@ -2,7 +2,6 @@ from threading import Thread
 import time
 import micropython
 from sim_console import console
-import sys
 
 
 def machine(*args, **kwargs):

toolkit/simulator_lib/neopixel.py

@@ -1,4 +1,4 @@
-
+from sim_console import console
 
 class NeoPixel:
     __instance = None
@@ -17,9 +17,10 @@ class NeoPixel:
         return cls.__pix_list[key]
 
     def __setitem__(cls, key, value):
+        console(f"Update NeoPixel at index {key} to {value}")
         cls.__pix_list[key] = value
 
     def write(cls):
-        pass
+        console(f"Neopixel write: {cls.__pix_list}")
 
 

toolkit/socketClient.py

@@ -424,7 +424,7 @@ def socket_commandline_args(arg_list):
     return ' <a> '.join(command_buffer), return_action_dict
 
 
-def run(arg_list=[], timeout=10):
+def run(arg_list=[], timeout=10, verbose=False):
     """ Run from code
         - Handles extra command line arguments
     """
@@ -434,7 +434,8 @@ def run(arg_list=[], timeout=10):
     output = False, ''
     try:
         #print("Socket run (args): {}".format(args))
-        output = main(args, host=host, port=port, timeout=timeout, pwd=action['password'], verbose=action['verbose'])
+        verbose = verbose or action['verbose']
+        output = main(args, host=host, port=port, timeout=timeout, pwd=action['password'], verbose=verbose)
     except Exception as e:
         if "TimeOut" in str(e):
             print("Resolve device by host ... {}.local {}:{}:{}".format(fid, host, port, uid))