Node Management and Real-Time Communication Enhancements

Addition of functional nodes
- Added analogWrite node
- Added digitalWrite node

Real-time system management via request–acknowledgment communication
- Added a data-sending node
- Added a data-receiving node

Temporary node removal for raw code execution

added two new workflows

Author: Juste-Leo2

README.md

@@ -8,12 +8,16 @@
   <img src="docs/image1.png" alt="workflow screen">
 </p>
 
+<p align="center">
+  <img src="docs/image2.png" alt="workflow screen">
+</p>
+
 
 Here are the initial goals for the project:
 
 - [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.
 - [x] **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.
+- [X] **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.
 - [x] **Example Workflows:** Provide simple, functional examples to help users get started quickly.
 
 ### other features
@@ -22,7 +26,7 @@ Ideas for the long-term development of the project:
 
 - [ ] **Arduino Library Management:** A node to automatically install required libraries for your sketch using `arduino-cli`.
 - [ ] **High-Level Hardware Nodes:** Easy-to-use nodes for common components (servos, sensors, NeoPixel LEDs, etc.) that abstract away the low-level code.
-- [x] **In-Workflow C++ Editor:** A dedicated node to write or paste raw Arduino (C++) code directly within ComfyUI.
+- [ ] **In-Workflow C++ Editor:** A dedicated node to write or paste raw Arduino (C++) code directly within ComfyUI.
 - [ ] **Full Sketch Export:** An option to export the generated C++ code and a list of its dependencies, allowing it to be used outside of ComfyUI.
 
 ### Installation

__init__.py

@@ -1,19 +1,51 @@
 # __init__.py
 
-from .nodes import ArduinoTargetNode, ArduinoCodeNode, ArduinoCompileUploadNode
+from .nodes import (
+    ArduinoTargetNode, 
+    ArduinoCompileUploadNode
+)
+from .arduino_native_nodes import (
+    ArduinoCreateVariableNode, # <-- NOUVEAU pour la flexibilité
+    ArduinoDigitalWriteNode, 
+    ArduinoAnalogWriteNode, 
+    ArduinoDelayNode,
+    ArduinoVariableInfoNode # <-- NOUVEAU pour l'info
+)
+from .arduino_comms_nodes import (
+    ArduinoSenderNode, 
+    ArduinoReceiverNode
+)
 
-# --- Mappings for ComfyUI ---
 
+# --- Mappings for ComfyUI ---
 NODE_CLASS_MAPPINGS = {
+    # Workflow 1: Build
     "ArduinoTarget": ArduinoTargetNode,
-    "ArduinoCode": ArduinoCodeNode,
+    "ArduinoCreateVariable": ArduinoCreateVariableNode,
+    "ArduinoDigitalWrite": ArduinoDigitalWriteNode,
+    "ArduinoAnalogWrite": ArduinoAnalogWriteNode,
+    "ArduinoDelay": ArduinoDelayNode,
+    "ArduinoVariableInfo": ArduinoVariableInfoNode,
     "ArduinoCompileUpload": ArduinoCompileUploadNode,
+    
+    # Workflow 2: Communication
+    "ArduinoSender": ArduinoSenderNode,
+    "ArduinoReceiver": ArduinoReceiverNode,
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
-    "ArduinoTarget": "Define Arduino Target",
-    "ArduinoCode": "Arduino Code",
-    "ArduinoCompileUpload": "Compile & Upload to Arduino",
+    # Workflow 1
+    "ArduinoTarget": "1. Define Arduino Target",
+    "ArduinoCreateVariable": "Native: Create Variable",
+    "ArduinoDigitalWrite": "Native: DigitalWrite",
+    "ArduinoAnalogWrite": "Native: AnalogWrite (PWM)",
+    "ArduinoDelay": "Native: Delay (Non-Blocking)",
+    "ArduinoVariableInfo": "Show Variable Info",
+    "ArduinoCompileUpload": "2. Compile & Upload",
+
+    # Workflow 2
+    "ArduinoSender": "Send to Arduino (by Port)",
+    "ArduinoReceiver": "Receive from Arduino (by Port)",
 }
 
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

arduino_comms_nodes.py

@@ -0,0 +1,87 @@
+# arduino_comms_nodes.py
+
+from .src.serial_communicator import send_and_receive
+from .nodes import ARDUINO_PROFILES
+
+class ArduinoSenderNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "port": ("STRING", {"default": "COM3"}),
+                "variable_name": ("STRING", {"default": "state_pin_13"}),
+                "value": ("STRING", {"default": "HIGH", "multiline": False}),
+            },
+        }
+    RETURN_TYPES = ("STRING",); RETURN_NAMES = ("status",); FUNCTION = "send_data"; CATEGORY = "Arduino/Communication"
+
+    def send_data(self, port, variable_name, value):
+        if port not in ARDUINO_PROFILES:
+            return (f"❌ ERROR: No profile for {port}. Upload code first.",)
+        
+        comm_map = ARDUINO_PROFILES[port].get("comm_map", {})
+        if variable_name not in comm_map:
+            return (f"❌ ERROR: Variable '{variable_name}' not found in profile for {port}.",)
+
+        details = comm_map[variable_name]
+        variable_index = details["index"]
+        
+        try:
+            value_str = str(value).strip().upper()
+            if value_str == "HIGH": int_value = 1
+            elif value_str == "LOW": int_value = 0
+            else: int_value = int(float(value_str))
+        except (ValueError, TypeError):
+            return (f"❌ ERROR: Invalid value '{value}'. Must be an integer, HIGH, or LOW.",)
+
+        command = f"S:{variable_index}:{int_value}\n"
+        success, response = send_and_receive(port, command)
+        
+        if not success: return (f"❌ ERROR: {response}",)
+        
+        expected_ack = f"OK:S:{variable_index}"
+        if response.startswith(expected_ack):
+            return (f"✅ Sent {value} to '{variable_name}'.",)
+        else:
+            return (f"⚠️ UNEXPECTED RESPONSE: {response}",)
+
+class ArduinoReceiverNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "port": ("STRING", {"default": "COM3"}),
+                "variable_name": ("STRING", {"default": "my_variable"}),
+            },
+            "optional": { "trigger": ("*",), }
+        }
+    RETURN_TYPES = ("INT", "STRING",); RETURN_NAMES = ("value", "status",); FUNCTION = "receive_data"; CATEGORY = "Arduino/Communication"
+
+    def receive_data(self, port, variable_name, trigger=None):
+        if port not in ARDUINO_PROFILES:
+            return (-1, f"❌ ERROR: No profile for {port}. Upload code first.",)
+
+        comm_map = ARDUINO_PROFILES[port].get("comm_map", {})
+        if variable_name not in comm_map:
+            return (-1, f"❌ ERROR: Variable '{variable_name}' not found in profile for {port}.",)
+        
+        # THE FIX: This entire 'if' block is removed to allow reading any variable type.
+        # if details['type'] != 'shared':
+        #      return (-1, f"❌ ERROR: Can only receive from general-purpose variables...")
+
+        details = comm_map[variable_name]
+        variable_index = details["index"]
+        command = f"G:{variable_index}\n"
+        success, response = send_and_receive(port, command)
+
+        if not success: return (-1, f"❌ ERROR: {response}",)
+
+        parts = response.split(':')
+        if len(parts) == 3 and parts[0] == 'R' and parts[1] == str(variable_index):
+            try:
+                value = int(parts[2])
+                return (value, f"✅ Received {value} from '{variable_name}'.")
+            except ValueError:
+                return (-1, f"⚠️ INVALID VALUE in response: {response}")
+        else:
+            return (-1, f"⚠️ UNEXPECTED RESPONSE: {response}")

arduino_native_nodes.py

@@ -0,0 +1,86 @@
+# arduino_native_nodes.py
+
+import copy
+from .src.code_generator import create_communication_map
+
+ARDUINO_CODE_BLOCK = "ARDUINO_CODE_BLOCK"
+
+def create_empty_code_block():
+    """Creates the base data structure for our Arduino code."""
+    return {
+        "setup_pins": set(),
+        "setup_code": [],
+        "loop_steps": [], # Kept for potential future use, but ignored by current generator
+        "global_vars": [],
+        "shared_variable_names": [],
+        "pin_states": {},
+    }
+
+def _append_code_to_last_step(steps, code_line):
+    if not steps or not isinstance(steps[-1], list):
+        steps.append([])
+    steps[-1].append(code_line)
+
+class ArduinoCreateVariableNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return { "required": { "variable_name": ("STRING", {"multiline": False, "default": "my_variable"}) }, "optional": { "code_in": (ARDUINO_CODE_BLOCK,), } }
+    RETURN_TYPES = (ARDUINO_CODE_BLOCK,); RETURN_NAMES = ("code_out",); FUNCTION = "create_var"; CATEGORY = "Arduino/Native"
+    def create_var(self, variable_name, code_in=None):
+        if code_in is None: code_in = create_empty_code_block()
+        new_code_block = copy.deepcopy(code_in)
+        if variable_name not in new_code_block["shared_variable_names"]:
+            new_code_block["shared_variable_names"].append(variable_name)
+        return (new_code_block,)
+        
+class ArduinoVariableInfoNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return { "required": { "code_block": (ARDUINO_CODE_BLOCK,), } }
+    RETURN_TYPES = ("STRING",); RETURN_NAMES = ("info",); FUNCTION = "get_info"; CATEGORY = "Arduino/Build"
+    def get_info(self, code_block):
+        comm_map = create_communication_map(code_block)
+        info = "--- Controllable Variables ---\n"
+        if not comm_map:
+            info += "None detected. Use DigitalWrite or Create Variable nodes."
+        else:
+            for name, details in comm_map.items():
+                info += f"- {name} (type: {details['type']})\n"
+        return (info,)
+
+class ArduinoDigitalWriteNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return { "required": { "pin": ("INT", {"default": 13, "min": 0}), "value": (["HIGH", "LOW"],), }, "optional": { "code_in": (ARDUINO_CODE_BLOCK,), } }
+    RETURN_TYPES = (ARDUINO_CODE_BLOCK,); RETURN_NAMES = ("code_out",); FUNCTION = "generate_code"; CATEGORY = "Arduino/Native"
+    def generate_code(self, pin, value, code_in=None):
+        if code_in is None: code_in = create_empty_code_block()
+        new_code_block = copy.deepcopy(code_in)
+        new_code_block["setup_pins"].add(pin) 
+        # RENAMING: Use state_pin_X as the variable name
+        new_code_block["pin_states"][f"state_pin_{pin}"] = {"type": "digital", "value": value}
+        # The node no longer adds code to the loop, it just defines the initial state.
+        return (new_code_block,)
+
+class ArduinoAnalogWriteNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return { "required": { "pin": ("INT", {"default": 9, "min": 0}), "value": ("INT", {"default": 128, "min": 0, "max": 255}), }, "optional": { "code_in": (ARDUINO_CODE_BLOCK,), } }
+    RETURN_TYPES = (ARDUINO_CODE_BLOCK,); RETURN_NAMES = ("code_out",); FUNCTION = "generate_code"; CATEGORY = "Arduino/Native"
+    def generate_code(self, pin, value, code_in=None):
+        if code_in is None: code_in = create_empty_code_block()
+        new_code_block = copy.deepcopy(code_in)
+        new_code_block["setup_pins"].add(pin)
+        # RENAMING: Use state_pin_X as the variable name
+        new_code_block["pin_states"][f"state_pin_{pin}"] = {"type": "analog", "value": value}
+        return (new_code_block,)
+
+class ArduinoDelayNode:
+    @classmethod
+    def INPUT_TYPES(s):
+        return { "required": { "delay_ms": ("INT", {"default": 1000, "min": 0}), }, "optional": { "code_in": (ARDUINO_CODE_BLOCK,), } }
+    RETURN_TYPES = (ARDUINO_CODE_BLOCK,); RETURN_NAMES = ("code_out",); FUNCTION = "generate_delay"; CATEGORY = "Arduino/Native"
+    def generate_delay(self, delay_ms, code_in=None):
+        # This node is now informational and doesn't affect the generated loop code.
+        if code_in is None: code_in = create_empty_code_block()
+        return (copy.deepcopy(code_in),)