install arduino-cli and arduino USB connection

- automatic installation of arduino cli on startup
- Added a node to initialize communication between Arduino and ComfyUI with board list and port

Author: Juste-Leo2

README.md

@@ -6,7 +6,7 @@
 
 Here are the initial goals for the project:
 
-- [ ] **Self-contained Installer Node:** Automatically downloads and manages `arduino-cli` locally. No manual setup required from the user, ensuring a smooth "all-in-one" experience.
+- [x] **Self-contained Installer Node:** Automatically downloads and manages `arduino-cli` locally. No manual setup required from the user, ensuring a smooth "all-in-one" experience.
 - [ ] **Dynamic Upload Node:** Visually build logic with nodes, which will then generate, compile, and upload a custom sketch to your connected Arduino board.
 - [ ] **Real-time Communication:** Implement a standard sketch and corresponding nodes to send live data (e.g., servo angles, LED colors) from ComfyUI to a running Arduino without re-uploading.
 - [ ] **Example Workflows:** Provide simple, functional examples to help users get started quickly.

__init__.py

@@ -0,0 +1,15 @@
+# __init__.py
+
+from .nodes import ArduinoTargetNode # <-- NOM MIS À JOUR
+
+# --- Mappings for ComfyUI ---
+
+NODE_CLASS_MAPPINGS = {
+    "ArduinoTarget": ArduinoTargetNode, # <-- NOM MIS À JOUR
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ArduinoTarget": "Define Arduino Target", # <-- NOM MIS À JOUR
+}
+
+print("...Custom Nodes: ComfyUI-Arduino loaded.")

nodes.py

@@ -0,0 +1,64 @@
+# nodes.py
+
+import os
+from .src.arduino_installer import setup_arduino_cli
+from .src.arduino_board_finder import get_available_boards, get_fqbn_by_name
+import serial.tools.list_ports
+
+def list_physical_ports():
+    ports = serial.tools.list_ports.comports()
+    return [f"{p.device} - {p.description}" for p in ports] if ports else ["No COM ports found"]
+
+# --------------------------------------------------------------------
+# -- GLOBAL INITIALIZATION (RUNS ONCE AT STARTUP) --------------------
+# --------------------------------------------------------------------
+NODE_DIR = os.path.dirname(os.path.abspath(__file__))
+print("--- Initializing ComfyUI-Arduino: Setting up arduino-cli ---")
+
+# The setup function now returns all the paths we need or an error
+ARDUINO_CLI_PATH, ARDUINO_CONFIG_PATH, SETUP_ERROR = setup_arduino_cli(NODE_DIR)
+
+AVAILABLE_BOARDS = ["Error: CLI setup failed"]
+AVAILABLE_PORTS = ["Error: pyserial missing or failed"]
+
+if SETUP_ERROR is None:
+    print("--- Fetching board lists and COM ports ---")
+    AVAILABLE_BOARDS = get_available_boards(ARDUINO_CLI_PATH, ARDUINO_CONFIG_PATH)
+    AVAILABLE_PORTS = list_physical_ports()
+    print(f"   Found {len(AVAILABLE_BOARDS)} board types and {len(AVAILABLE_PORTS)} COM ports.")
+    print("--- ComfyUI-Arduino initialized successfully. ---")
+else:
+    print(f"FATAL: ComfyUI-Arduino setup failed: {SETUP_ERROR}")
+
+# --------------------------------------------------------------------
+# -- NODE: DEFINE ARDUINO TARGET -------------------------------------
+# --------------------------------------------------------------------
+class ArduinoTargetNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "board_name": (AVAILABLE_BOARDS, ),
+                "port_str": (AVAILABLE_PORTS, ),
+            }
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING")
+    RETURN_NAMES = ("port", "fqbn", "status")
+    FUNCTION = "define_target"
+    CATEGORY = "Arduino"
+
+    def define_target(self, board_name, port_str):
+        if SETUP_ERROR is not None:
+            return ("ERROR", "ERROR", f"Setup failed: {SETUP_ERROR}")
+        
+        port = port_str.split(' ')[0]
+        print(f"--- Defining target: Board '{board_name}' on port '{port}' ---")
+        
+        fqbn, error = get_fqbn_by_name(ARDUINO_CLI_PATH, ARDUINO_CONFIG_PATH, board_name)
+        
+        if error:
+            return ("ERROR", "ERROR", error)
+        
+        status_message = f"✅ Target defined: {board_name} ({fqbn}) on {port}"
+        return (port, fqbn, status_message)

requirements.txt

@@ -0,0 +1,3 @@
+# requirements.txt
+requests
+pyserial

src/arduino_board_finder.py

@@ -0,0 +1,33 @@
+# src/arduino_board_finder.py
+
+from .cli_utils import run_cli_command
+
+def get_available_boards(cli_path: str, config_path: str) -> list[str]:
+    """
+    Gets a list of all board names known by the installed cores.
+    """
+    success, data = run_cli_command(cli_path, config_path, ["board", "listall", "--format", "json"], expect_json=True)
+    
+    if not success:
+        print(f"❌ Error fetching all available boards: {data}")
+        return ["Error: Could not list boards"]
+
+    if 'boards' in data and data.get('boards'):
+        return sorted(list(set(b['name'] for b in data['boards'])))
+    
+    return ["Error: No boards found by listall command"]
+
+def get_fqbn_by_name(cli_path: str, config_path: str, board_name: str) -> tuple[str | None, str | None]:
+    """
+    Finds the FQBN for a given board name.
+    """
+    success, data = run_cli_command(cli_path, config_path, ["board", "listall", "--format", "json"], expect_json=True)
+
+    if not success or 'boards' not in data:
+        return None, f"Could not retrieve board list to find FQBN for '{board_name}'"
+    
+    for board in data['boards']:
+        if board.get('name') == board_name:
+            return board.get('fqbn'), None
+
+    return None, f"FQBN for '{board_name}' not found."

src/arduino_installer.py

@@ -0,0 +1,98 @@
+# src/arduino_installer.py
+
+import os
+import platform
+import shutil
+import requests
+import zipfile
+import tarfile
+import io
+import textwrap
+from .cli_utils import run_cli_command
+
+# --- Constants ---
+BASE_URL = "https://downloads.arduino.cc/arduino-cli/arduino-cli_latest"
+BIN_DIR_NAME = "bin"
+DATA_DIR_NAME = "arduino_data"
+CONFIG_FILE_NAME = "arduino-cli.yaml"
+CORE_TO_INSTALL = "arduino:avr"
+
+def get_platform_specific_url():
+    system = platform.system()
+    arch = platform.machine()
+    if system == "Windows": return f"{BASE_URL}_Windows_64bit.zip"
+    if system == "Linux":
+        return f"{BASE_URL}_Linux_ARM64.tar.gz" if "aarch64" in arch or "arm64" in arch else f"{BASE_URL}_Linux_64bit.tar.gz"
+    if system == "Darwin": # macOS
+        return f"{BASE_URL}_macOS_ARM64.tar.gz" if "arm64" in arch else f"{BASE_URL}_macOS_64bit.tar.gz"
+    raise NotImplementedError(f"Unsupported OS: {system} {arch}")
+
+def get_cli_executable_path(install_dir: str) -> str:
+    bin_dir = os.path.join(install_dir, BIN_DIR_NAME)
+    executable_name = "arduino-cli.exe" if platform.system() == "Windows" else "arduino-cli"
+    return os.path.join(bin_dir, executable_name)
+
+def setup_arduino_cli(install_dir: str) -> tuple[str | None, str | None, str | None]:
+    cli_path = get_cli_executable_path(install_dir)
+    data_dir = os.path.join(install_dir, DATA_DIR_NAME)
+    config_path = os.path.join(install_dir, CONFIG_FILE_NAME)
+
+    if not os.path.exists(cli_path):
+        print(" arduino-cli not found. Starting download and installation...")
+        bin_dir = os.path.dirname(cli_path)
+        if os.path.exists(bin_dir): shutil.rmtree(bin_dir)
+        os.makedirs(bin_dir, exist_ok=True)
+        try:
+            url = get_platform_specific_url()
+            print(f"   Downloading from: {url}")
+            response = requests.get(url, stream=True); response.raise_for_status()
+            print("   Extracting archive...")
+            if url.endswith(".zip"):
+                with zipfile.ZipFile(io.BytesIO(response.content)) as z: z.extractall(bin_dir)
+            else:
+                with tarfile.open(fileobj=io.BytesIO(response.content), mode="r:gz") as t: t.extractall(bin_dir)
+            if platform.system() != "Windows": os.chmod(cli_path, 0o755)
+            print(f"✅ arduino-cli installed successfully: {cli_path}")
+        except Exception as e:
+            return None, None, f"Critical error during arduino-cli download/extraction: {e}"
+
+    if not os.path.exists(config_path):
+        print(f"--- First time setup: Manually creating a clean arduino-cli.yaml ---")
+        os.makedirs(data_dir, exist_ok=True)
+        data_dir_fwd = data_dir.replace('\\', '/')
+        config_content = textwrap.dedent(f"""
+            directories:
+              data: {data_dir_fwd}
+              downloads: {data_dir_fwd}/downloads
+              user: {data_dir_fwd}/user
+        """).strip()
+        try:
+            with open(config_path, 'w') as f: f.write(config_content)
+            print(f"   Local config file created at: {config_path}")
+        except Exception as e:
+            return None, None, f"Failed to write config file: {e}"
+            
+    print("--- Verifying arduino-cli core installation ---")
+    success, data = run_cli_command(cli_path, config_path, ["core", "list", "--format", "json"], expect_json=True)
+    if not success: return None, None, f"Error checking installed cores: {data}"
+    
+    # *** THE ONE AND ONLY FIX IS HERE ***
+    # The key is 'platforms', not 'result'.
+    core_list = data.get('platforms', []) if isinstance(data, dict) else []
+
+    core_is_installed = any(CORE_TO_INSTALL in core.get('id', '') for core in core_list if isinstance(core, dict))
+
+    if core_is_installed:
+        print(f"✅ Core '{CORE_TO_INSTALL}' is already installed.")
+    else:
+        print(f"   Core '{CORE_TO_INSTALL}' not found. Installing...")
+        print("   Updating core index... (This may take a moment)")
+        success, res = run_cli_command(cli_path, config_path, ["core", "update-index"])
+        if not success: return None, None, f"Error updating core index: {res}"
+
+        print(f"   Installing core '{CORE_TO_INSTALL}'...")
+        success, res = run_cli_command(cli_path, config_path, ["core", "install", CORE_TO_INSTALL])
+        if not success: return None, None, f"Error installing core: {res}"
+        print(f"✅ Core '{CORE_TO_INSTALL}' installed successfully.")
+
+    return cli_path, config_path, None

src/cli_utils.py

@@ -0,0 +1,42 @@
+# src/cli_utils.py
+
+import subprocess
+import json
+import os
+
+def run_cli_command(cli_path: str, config_path: str, args: list, expect_json=False):
+    """
+    Runs a command with arduino-cli using a specific config file.
+    """
+    # Prepend the config file argument to every command
+    command = [cli_path, "--config-file", config_path] + args
+    
+    startupinfo = None
+    if os.name == 'nt':
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+
+    try:
+        # We don't print the full command anymore to reduce log spam
+        # print(f"   Running command: {' '.join(command)}")
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+            startupinfo=startupinfo
+        )
+        
+        stdout = process.stdout.strip()
+        
+        if expect_json:
+            return True, json.loads(stdout) if stdout else {}
+        
+        return True, stdout
+
+    except subprocess.CalledProcessError as e:
+        error_message = f"Command failed: {' '.join(args)}\n" \
+                        f"Stderr: {e.stderr.strip()}"
+        return False, error_message
+    except Exception as e:
+        return False, f"An unexpected error occurred running {' '.join(args)}: {e}"