micrOSDevToolKit 2.9.8__py3-none-any.whl → 2.9.10__py3-none-any.whl

{micrOSDevToolKit-2.9.8.dist-info → micrOSDevToolKit-2.9.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

toolkit/DevEnvUSB.py

@@ -65,12 +65,13 @@ 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}',
@@ -239,7 +240,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=f'put {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
@@ -614,7 +615,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='get node_config.json')
         else:
-            command = f'{mpremote_cmd} cat node_config.json'
+            command = f'{mpremote_cmd} fs cat node_config.json'     # new mpremote <1.24.1
         if not self.dry_run:
             exitcode, stdout, stderr = LocalMachine.CommandHandler.run_command(command, shell=True)
             self._archive_node_config()
@@ -671,7 +672,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/MicrOSDevEnv.py

@@ -214,12 +214,22 @@ class MicrOSDevTool(OTA, USB):
         _url = hardcoded_manual["task"]["img"]
         hardcoded_manual['task']['img'] = f'<img src="{_url}" alt="tasks" height=150>'
         module_function_dict_html.update(hardcoded_manual)
-        module_function_json = json.dumps(module_function_dict_html, indent=4)
         import json2html
         table_attributes = 'border="1" cellspacing="1" cellpadding="5" width="80%"'
-        html_table = json2html.json2html.convert(json=module_function_json,
-                                                 table_attributes=table_attributes,
-                                                 clubbing=True, escape=False, encode=False)
+
+        sorted_modules_w_data = dict(sorted(module_function_dict_html.items(), key=lambda item: item[0].lower()))
+        module_shortcuts = ' | '.join(
+            f'<a href="#{mod_name.replace(" ", "_")}">{mod_name}</a>'
+            for mod_name in sorted_modules_w_data)
+        html_tables = module_shortcuts + "<br><hr><br>"
+        for key, value in sorted_modules_w_data.items():
+            anchor = key.replace(" ", "_")  # Replace spaces with underscores for a valid anchor
+            html_tables += f'\n<br><br>\n<h2 id="{anchor}"><a href="#{anchor}">{key}</a></h2>\n'
+            html_tables += json2html.json2html.convert(json=value,
+                                             table_attributes=table_attributes,
+                                             clubbing=True,
+                                             escape=False,
+                                             encode=False)
 
         # http://corelangs.com/css/table/tablecolor.html
         # http://corelangs.com/css/table/tablecolor.html
@@ -267,11 +277,15 @@ Logical pin names aka pin map
   <li><a href="https://github.com/BxNxM/micrOS/blob/master/micrOS/source/IO_rp2.py" target="_blank">rp2 (experimental)</a></li>
 </ul>
 
+<h2>
+Built-in control modules for various peripheries.:
+</h2>
+
 """
         html_body_end = """</body>
 </html>"""
 
-        html_page = html_body_start + html_table + html_body_end
+        html_page = html_body_start + html_tables + html_body_end
         # Write html to file
         with open(static_help_html_path, 'w') as f:
             f.write(html_page)

toolkit/WebRepl.py

@@ -0,0 +1,73 @@
+import sys
+import os
+
+MYDIR = os.path.dirname(__file__)
+print("Module [WebRepl] path: {} __package__: {} __name__: {} __file__: {}".format(
+    sys.path[0], __package__, __name__, MYDIR))
+try:
+    from .lib.TerminalColors import Colors
+    from .lib.LocalMachine import FileHandler, CommandHandler, SimplePopPushd
+    from .socketClient import ConnectionData
+except Exception as e:
+    print("Import warning __name__:{}: {}".format(__name__, e))
+    from lib.TerminalColors import Colors
+    from lib.LocalMachine import FileHandler, CommandHandler, SimplePopPushd
+    from socketClient import ConnectionData
+
+WEBREPL_DIR = os.path.join(MYDIR, "workspace/webrepl")
+MAKE_HTML_WEBPAGE_PATH = os.path.join(WEBREPL_DIR, "make_html_js.py")
+WEBREPL_WEBPAGE_PATH = os.path.join(WEBREPL_DIR, "webrepl.html")
+
+def init_webrepl_frontend():
+    webrepldir_handler = SimplePopPushd()
+    webrepldir_handler.pushd(WEBREPL_DIR)
+
+    is_exists, ftype = FileHandler.path_is_exists(MAKE_HTML_WEBPAGE_PATH)
+    if is_exists and ftype == 'f':
+        print("RUN webrepl/make_html_js.py")
+        exitcode, _, stderr = CommandHandler.run_command(f"{sys.executable} {MAKE_HTML_WEBPAGE_PATH}", shell=True)
+        webrepldir_handler.popd()
+        if exitcode == 0:
+            return True
+        print(f"Cannot init {MAKE_HTML_WEBPAGE_PATH}: {stderr}")
+        return False
+    print(f"WEBREPL MAKE MISSING: {MAKE_HTML_WEBPAGE_PATH}")
+    return False
+
+def open_webrepl_webpage(address=None, port=8266):
+    # file:///Users/usrname/micrOS/micrOS/toolkit/workspace/webrepl/webrepl.html#10.0.1.76:8266
+    fuid = ''
+    if address is None:
+        try:
+            address, _, fuid, _ = ConnectionData.select_device()
+        except KeyboardInterrupt:
+            address = None
+
+    device = "" if address is None else f"#{address}:{port}"
+    webrepl_html = f"file://{WEBREPL_WEBPAGE_PATH}{device}"
+    is_exists, ftype = FileHandler.path_is_exists(WEBREPL_WEBPAGE_PATH)
+    if is_exists and ftype == "f":
+        print(f"OPEN {fuid} webrepl {webrepl_html}")
+        if sys.platform == "darwin":
+            CommandHandler.run_command(f"open '{webrepl_html}'", shell=True)
+        elif sys.platform == "win32":
+            CommandHandler.run_command(f"start {webrepl_html}", shell=True)
+        elif sys.platform == "linux":
+            CommandHandler.run_command(f"xdg-open {webrepl_html}", shell=True)
+        else:
+            print("Unsupported OS")
+            return False
+        return True
+    print(f"{WEBREPL_WEBPAGE_PATH} not exists.")
+    return False
+
+
+def open_webrepl():
+    state = init_webrepl_frontend()
+    if state:
+        open_webrepl_webpage()
+
+
+
+if __name__ == "__main__":
+    open_webrepl()

toolkit/dashboard_apps/BackupRestore.py

@@ -5,27 +5,17 @@ import sys
 import json
 MYPATH = os.path.dirname(os.path.abspath(__file__))
 BACKUP_DIR = os.path.join(MYPATH, "../user_data/node_config_archive/")
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 sys.path.append(os.path.join(MYPATH, '../lib/'))
 from TerminalColors import Colors
 
-# FILL OUT
-DEVICE = 'node01'
-PASSWD = None
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
-def base_cmd():
-    if PASSWD is None:
-        return ['--dev', DEVICE]
-    return ['--dev', DEVICE, '--password', PASSWD]
+CLIENT = None
 
 
-def run_command(cmd):
-    # EDIT YOUR COMMAND
-    args = base_cmd() + cmd
-    status, answer = socketClient.run(args)
-    return status, answer
-
 ###########################################################
 def _value_type(value):
     value = value.strip()
@@ -42,15 +32,16 @@ def _value_type(value):
 
 
 def backup():
-    print(f"\tBackup name format: {DEVICE}-<tag>-node_config.json")
-    print(f"\t\t tag is optional (press simply enter): {DEVICE}-node_config.json")
-    backup_tag = input(f"\tFill backup tag for {DEVICE}: ").strip()
+    device = CLIENT.get_device()
+    print(f"\tBackup name format: {device}-<tag>-node_config.json")
+    print(f"\t\t tag is optional (press simply enter): {device}-node_config.json")
+    backup_tag = input(f"\tFill backup tag for {device}: ").strip()
     backup_tag = "" if len(backup_tag) == 0 else f"-{backup_tag}"
-    backup_name = f"{DEVICE}{backup_tag}-node_config.json"
+    backup_name = f"{device}{backup_tag}-node_config.json"
     backup_path = os.path.join(BACKUP_DIR, backup_name)
     print(f"\tBackup path: {backup_path}")
 
-    status, answer = run_command(["conf", "dump"])
+    status, answer = CLIENT.run(["conf", "dump"])
     if status:
         configuration = {line.split(":")[0].strip(): _value_type(':'.join(line.split(":")[1:])) for line in answer.strip().split("\n") if ":" in line}
         with open(backup_path, 'w') as f:
@@ -61,7 +52,8 @@ def backup():
 
 
 def restore():
-    print(f"\tRestore backup for: {DEVICE}")
+    device = CLIENT.get_device()
+    print(f"\tRestore backup for: {device}")
     diff_config = {}
 
     # SELECT AND LOAD CONFIG BACKUP
@@ -81,7 +73,7 @@ def restore():
     print(f"BACKUP CONFIG DICT:\n{backup_dict}")
 
     # LOAD LIVE DEVICE CONFIG - create config diff
-    status, answer = run_command(["conf", "dump"])
+    status, answer = CLIENT.run(["conf", "dump"])
     if not status:
         return f"Cannot load live device config"
     live_configuration = {line.split(":")[0].strip(): _value_type(':'.join(line.split(":")[1:])) for line in answer.strip().split("\n") if ":" in line}
@@ -103,20 +95,16 @@ def restore():
         print(f"{Colors.WARN}SKIP restore...{Colors.NC}")
         return
 
-    print(f"PACKAGE CONFIG DIFFS...{DEVICE}")
+    print(f"PACKAGE CONFIG DIFFS...{device}")
     conf_cmd_list = ["conf"]
     for key, value in diff_config.items():
         print(f"\tADD {key} : {value}")
         conf_cmd_list.append(f"{key} {value}")
     conf_cmd_list.append("reboot")
 
-    verify = input(f"{Colors.WARN}This is BETA feature, are you sure?{Colors.NC} [YY/n]: ")
-    if verify != "YY":
-        print(f"{Colors.WARN}SKIP restore...{Colors.NC}")
-        return
     # Restore
-    print(f"APPLY CONFIG DIFFS...{DEVICE}")
-    status, answer = run_command(conf_cmd_list)
+    print(f"APPLY CONFIG DIFFS...{device}")
+    status, answer = CLIENT.run(conf_cmd_list)
     if status:
         print(f"{Colors.OKGREEN}Backup was successfully restored:{Colors.NC} {backup_path}\nRebooting...")
     else:
@@ -148,15 +136,12 @@ def app(devfid=None, pwd=None):
         send command(s) over socket connection [socketClient.run(args)]
         list load module commands and send in single connection
     """
-    global DEVICE, PASSWD
-    if devfid is not None:
-        DEVICE = devfid
-    if pwd is not None:
-        PASSWD = pwd
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
     print(f"{Colors.WARN}Backup & Restore management{Colors.NC}\n")
     while True:
-        print(f"{Colors.UNDERLINE}Operations on {DEVICE}{Colors.NC}")
+        print(f"{Colors.UNDERLINE}Operations on {CLIENT.get_device()}{Colors.NC}")
         print("\t[1]  Backup")
         print("\t[2]  Restore")
         print("\t[3]  Delete backups")

toolkit/dashboard_apps/CCTDemo.py

@@ -2,38 +2,33 @@
 
 import os
 import sys
-import time
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 sys.path.append(os.path.join(MYPATH, '../lib/'))
-from TerminalColors import Colors
 
-# FILL OUT
-DEVICE = 'node01'
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
+CLIENT = None
 
-def base_cmd():
-    return ['--dev', DEVICE]
 
-
-def app(devfid=None):
+def app(devfid=None, pwd=None):
     """
     devfid: selected device input
         send command(s) over socket connection [socketClient.run(args)]
         list load module commands and send in single connection
     """
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
-    status, answer = socketClient.run(base_cmd() + ['cct white 50 400',
+    status, answer = CLIENT.run(['cct white 50 400',
                                                     'cct brightness 50'])
-    status, answer = socketClient.run(base_cmd() + ['cct brightness 100', 'cct brightness 20',
+    status, answer = CLIENT.run(['cct brightness 100', 'cct brightness 20',
                                                     'cct brightness 60'])
-    status, answer = socketClient.run(base_cmd() + ['cct white 400 50',
+    status, answer = CLIENT.run(['cct white 400 50',
                                                     'cct brightness 100', 'cct brightness 20'])
-    status, answer = socketClient.run(base_cmd() + ['cct white 600 700',
+    status, answer = CLIENT.run(['cct white 600 700',
                                                     'cct white 50 300'])
 
 

toolkit/dashboard_apps/CCTTest.py

@@ -5,18 +5,15 @@ import sys
 import time
 import random
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
-import time
 sys.path.append(os.path.join(MYPATH, '../lib/'))
 from TerminalColors import Colors
 
-# FILL OUT
-DEVICE = 'node01'
-
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
-def base_cmd():
-    return ['--dev', DEVICE]
+CLIENT = None
 
 
 def test_random_colors(test_len=8, smooth=False):
@@ -30,12 +27,12 @@ def test_random_colors(test_len=8, smooth=False):
 
     # Generate command
     cmd_list_str = " <a> ".join(["{} {} {} {} >json".format(main_function, k[0], k[1], smooth) for k in cct_list])
-    args = base_cmd() + [cmd_list_str]
+    args = [cmd_list_str]
     print("{} Generated command {} - multi message single connection single connection: {} cold warm {}\n{}".format(Colors.HEADER, Colors.NC, main_function, smooth, args))
 
     start_t = time.time()
     # SEND MESSSAGE OVER micrOS client
-    status, answer = socketClient.run(args)
+    status, answer = CLIENT.run(args)
     delta_t = round((time.time() - start_t)/test_len, 1)
 
     #Evaluate last message
@@ -51,14 +48,14 @@ def test_random_colors(test_len=8, smooth=False):
 
 def test_toogle():
     main_function = 'cct toggle'
-    args_on = base_cmd() + [f'{main_function} True >json']
-    args_toggle = base_cmd() + [f'{main_function} >json']
+    args_on = [f'{main_function} True >json']
+    args_toggle = [f'{main_function} >json']
 
     # SEND MESSSAGE OVER micrOS client
-    status, answer = socketClient.run(args_on)
+    status, answer = CLIENT.run(args_on)
     if status and '"S": 1' in answer:
         # SEND MESSSAGE OVER micrOS client
-        status, answer = socketClient.run(args_toggle)
+        status, answer = CLIENT.run(args_toggle)
         if status and '"S": 0' in answer:
             return True, '{} works {}OK{}'.format(main_function, Colors.OK, Colors.NC)
     return False, '{} not works {}NOK{}: {}'.format(main_function, Colors.ERR, Colors.NC, answer)
@@ -66,24 +63,23 @@ def test_toogle():
 
 def test_brightness():
     main_function = 'cct brightness'
-    args_10 = base_cmd() + [f'{main_function} 10 >json']
-    args_50 = base_cmd() + [f'{main_function} 50 >json']
-    args_actual_br = base_cmd() + [f'{main_function} >json']
+    args_10 = [f'{main_function} 10 >json']
+    args_50 = [f'{main_function} 50 >json']
+    args_actual_br = [f'{main_function} >json']
 
-    status, answer = socketClient.run(args_10)
+    status, answer = CLIENT.run(args_10)
     if status:
-        status, answer = socketClient.run(args_50)
+        status, answer = CLIENT.run(args_50)
         if status:
-            status, answer = socketClient.run(args_actual_br)
+            status, answer = CLIENT.run(args_actual_br)
             if status and "50.0 %" in answer:
                 return True, "{} function {}OK{} (50.0 % == {})".format(main_function, Colors.OK, Colors.NC, answer)
     return False, "{} function {}NOK{} (50.0 % == {})".format(main_function, Colors.ERR, Colors.NC, answer)
 
 
-def app(devfid=None):
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
+def app(devfid=None, pwd=None):
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
     test_pool = { 'Color change test': test_random_colors(test_len=8, smooth=False),
                   'Color smooth test': test_random_colors(test_len=4, smooth=True),

toolkit/dashboard_apps/CamStream.py

@@ -2,14 +2,10 @@ import sys, os
 import subprocess
 MYPATH = os.path.dirname(os.path.abspath(__file__))
 
-DEVICE = "node01"
 
-def app(devfid=None):
+def app(devfid=None, pwd=None):
     """
     Wrapper function to start subprocess plotting... (threading limitation)
     """
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
-    result = subprocess.run([f'{sys.executable}', os.path.join(MYPATH, '_capture.py'), DEVICE])
+    result = subprocess.run([f'{sys.executable}', os.path.join(MYPATH, '_capture.py'), devfid])
     print(result)

toolkit/dashboard_apps/CatGame.py

@@ -1,28 +1,26 @@
 #!/usr/bin/env python3
 
 import os
-import sys
 import atexit
 from random import randint
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 
-DEVICE = 'ImpiGamePro'
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
+
+CLIENT = None
 CMD_PIPE_SEP = '<a>'
 SERVO_CENTER_VAL = 77
 
 
-def base_cmd():
-    return ['--dev', DEVICE]
-
-
 def play_game(iteration=30, devfid=None):
     global CMD_PIPE_SEP
     for _ in range(iteration):
         piped_commands = []
 
-        args = base_cmd() + ['servo sduty {} '.format(SERVO_CENTER_VAL)]
+        args = ['servo sduty {} '.format(SERVO_CENTER_VAL)]
         print("CMD: {}".format(args))
         args.append(CMD_PIPE_SEP)
         piped_commands += args
@@ -39,19 +37,19 @@ def play_game(iteration=30, devfid=None):
         piped_commands += args
 
         print("CMD PIPE: {}".format(piped_commands))
-        socketClient.run(piped_commands)
+        CLIENT.run(piped_commands)
 
 
 def deinit_servo():
     print("DEINIT SERVO, SET TO {} and DEINIT".format(SERVO_CENTER_VAL))
-    args = base_cmd() + ['servo sduty {}'.format(SERVO_CENTER_VAL)]
-    socketClient.run(args)
+    args = ['servo sduty {}'.format(SERVO_CENTER_VAL)]
+    CLIENT.run(args)
+
 
+def app(devfid=None, pwd=None):
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
-def app(devfid=None):
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
     atexit.register(deinit_servo)
     play_game()
     deinit_servo()

toolkit/dashboard_apps/Dimmer.py

@@ -1,43 +1,33 @@
 #!/usr/bin/env python3
 
 import os
-import sys
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
-# FILL OUT
-DEVICE = 'CamLed'
+CLIENT = None
 
 
-def base_cmd():
-    return ['--dev', DEVICE]
+def app(devfid=None, pwd=None, itr=80):
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
 
-
-def app(devfid=None, itr=80):
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
     # EDIT YOUR COMMAND
     cmd_list = []
     for k in range(0, itr, 2):
         cmd_list += ['dimmer set_value {} smooth=False >json'.format(k)]
-    execute(cmd_list)
+    CLIENT.run(cmd_list)
 
     cmd_list = []
     for k in range(itr, 0, -2):
         cmd_list += ['dimmer set_value {} smooth=False >json'.format(k)]
-    execute(cmd_list)
+    CLIENT.run(cmd_list)
 
     cmd_list = ['dimmer set_value 300', 'dimmer toggle False', 'dimmer toggle True']
-    execute(cmd_list)
-
-
-def execute(cmd_list):
-    cmd_args = base_cmd() + cmd_list
-    print("DIMMER TEST: {}".format(cmd_args))
-    socketClient.run(cmd_args)
+    CLIENT.run(cmd_list)
 
 
 if __name__ == "__main__":

toolkit/dashboard_apps/GetVersion.py

@@ -4,31 +4,23 @@ import os
 import sys
 import time
 MYPATH = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(MYPATH))
-import socketClient
 
-# FILL OUT
-DEVICE = 'node01'
-PASSWD = None
-
-
-def base_cmd():
-    if PASSWD is None:
-        return ['--dev', DEVICE]
-    return ['--dev', DEVICE, '--password', PASSWD]
+try:
+    from ._app_base import AppBase
+except:
+    from _app_base import AppBase
 
+CLIENT = None
 
 
 def app(devfid=None, pwd=None):
-    global DEVICE, PASSWD
-    if devfid is not None:
-        DEVICE = devfid
-    if pwd is not None:
-        PASSWD = pwd
+    global CLIENT
+    CLIENT = AppBase(device=devfid, password=pwd)
+
     # EDIT YOUR COMMAND
-    args = base_cmd() + ['version']
-    status, answer = socketClient.run(args)
-    print("[micrOS] {}: {}".format(DEVICE, answer).upper())
+    args = ['version']
+    status, answer = CLIENT.run(args)
+    print("[micrOS] {}: {}".format(CLIENT.get_device(), answer).upper())
 
 
 if __name__ == "__main__":

toolkit/dashboard_apps/MicrophoneTest.py

@@ -2,15 +2,10 @@ import sys, os
 import subprocess
 MYPATH = os.path.dirname(os.path.abspath(__file__))
 
-DEVICE = "node01"
-
 
 def app(devfid=None, pwd=None):
     """
     Wrapper function to start subprocess plotting... (threading limitation)
     """
-    global DEVICE
-    if devfid is not None:
-        DEVICE = devfid
-    result = subprocess.run([f'{sys.executable}', os.path.join(MYPATH, '_micPlotting.py'), DEVICE])
+    result = subprocess.run([f'{sys.executable}', os.path.join(MYPATH, '_micPlotting.py'), devfid])
     print(result)