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

toolkit/DevEnvOTA.py

@@ -5,22 +5,27 @@ 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.MicrosFiles import check_all_extensions, check_web_extensions, check_python_extensions, micros_resource_list
+    from .lib.Repository import git_clone_archive, git_clone
 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
-    sys.path.append(MYPATH)
-    import socketClient
+    from lib.MicrosFiles import check_all_extensions, check_web_extensions, check_python_extensions, micros_resource_list
+    from lib.Repository import git_clone_archive, git_clone
+
+sys.path.append(MYPATH)
+import socketClient
 
 
 #################################################
@@ -37,7 +42,7 @@ class OTA(Compile):
         # Skip the following modules in OTA update (safe mode) to have recovery mode
         self.safe_mode_file_exception_list = ['main.py', 'micrOSloader.mpy',
                                               'Network.mpy', 'Config.mpy',
-                                              'Debug.mpy']
+                                              'Debug.mpy', 'Files.py']
 
     def safe_core_list(self):
         return self.safe_mode_file_exception_list
@@ -52,15 +57,17 @@ class OTA(Compile):
             # Change workdir
             workdir_handler = LocalMachine.SimplePopPushd()
             workdir_handler.pushd(os.path.dirname(os.path.dirname(webrepl_path)))
+            webrepl_url = 'https://github.com/micropython/webrepl.git'
 
-            command = 'git clone {url} {name}'.format(
-                name='webrepl',
-                url='https://github.com/micropython/webrepl.git')
-            self.console("Clone webrepl repo: {}".format(command))
+            self.console(f"Clone webrepl repo: {webrepl_url}")
             if self.dry_run:
-                exitcode, stdout, stderr = 0, 'dry-run', ''
+                exitcode, stdout, stderr = 0, "", ""
             else:
-                exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(command, shell=True)
+                # Git clone with command line tool
+                exitcode, stdout, stderr = git_clone(url=webrepl_url)
+                if exitcode != 0:
+                    # Git clone archive - without git
+                    exitcode, stdout, stderr = git_clone_archive(url=webrepl_url)
 
             # Restore workdir
             workdir_handler.popd()
@@ -156,7 +163,6 @@ class OTA(Compile):
     def update_with_webrepl(self, force=False, device=None, lm_only=False, loader_update=False, ota_password='ADmin123'):
         """
         OTA UPDATE via webrepl
-            git clone https://github.com/micropython/webrepl.git
             info: https://techoverflow.net/2020/02/22/how-to-upload-files-to-micropython-using-webrepl-using-webrepl_cli-py/
             ./webrepl/webrepl_cli.py -p <password> <input_file> espressif.local:<output_file>
         """
@@ -237,9 +243,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)
@@ -264,7 +270,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
@@ -397,7 +404,32 @@ 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):
+    @staticmethod
+    def _dynamic_file_target(source_name, force_lm):
+        """
+        Dynamic file target path based on file extension.
+        -> web
+        -> modules
+        -> config
+        -> data
+        """
+        # Force LM update - user load modules - drag n drop files
+        if force_lm and not source_name.startswith('LM_') and source_name.endswith('py'):
+            source_name = 'LM_{}'.format(source_name)
+        # 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 check_python_extensions(source_name):
+            source_name_target = os.path.join('modules', source_name)
+        elif source_name.endswith("node_config.json") or source_name.endswith("requirements.txt"):
+            source_name_target = os.path.join('config', source_name)
+        else:
+            # Copy file to micrOS data folder (not web, not module, not config)
+            source_name_target = os.path.join('data', source_name)
+        return source_name_target
+
+    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/
@@ -406,7 +438,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
@@ -453,11 +489,11 @@ class OTA(Compile):
             # Copy retry mechanism
             exitcode = -1
             source_name = os.path.basename(source)
-            source_name_target = source_name
-
-            # Force LM update - user load modules - drag n drop files
-            if force_lm and not source_name.startswith('LM_') and source_name.endswith('.py'):
-                source_name_target = 'LM_{}'.format(source_name)
+            if upload_root_dir is None:
+                source_name_target = self._dynamic_file_target(source_name, force_lm)
+            else:
+                # MAIN USE-CASE
+                source_name_target = source.replace(upload_root_dir, '')
 
             command = '{python} {api} -p {pwd} {input_file} {host}:{target_path}'.format(
                 python=self.python_interpreter,

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 .lib.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 lib.MicrosFiles import micros_resource_list
 
 
 class USB(Compile):
@@ -33,6 +35,7 @@ class USB(Compile):
         self.micrOS_node_config_archive = os.path.join(MYPATH, "user_data/node_config_archive")
         self.node_config_profiles_path = os.path.join(MYPATH, "../micrOS/release_info/node_config_profiles/")
         self.esptool_interface = self.get_valid_esptool_cmd()
+        self.micrOS_node_config_path = "config/node_config.json"
         self.dev_types_and_cmds = \
             {'esp32':
                  {'erase': '{esptool_interface} --port {dev} erase_flash',
@@ -65,17 +68,23 @@ class USB(Compile):
                  {'erase': '{esptool_interface} --chip esp32s3 --port {dev} erase_flash',
                   'deploy': '{esptool_interface} --chip esp32s3 --port {dev} write_flash -z 0 {micropython}',
                   'mpremote_cmd': 'mpremote',
-                  'cmd_line_info': '[!!!] Fully automatic deployment.'},
+                  'cmd_line_info': '[!HINNT!] Press boot button under connecting the board over USB: enables flash erase'},
              'esp32s3':
                  {'erase': '{esptool_interface} --chip esp32s3 --port {dev} erase_flash',
                   'deploy': '{esptool_interface} --chip esp32s3 --port {dev} write_flash -z 0 {micropython}',
                   'mpremote_cmd': 'mpremote',
-                  'cmd_line_info': '[!!!] Fully automatic deployment.'},
+                  #'ampy_cmd': 'ampy -p {dev} -b 115200 -d 2 {args}',
+                  'cmd_line_info': '[!HINNT!] Press boot button under connecting board over USB: enables flash erase'},
              'esp32c3':
                  {'erase': '{esptool_interface} --chip esp32c3 --port {dev} erase_flash',
                   '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
@@ -201,6 +210,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
@@ -217,17 +258,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 + os.sep, '') 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)
@@ -237,9 +281,9 @@ 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} cp {source} :{source}'
+                command = f'{mpremote_cmd} fs cp {source} :{source}'     # new mpremote <1.24.1
             if ' ' in source:
                 self.console("[{}%][SKIP] micrOS deploy via USB: {}".format(percent, command))
                 continue
@@ -254,17 +298,17 @@ class USB(Compile):
     def update_micros_via_usb(self, force=False):
         self.select_board_n_micropython()
         exitcode, stdout, stderr = self.__get_node_config()
-        print(self.__get_node_config())
         if exitcode == 0:
             self.console("Get Node config (node_config.json):")
             pprint.PrettyPrinter(indent=4).pprint(json.loads(stdout))
             repo_version, node_version = self.get_micrOS_version(stdout)
             self.console("Repo version: {} Node_version: {}".format(repo_version, node_version))
             if repo_version != node_version or force:
+                self._cleanup_precompiled_dir()
                 self.console("Update necesarry {} -> {}".format(node_version, repo_version), state='ok')
                 state = self.__override_local_config_from_node(node_config=stdout)
                 if state:
-                    self.deploy_micros(restore=False)
+                    self.deploy_micros(restore_config=False, cleanup_workdir=False)
                 else:
                     self.console("Saving node config failed - SKIP update/redeploy", state='err')
             else:
@@ -278,17 +322,17 @@ class USB(Compile):
         self.execution_verdict.append("[OK] usb_update was finished")
         return True
 
-    def deploy_micros(self, restore=True, purge_conf=False):
+    def deploy_micros(self, restore_config=True, cleanup_workdir=True):
         """
         Clean board deployment with micropython + micrOS
-        :param restore: restore and create node config
-        :param purge_conf: purge node config - deletion
+        :param restore_config: restore and create node config
+        :param cleanup_workdir: clean up workdir as part of precompile
         :return: None
         """
         self.select_board_n_micropython()
-        if purge_conf:
-            self._purge_node_config_from_workdir()
-        if restore:
+        self.precompile_micros(cleanup=cleanup_workdir)
+
+        if restore_config:
             self._restore_and_create_node_config()
 
         is_erased = False
@@ -300,9 +344,7 @@ class USB(Compile):
                 break
         if is_erased:
             if self.deploy_micropython_dev():
-                time.sleep(2)
-                self.precompile_micros()
-                time.sleep(2)
+                time.sleep(3)
                 self.put_micros_to_dev()
                 self._archive_node_config()
             else:
@@ -342,7 +384,7 @@ class USB(Compile):
             # List USB devices on Windows
             import serial.tools.list_ports as serial_port_list      # Import here (only windows...), package not exists on some platforms
             ports = list(serial_port_list.comports())
-            win_known_devices = ("CP210", "CH340", "CH343")
+            win_known_devices = ("CP210", "CH340", "CH343", "CH9102")
             for item in ports:
                 self.console(f'[Win] Com device: {item.description}')
                 if any(device in str(item.description) for device in win_known_devices):
@@ -372,7 +414,7 @@ class USB(Compile):
     #############################
 
     def _purge_node_config_from_workdir(self):
-        path = os.path.join(self.precompiled_micrOS_dir_path, 'node_config.json')
+        path = os.path.join(self.precompiled_micrOS_dir_path, self.micrOS_node_config_path)
         LocalMachine.FileHandler().remove(path, ignore=False)
 
     def _restore_and_create_node_config(self):
@@ -388,24 +430,22 @@ class USB(Compile):
             self.console("  [{}{}{}] {}".format(Colors.BOLD, index, Colors.NC, conf))
         self.console("  [{}{}{}] {}".format(Colors.BOLD, index + 1, Colors.NC, 'NEW'))
         self.console("  [{}{}{}] {}".format(Colors.BOLD, index + 2, Colors.NC, 'SKIP'))
-        conf_list.append(os.path.join('node_config.json'))
+        conf_list.append(self.micrOS_node_config_path)
         conf_list.append(os.path.join('SKIP'))
         selected_index = int(input("Select index: "))
         # Use (already existing) selected config to restore
         selected_config = conf_list[selected_index]
-        if '-' in selected_config:
+        target_path = os.path.join(self.precompiled_micrOS_dir_path, self.micrOS_node_config_path)
+        if selected_config.endswith(".json"):
             # Restore saved config
-            target_path = os.path.join(self.precompiled_micrOS_dir_path, selected_config.split('-')[1])
             source_path = os.path.join(self.micrOS_node_config_archive, selected_config)
         elif selected_index == len(conf_list) - 1:
             # SKIP restore config - use the local version in mpy-micrOS folder
-            target_path = os.path.join(self.precompiled_micrOS_dir_path, 'node_config.json')
             source_path = None
         else:
             # Create new config - from micrOS folder path -> mpy-micrOS folder
-            target_path = os.path.join(self.precompiled_micrOS_dir_path, selected_config)
             source_path = os.path.join(self.micrOS_dir_path, selected_config)
-        self.console("Restore config: {} -> {}".format(source_path, target_path))
+        self.console(f"Restore config: {source_path} -> {target_path}")
         if source_path is not None:
             LocalMachine.FileHandler.copy(source_path, target_path)
 
@@ -442,9 +482,11 @@ class USB(Compile):
         else:
             self.console("Profile was selected: {}{}{}".format(Colors.OK, profile_list[int(profile)], Colors.NC))
         # Read default conf
-        default_conf_path = os.path.join(self.micros_sim_workspace, 'node_config.json')
+        default_conf_path = os.path.join(self.micrOS_dir_path, self.micrOS_node_config_path)
         if not os.path.isfile(default_conf_path):
-            self.micrOS_sim_default_conf_create()
+            if not self.__generate_default_config():
+                self.console(f"Missing default config: {default_conf_path}", state="warn")
+                return None
         with open(default_conf_path, 'r') as f:
             default_conf_dict = json.load(f)
         # Read profile
@@ -509,10 +551,9 @@ class USB(Compile):
         create_default_config_command = "{} Config.py".format(self.python_interpreter)
         if not self.dry_run:
             # Remove actual defualt config
-            LocalMachine.FileHandler.remove(os.path.join(self.micrOS_dir_path, 'node_config.json'))
+            LocalMachine.FileHandler.remove(os.path.join(self.micrOS_dir_path, self.micrOS_node_config_path))
             # Create default config
-            exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(create_default_config_command,
-                                                                               shell=True)
+            exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(create_default_config_command, shell=True)
         else:
             exitcode = 0
         # Restore workdir
@@ -541,7 +582,7 @@ class USB(Compile):
 
     def __validate_json(self):
         is_valid = True
-        local_config_path = os.path.join(self.precompiled_micrOS_dir_path, 'node_config.json')
+        local_config_path = os.path.join(self.precompiled_micrOS_dir_path, self.micrOS_node_config_path)
         try:
             if os.path.isfile(local_config_path):
                 with open(local_config_path, 'r') as f:
@@ -553,6 +594,9 @@ class USB(Compile):
         return is_valid
 
     def __safe_execute_mpremote_cmd(self, command, source, retry=8):
+        if sys.platform.startswith('win'):
+            # Because windows is a shit... python commands requires unix like separators
+            command = command.replace('\\', '/')
         retry_orig = retry
         status = False
         for retry in range(1, retry_orig):
@@ -607,24 +651,34 @@ class USB(Compile):
         return processid
 
     def __get_node_config(self):
+
+        def _get_config(path):
+            mpremote_cmd = self.dev_types_and_cmds[self.selected_device_type]['mpremote_cmd']
+            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'get {path}'))
+            else:
+                _command = f'{mpremote_cmd} fs cat {path}'  # new mpremote <1.24.1
+            _exitcode, _stdout, _stderr = LocalMachine.CommandHandler.run_command(_command, shell=True)
+            return _exitcode, _stdout, _stderr
+
         device = self.get_devices()[0]
         self.console(f"Get node config over USB: {device}")
-        mpremote_cmd = self.dev_types_and_cmds[self.selected_device_type]['mpremote_cmd']
-        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='get node_config.json')
+        if self.dry_run:
+            exitcode, stdout, stderr = 0, '{"key": "Dummy stdout"}', ''
         else:
-            command = f'{mpremote_cmd} cat node_config.json'
-        if not self.dry_run:
-            exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(command, shell=True)
+            exitcode, stdout, stderr = _get_config("node_config.json")                  # Legacy
+            if exitcode != 0:
+                exitcode, stdout, stderr = _get_config("/" + self.micrOS_node_config_path)    # New
             self._archive_node_config()
-        else:
-            exitcode = 0
-            stdout = '{"key": "Dummy stdout"}'
-            stderr = ''
+
         if '\n' in stdout:
             stdout = stdout.strip().splitlines()
-            stdout = str([line for line in stdout if '{' in line and '}' in line][0])
+            try:
+                stdout = str([line for line in stdout if '{' in line and '}' in line][0])
+            except Exception as ejson:
+                raise Exception(f"Invalid json format from device: {ejson}")
         return exitcode, stdout, stderr
 
     def backup_node_config(self):
@@ -639,12 +693,12 @@ class USB(Compile):
                 if state:
                     self._archive_node_config()
                     return True
-        self.console("exitcode: {}\n{}\n{}".format(exitcode, stdout, stderr))
+            self.console("exitcode: {}\n{}\n{}".format(exitcode, stdout, stderr))
         return False
 
     def _archive_node_config(self):
         self.console("ARCHIVE NODE_CONFIG.JSON")
-        local_node_config = os.path.join(self.precompiled_micrOS_dir_path, 'node_config.json')
+        local_node_config = os.path.join(self.precompiled_micrOS_dir_path, self.micrOS_node_config_path)
         if os.path.isfile(local_node_config):
             with open(local_node_config, 'r') as f:
                 node_devfid = json.load(f)['devfid']
@@ -656,8 +710,9 @@ class USB(Compile):
                 LocalMachine.FileHandler.copy(local_node_config, archive_node_config)
 
     def __override_local_config_from_node(self, node_config=None):
-        node_config_path = os.path.join(self.precompiled_micrOS_dir_path, 'node_config.json')
-        self.console("Overwrite node_config.json with connected node config: {}".format(node_config_path), state='ok')
+        self.ensure_precompiled_target_dir("config")
+        node_config_path = os.path.join(self.precompiled_micrOS_dir_path, self.micrOS_node_config_path)
+        self.console(f"Overwrite node_config.json with connected node config: {node_config_path}", state='ok')
         if not self.dry_run and node_config is not None:
             with open(node_config_path, 'w') as f:
                 f.write(node_config)
@@ -671,7 +726,7 @@ class USB(Compile):
             # Legacy ampy command (esp32 auto reboot tolerance...)
             command = self.dev_types_and_cmds[self.selected_device_type]['ampy_cmd'].format(dev=device, args='ls')
         else:
-            command = f"{mpremote_cmd} ls"
+            command = f"{mpremote_cmd} fs ls"       # new mpremote <1.24.1
         if not self.dry_run:
             self.console("CMD: {}".format(command))
             exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(command, shell=True, debug=False)

toolkit/Gateway.py

@@ -154,7 +154,7 @@ class Hello(Resource):
 
 class SendCmd(Resource):
     """
-    http://127.0.0.1:5000/sendcmd/micr240ac4f679e8OS/rgb+toggle
+    http://127.0.0.1:5005/sendcmd/micr240ac4f679e8OS/rgb+toggle
         {
           "cmd": [
             "rgb",
@@ -211,7 +211,7 @@ class ListDevices(Resource):
 
     def sort_devices(self):
         device_struct = socketClient.ConnectionData.list_devices()
-        online_devices = socketClient.ConnectionData.nodes_status()
+        online_devices = socketClient.ConnectionData.nodes_status(feature_stat=False)
         filtered_devices = {"online": {}, "offline": {}}
         for uid, data in device_struct.items():
             if data[0] in online_devices:
@@ -554,9 +554,9 @@ class ForwardImg(Resource):
         for devid, dev_conn_data in ListDevices.DEVICE_CACHE['online'].items():
             # IP, PORT, FID
             device = dev_conn_data[2]
-            response = SendCmd.runcmd(device, 'lmpacman module')['response']
+            response = SendCmd.runcmd(device, 'modules')['response']
             print(f"\n\n{response}\n\n")
-            if 'LM_OV2640' in response:
+            if 'OV2640' in response:
                 ForwardImg.CAM_DEVICES.add(device)
         return jsonify(list(ForwardImg.CAM_DEVICES))
 
@@ -621,11 +621,11 @@ api.add_resource(WebHook, '/webhooks', '/webhooks/<string:payload>', '/webhooks/
 
 def gateway(debug=True):
     global API_URL_CACHE
-    API_URL_CACHE = f"http://{my_local_ip()}:5000"
+    API_URL_CACHE = f"http://{my_local_ip()}:5005"
     print("\n############### START MICROS GATEWAY ###############")
     print("#             {}            #".format(API_URL_CACHE))
     print("####################################################\n")
-    app.run(debug=debug, use_reloader=debug, host='0.0.0.0', port=5000)     # host='0.0.0.0' automatic, manual: host=my_local_ip()
+    app.run(debug=debug, use_reloader=debug, host='0.0.0.0', port=5005)     # host='0.0.0.0' automatic, manual: host=my_local_ip()
 
 
 # driver function

toolkit/LM_to_compile.dat

@@ -11,8 +11,6 @@ LM_bme280.py
 LM_co2.py
 LM_dht11.py
 LM_light_sensor.py
-LM_L298N_DCmotor.py
-LM_intercon.py
 LM_tinyrgb.py
 LM_repair.py
 LM_buzzer.py
@@ -25,11 +23,10 @@ LM_cct.py
 LM_presence.py
 LM_telegram.py
 LM_oled_sh1106.py
-LM_lmpacman.py
+LM_pacman.py
 LM_aht10.py
 LM_rgbcct.py
 LM_OV2640.py
-LM_keychain.py
 LM_i2s_mic.py
 LM_rest.py
 LM_gameOfLife.py
@@ -40,3 +37,8 @@ LM_oledui.py
 LM_haptic.py
 LM_distance.py
 LM_veml7700.py
+LM_neomatrix.py
+LM_L298N.py
+LM_cluster.py
+LM_fileserver.py
+LM_web.py