micrOSDevToolKit 2.1.5__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
@@ -386,7 +393,43 @@ class OTA(Compile):
         self.execution_verdict.append("[OK] ota_update was finished")
         return up_again_status
 
-    def ota_webrepl_update_core(self, device=None, upload_path_list=[], ota_password='ADmin123', force_lm=False):
+    @staticmethod
+    def sim_ota_update(file_list, force_lm):
+        sim_path = os.path.join(MYPATH, "workspace/simulator")
+        for source in file_list:
+            f_name = os.path.basename(source)
+            if force_lm and not f_name.startswith('LM_') and f_name.endswith('.py'):
+                f_name = 'LM_{}'.format(f_name)
+            target = os.path.join(sim_path, f_name)
+            print(f"[SIM] 'OTA' COPY FILES... {source} -> {target}")
+            LocalMachine.FileHandler().copy(source, target)
+
+    @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/
@@ -395,7 +438,14 @@ 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
 
         # GET webrepl repo
         if not self.__clone_webrepl_repo():
@@ -439,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

@@ -3,6 +3,7 @@ import sys
 import json
 import time
 import pprint
+
 MYPATH = os.path.dirname(__file__)
 print("Module [DevEnvOTA] path: {} __package__: {} __name__: {} __file__: {}".format(
     sys.path[0], __package__, __name__, MYPATH))
@@ -12,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):
@@ -31,33 +34,30 @@ class USB(Compile):
         self.micropython_bin_dir_path = os.path.join(MYPATH, "../micrOS/micropython")
         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.py --port {dev} erase_flash',
-                  'deploy': 'esptool.py --chip esp32 --port {dev} --baud 460800 write_flash -z 0x1000 {micropython}',
+                 {'erase': '{esptool_interface} --port {dev} erase_flash',
+                  'deploy': '{esptool_interface} --chip esp32 --port {dev} --baud 460800 write_flash -z 0x1000 {micropython}',
                   'ampy_cmd': 'ampy -p {dev} -b 115200 -d 2 {args}',
                   'mpremote_cmd': None,
                   'cmd_line_info': '[!HINT!] PRESS [EN] BUTTON TO ENABLE DEVICE ERASE...'},
              'esp32cam':
-                  {'erase': 'esptool.py --port {dev} erase_flash',
-                   'deploy': 'esptool.py --chip esp32 --port {dev} --baud 460800 write_flash -z 0x1000 {micropython}',
+                  {'erase': '{esptool_interface} --port {dev} erase_flash',
+                   'deploy': '{esptool_interface} --chip esp32 --port {dev} --baud 460800 write_flash -z 0x1000 {micropython}',
                    'mpremote_cmd': 'mpremote',
                    'cmd_line_info': '*** [!DISCLAIMER!] ***\n\tUSB copy not works with some serial interface\n\tCopy manually: toolkit/workspace/precompiled/micrOSloader.mpy\n\tNetwork.mpy Debug.mpy ConfigHandler.mpy main.py\n\tThen push OTA update over AP mode... Then you are done'},
              'esp32s2':
-                 {'erase': 'esptool.py --chip esp32s2 --port {dev} --after no_reset erase_flash',
-                  'deploy': 'esptool.py --chip esp32s2 --port {dev} --after no_reset --baud 460800 write_flash -z 0x1000 {micropython}',
+                 {'erase': '{esptool_interface} --chip esp32s2 --port {dev} --after no_reset erase_flash',
+                  'deploy': '{esptool_interface} --chip esp32s2 --port {dev} --after no_reset --baud 460800 write_flash -z 0x1000 {micropython}',
                   'mpremote_cmd': 'mpremote',
                   'cmd_line_info': '[!HINT!] Hold on Button 0 -> Press Button Reset -> Release Button 0 TO ENABLE DEVICE ERASE...'},
              'tinypico':
-                 {'erase': 'esptool.py --port {dev} erase_flash',
-                  'deploy': 'esptool.py --chip esp32 --port {dev} --baud 460800 write_flash -z 0x1000 {micropython}',
-                  'mpremote_cmd': 'mpremote',
-                  'cmd_line_info': ''},
-             'tinypico-usbc':
-                 {'erase': 'esptool.py --port {dev} erase_flash',
-                  'deploy': 'esptool.py --chip esp32 --port {dev} --baud 921600 write_flash -z 0x1000 {micropython}',
+                 {'erase': '{esptool_interface} --port {dev} erase_flash',
+                  'deploy': '{esptool_interface} --chip esp32 --port {dev} --baud 921600 write_flash -z 0x1000 {micropython}',
+                  'mpremote_cmd': None,         # USB update (node_config backup) not works - freeze with: mpremote
                   'ampy_cmd': 'ampy -p {dev} -b 115200 -d 2 {args}',
-                  'mpremote_cmd': None,
                   'cmd_line_info': ''},
              'rpi-pico-w':
                  {'erase': None,
@@ -65,18 +65,24 @@ class USB(Compile):
                   'mpremote_cmd': 'mpremote',
                   'cmd_line_info': '[!!!] Experimental device - no stable micropython yet'},
              'esp32s3_spiram_oct':
-                 {'erase': 'esptool.py --chip esp32s3 --port {dev} erase_flash',
-                  'deploy': 'esptool.py --chip esp32s3 --port {dev} write_flash -z 0 {micropython}',
+                 {'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.py --chip esp32s3 --port {dev} erase_flash',
-                  'deploy': 'esptool.py --chip esp32s3 --port {dev} write_flash -z 0 {micropython}',
+                 {'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.py --chip esp32c3 --port {dev} erase_flash',
-                  'deploy': 'esptool.py --chip esp32c3 --port {dev} --baud 460800 write_flash -z 0x0 {micropython}',
+                 {'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...'},
              }
@@ -85,6 +91,22 @@ class USB(Compile):
             install_usb_serial_driver()
             USB.usb_driver_ok = True
 
+    @staticmethod
+    def get_valid_esptool_cmd():
+        # Windows / Linux / MacOS installation dependencies
+        command_possibilities = ("esptool.py", "esptool")
+        for cmd in command_possibilities:
+            validate_cmd = f"{cmd} -h"
+            exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(validate_cmd, shell=True)
+            if exitcode == 0:
+                return cmd
+        print("!"*60)
+        print(f"{Colors.ERR}No esptool available... USB features are not available{Colors.NC}")
+        print("!"*60)
+        time.sleep(5)
+        return command_possibilities[0]     # Default
+
+
     #############################
     #       Main interfaces     #
     #############################
@@ -137,7 +159,7 @@ class USB(Compile):
 
         selected_device = self.get_devices()[0]
         print("selected_device_port: {}".format(selected_device))
-        command = erase_cmd.format(dev=selected_device)
+        command = erase_cmd.format(dev=selected_device, esptool_interface=self.esptool_interface)
         self.console("CMD: {}".format(command))
         if self.dry_run:
             exitcode = 0
@@ -171,7 +193,8 @@ class USB(Compile):
 
         selected_device = self.get_devices()[0]
         selected_micropython = self.selected_micropython_bin
-        command = deploy_cmd.format(dev=selected_device, micropython=selected_micropython)
+        command = deploy_cmd.format(dev=selected_device, micropython=selected_micropython,
+                                    esptool_interface=self.esptool_interface)
         self.console("CMD: {}".format(command))
         if self.dry_run:
             exitcode = 0
@@ -187,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
@@ -203,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)
@@ -223,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
@@ -240,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:
@@ -264,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
@@ -286,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:
@@ -328,9 +384,10 @@ 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", "CH9102")
             for item in ports:
                 self.console(f'[Win] Com device: {item.description}')
-                if "CP210" in str(item.description) or "CH340" in str(item.description):
+                if any(device in str(item.description) for device in win_known_devices):
                     micros_devices.append(item.device)
                     self.console("Device was found: {}".format(item.device, state="imp"))
         else:
@@ -357,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):
@@ -373,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)
 
@@ -427,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
@@ -494,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
@@ -526,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:
@@ -538,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):
@@ -592,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):
@@ -624,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']
@@ -641,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)
@@ -656,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)