Merge pull request #2 from MerzSebastian/feature/analogNode

Feature/analog node

Author: MerzSebastian

README.md

@@ -12,6 +12,9 @@ A visual programming interface for Arduino controllers built with React and Reac
 
 Weekend project with occasional updates. This is my first React project, so best practices may not always be followed.
 
+things to keep in mind:
+- only connect 1 line to a input of a block. if you want to connect more use a or element beforehand. I dont got any automation in there to do that automatically. will come
+
 ## Features
 
 - Drag-and-drop block interface for Arduino programming

arduino/arduino.ino

@@ -16,6 +16,7 @@
 #define OP_LATCH 16
 #define OP_PULSE 17
 #define OP_TOGGLE 18
+#define OP_ANALOG_RANGE 19
 
 const int MAX_INSTRUCTIONS = 300;
 const int MAX_VARIABLES = 60;
@@ -49,36 +50,24 @@ int lastButtonState[MAX_VARIABLES] = {LOW};  // Store the last stable button sta
 // WebSerial message structure
 #define START_BYTE 0x7E
 
-// #define WOKWI // uncomment when using wokwi
+// For Wokwi simulation, do not change the next line, it will get replaced with regex
+// #define WOKWI
 
 void setup() {
   Serial.begin(9600);
 
   // Check if we should load from WebSerial or use fixed bytecode
 #ifdef WOKWI
-  // For Wokwi simulation, use fixed bytecode
+  // For Wokwi simulation, do not change the next line, it will get replaced with regex
   byte myBytecode[] = {1, 3, 1, 4, 1, 2, 2, 5, 1, 6, 3, 3, 0, 3, 4, 1, 3, 2, 2, 3, 6, 3, 17, 4, 100, 0, 232, 3, 18, 2, 5, 0, 16, 1, 3, 6, 0, 11, 4, 0, 6, 4, 5, 7, 4, 5, 7};
 
   instructionLength = sizeof(myBytecode) / sizeof(myBytecode[0]);
   for (int i = 0; i < instructionLength; i++) {
     instructions[i] = myBytecode[i];
   }
-
-  Serial.print("Loaded ");
-  Serial.print(instructionLength);
-  Serial.println(" instructions for Wokwi simulation");
 #else
   // For real Arduino, try to load from EEPROM first
   loadFromEEPROM();
-  
-  // If no valid program in EEPROM, wait for WebSerial transmission
-  if (instructionLength == 0) {
-    Serial.println("READY");
-  } else {
-    Serial.print("Loaded ");
-    Serial.print(instructionLength);
-    Serial.println(" instructions from EEPROM");
-  }
 #endif
 }
 
@@ -398,6 +387,19 @@ void executeInstructions() {
         variables[outputVar] = toggleState[outputVar];
         break;
       }
+      case OP_ANALOG_RANGE: {
+        byte inputVar = instructions[pc++];
+        unsigned int min = instructions[pc++];
+        min |= (instructions[pc++] << 8);
+        unsigned int max = instructions[pc++];
+        max |= (instructions[pc++] << 8);
+        byte outputVar = instructions[pc++];
+        
+        int value = variables[inputVar];
+        variables[outputVar] = (value >= min && value <= max) ? 1 : 0;
+        break;
+      }
+    
     }
   }
 }

logic-editor/src/App.tsx

@@ -50,6 +50,7 @@ const blockTypes = [
   { type: 'latchNode', label: 'LATCH', color: 'bg-orange-500' },
   { type: 'pulseNode', label: 'PULSE (beta)', color: 'bg-cyan-500' },
   { type: 'toggleNode', label: 'TOGGLE', color: 'bg-pink-500' },
+  { type: 'analogRangeNode', label: 'ANALOG RANGE', color: 'bg-teal-500' },
 ];
 
 // === Node Definitions ===
@@ -77,6 +78,36 @@ function LatchNode({ data, id }: any) {
   );
 }
 
+function AnalogRangeNode({ data, id }: any) {
+  return (
+    <div className={`${nodeBaseClasses} w-40 bg-teal-500 border-2 border-teal-700`}>
+      <div className={titleClasses}>ANALOG RANGE</div>
+      <Handle type="target" position={Position.Left} id="in" className={handleClasses} />
+      <div className="flex space-x-1 mt-1">
+        <input
+          type="number"
+          min="0"
+          max="1023"
+          value={data.min || 0}
+          onChange={(e) => data.onChangeMin(id, parseInt(e.target.value))}
+          className={`${inputClasses} w-16`}
+          placeholder="Min"
+        />
+        <input
+          type="number"
+          min="0"
+          max="1023"
+          value={data.max || 1023}
+          onChange={(e) => data.onChangeMax(id, parseInt(e.target.value))}
+          className={`${inputClasses} w-16`}
+          placeholder="Max"
+        />
+      </div>
+      <Handle type="source" position={Position.Right} id="out" className={handleClasses} />
+    </div>
+  );
+}
+
 function ToggleNode({ data, id }: any) {
   return (
     <div className={`${nodeBaseClasses} w-30 h-15 bg-pink-500 border-2 border-pink-800`}>
@@ -315,8 +346,25 @@ export default function App() {
     latchNode: LatchNode,
     pulseNode: PulseNode,
     toggleNode: ToggleNode,
+    analogRangeNode: AnalogRangeNode,
   }), []);
 
+  const handleMinChange = useCallback((nodeId: string, min: number) => {
+    setNodes((nds) =>
+      nds.map((n) =>
+        n.id === nodeId ? { ...n, data: { ...n.data, min } } : n
+      )
+    );
+  }, [setNodes]);
+
+  const handleMaxChange = useCallback((nodeId: string, max: number) => {
+    setNodes((nds) =>
+      nds.map((n) =>
+        n.id === nodeId ? { ...n, data: { ...n.data, max } } : n
+      )
+    );
+  }, [setNodes]);
+
   const handleInitialStateChange = useCallback((nodeId: string, initialState: number) => {
     setNodes((nds) =>
       nds.map((n) =>
@@ -687,6 +735,8 @@ export default function App() {
               onChangeInitialState: n.type === 'latchNode' || n.type === 'toggleNode' ? handleInitialStateChange : undefined,
               onChangePulseLength: n.type === 'pulseNode' ? handlePulseLengthChange : undefined,
               onChangeInterval: n.type === 'pulseNode' ? handleIntervalChange : undefined,
+              onChangeMin: n.type === 'analogRangeNode' ? handleMinChange : undefined,
+              onChangeMax: n.type === 'analogRangeNode' ? handleMaxChange : undefined,
             }
           }))}
           edges={edges}

logic-editor/src/bytecode-gen.ts

@@ -1,4 +1,4 @@
-// Enhanced bytecode-gen.ts with Latch and Timer support
+// Enhanced bytecode-gen.ts with Analog Range support
 export const OP_SET_PIN_MODE_INPUT = 1;
 export const OP_SET_PIN_MODE_OUTPUT = 2;
 export const OP_READ_PIN = 3;
@@ -14,6 +14,7 @@ export const OP_XOR = 15;
 export const OP_LATCH = 16;
 export const OP_PULSE = 17;
 export const OP_TOGGLE = 18;
+export const OP_ANALOG_RANGE = 19;
 export const OP_DELAY = 30;
 
 // Types for the logic configuration
@@ -26,6 +27,8 @@ interface NodeData {
   label: string;
   inputs?: number;
   pin?: string;
+  min?: number;
+  max?: number;
   initialState?: number;
   pulseLength?: number;
   interval?: number;
@@ -62,7 +65,7 @@ export function generateBytecode(config: LogicConfig): number[] {
   const { nodes, edges } = config;
   const instructions: number[] = [];
 
-  // Build graph and in-degree map
+  // Build graph
   const graph: Record<string, string[]> = {};
   const inDegree: Record<string, number> = {};
   const nodeDict: Record<string, Node> = {};
@@ -81,6 +84,30 @@ export function generateBytecode(config: LogicConfig): number[] {
     inDegree[target] += 1;
   }
 
+  // Simple check: if an input node is connected to an analog node
+  const inputUsesAnalog: Record<string, boolean> = {};
+  
+  for (const node of nodes) {
+    if (node.type === 'inputNode') {
+      // Check if this input is connected to any analog node
+      const checkConnectedToAnalog = (nodeId: string, visited: Set<string> = new Set()): boolean => {
+        if (visited.has(nodeId)) return false;
+        visited.add(nodeId);
+        
+        const currentNode = nodeDict[nodeId];
+        if (currentNode.type === 'analogRangeNode') return true;
+        
+        for (const neighbor of graph[nodeId]) {
+          if (checkConnectedToAnalog(neighbor, visited)) return true;
+        }
+        
+        return false;
+      };
+      
+      inputUsesAnalog[node.id] = checkConnectedToAnalog(node.id);
+    }
+  }
+
   // Topological sort
   const queue: string[] = [];
   for (const [nodeId, deg] of Object.entries(inDegree)) {
@@ -132,7 +159,13 @@ export function generateBytecode(config: LogicConfig): number[] {
     if (node.type === 'inputNode' && node.data.pin) {
       const pin = parseInt(node.data.pin, 10);
       const varIndex = varIndexMap[nodeId];
-      instructions.push(OP_READ_PIN);
+      
+      // Use analog read if connected to an analog node
+      if (inputUsesAnalog[nodeId]) {
+        instructions.push(OP_READ_ANALOG_PIN);
+      } else {
+        instructions.push(OP_READ_PIN);
+      }
       instructions.push(pin);
       instructions.push(varIndex);
     } else if (node.type === 'outputNode' && node.data.pin) {
@@ -154,6 +187,30 @@ export function generateBytecode(config: LogicConfig): number[] {
       instructions.push(OP_WRITE_PIN);
       instructions.push(pin);
       instructions.push(sourceVar);
+    } else if (node.type === 'analogRangeNode') {
+      // Handle analog range node
+      const inputVars: number[] = [];
+      for (const edge of edges) {
+        if (edge.target === nodeId) {
+          const sourceNodeId = edge.source;
+          if (varIndexMap[sourceNodeId] !== undefined) {
+            inputVars.push(varIndexMap[sourceNodeId]);
+          }
+        }
+      }
+
+      if (inputVars.length >= 1 && varIndexMap[nodeId] !== undefined) {
+        const min = node.data.min || 0;
+        const max = node.data.max || 1023;
+        
+        instructions.push(OP_ANALOG_RANGE);
+        instructions.push(inputVars[0]); // Input variable
+        instructions.push(min & 0xFF);   // Min value low byte
+        instructions.push((min >> 8) & 0xFF); // Min value high byte
+        instructions.push(max & 0xFF);   // Max value low byte
+        instructions.push((max >> 8) & 0xFF); // Max value high byte
+        instructions.push(varIndexMap[nodeId]); // Output variable
+      }
     } else {
       // Logic gate node
       const gateType = node.type;