Generate script

.gitignore

@@ -1,4 +1,11 @@
 __pycache__/
 .mypy_cache/
 build/
-dist/
+dist/
+*.DS_Store
+*.tmp
+*.temp
+*.docx~
+~*.docx
+*.docx.tmp
+*.docx.temp

.vscode/launch.json

@@ -2,7 +2,7 @@
     "configurations": [
         {
             "name": "ArduinoLogique",
-            "type": "debugpy",
+            "type": "python",
             "request": "launch",
             "program": "${workspaceFolder}/arduino_logique.py",
             "console": "integratedTerminal"

Components/Chips/Logical/74HC238_DEMUX_3_8.json

@@ -7,7 +7,7 @@
     "functions": [
         {
             "func_type": "DEMUX",
-            "address_pins": [1, 2, 3],
+            "input_pins": [1, 2, 3],
             "output_pins": [15, 14, 13, 12, 11, 10, 9, 7],
             "enable_pins": [6],
             "inv_enable_pins": [4, 5]

Components/Chips/Sequential/74HC109_JK.json

@@ -17,8 +17,8 @@
             "inv_j_input_pin": null,
             "k_input_pin": null,
             "inv_k_input_pin": 3,
-            "output_pin": 6,
-            "inv_output_pin": 7
+            "output_pins": 6,
+            "inv_output_pins": 7
         },
         {
             "func_type": "JK_FLIP_FLOP",
@@ -32,8 +32,8 @@
             "inv_j_input_pin": null,
             "k_input_pin": null,
             "inv_k_input_pin": 13,
-            "output_pin": 10,
-            "inv_output_pin": 9
+            "output_pins": 10,
+            "inv_output_pins": 9
         }
     ],
     "datasheet": "https://www.alldatasheet.com/datasheet-pdf/view/15527/PHILIPS/74HC109.html"

Components/Chips/Sequential/74HC112_JK.json

@@ -17,8 +17,8 @@
             "inv_j_input_pin": null,
             "k_input_pin": 2,
             "inv_k_input_pin": null,
-            "output_pin": 5,
-            "inv_output_pin": 6
+            "output_pins": 5,
+            "inv_output_pins": 6
         },
         {
             "func_type": "JK_FLIP_FLOP",
@@ -32,8 +32,8 @@
             "inv_j_input_pin": null,
             "k_input_pin": 12,
             "inv_k_input_pin": null,
-            "output_pin": 9,
-            "inv_output_pin": 7
+            "output_pins": 9,
+            "inv_output_pins": 7
         }
     ],
     "datasheet": "https://www.alldatasheet.com/datasheet-pdf/view/15529/PHILIPS/74HC112.html"

Components/Chips/Sequential/74HC163.json

@@ -0,0 +1,27 @@
+{
+    "name": "74HC163",
+    "description": "Presettable synchronous 4-bit binary counter; synchronous reset",
+    "package": "DIP16",
+    "vcc_pin": 16,
+    "gnd_pin": 8,
+    "functions": [
+        {
+            "func_type": "BINARY_COUNTER",
+            "clock_pin": 2, 
+            "clock_type": "RISING_EDGE",
+            "reset_pin": null,
+            "inv_reset_pin": 1,
+            "count_enable_pin": 7,
+            "inv_count_enable_pin": null,
+            "load_enable_pin": null,
+            "inv_load_enable_pin": 9,
+            "up_down_input_pin": null,
+            "inv_up_down_input_pin": 10,
+            "terminal_count_pin": 15,
+            "ripple_clock_output_pin": null,
+            "data_pins": [3, 4, 5, 6],
+            "output_pins": [14, 13, 12, 11]
+        }
+    ],
+    "datasheet": "https://www.alldatasheet.com/datasheet-pdf/view/15547/PHILIPS/74HC163.html"
+}

Components/Chips/Sequential/74HC191_CB4CLED.json

@@ -9,6 +9,8 @@
             "func_type": "BINARY_COUNTER",
             "clock_pin": 14,
             "clock_type": "RISING_EDGE",
+            "reset_pin": null,
+            "inv_reset_pin": null,
             "count_enable_pin": null,
             "inv_count_enable_pin": 4,
             "load_enable_pin": null,

Components/Chips/Sequential/74HC74_D.json

@@ -7,27 +7,27 @@
     "functions": [
         {
             "func_type": "D_FLIP_FLOP",
-            "clock_pin": 3,
+            "clock_pin": [3],
             "clock_type": "RISING_EDGE",
             "reset_pin": null,
-            "inv_reset_pin": 1,
+            "inv_reset_pin": [1],
             "set_pin": null,
-            "inv_set_pin": 4,
-            "data_pin": 2,
-            "output_pin": 5,
-            "inv_output_pin": 6
+            "inv_set_pin": [4],
+            "input_pins": [2],
+            "output_pins": [5],
+            "inv_output_pins": [6]
         },
         {
             "func_type": "D_FLIP_FLOP",
-            "clock_pin": 11,
+            "clock_pin": [11],
             "clock_type": "RISING_EDGE",
             "reset_pin": null,
-            "inv_reset_pin": 13,
+            "inv_reset_pin": [13],
             "set_pin": null,
-            "inv_set_pin": 10,
-            "data_pin": 12,
-            "output_pin": 9,
-            "inv_output_pin": 8
+            "inv_set_pin": [10],
+            "input_pins": [12],
+            "output_pins": [9],
+            "inv_output_pins": [8]
         }
     ],
     "datasheet": "https://www.alldatasheet.com/datasheet-pdf/view/15659/PHILIPS/74HC74.html"

Mc/simul61_testee_fonctionnelle (2eme approche)/simul61_testee_fonctionnelle.ino

@@ -0,0 +1,168 @@
+#include <Arduino.h>
+
+const int MAX_INPUTS = 8;
+const int MAX_OUTPUTS = 6;
+
+const int inputPins[MAX_INPUTS] = {22, 23, 24, 25, 26, 27, 28, 29};  // Broches pour I1 à I8
+const int outputPins[MAX_OUTPUTS] = {32, 33, 34, 35, 36, 37};        // Broches pour O1 à O6
+
+String logicExpressions[MAX_OUTPUTS];
+
+void setup() {
+  Serial.begin(9600);
+  for (int i = 0; i < MAX_INPUTS; i++) {
+    pinMode(inputPins[i], INPUT);
+  }
+  for (int i = 0; i < MAX_OUTPUTS; i++) {
+    pinMode(outputPins[i], OUTPUT);
+    digitalWrite(outputPins[i], LOW);
+  }
+}
+
+void loop() {
+  if (Serial.available()) {
+    String input = Serial.readStringUntil('\n');
+    parseMultipleExpressions(input);
+  }
+  updateOutputs();
+}
+
+void resetOutputs() {
+  for (int i = 0; i < MAX_OUTPUTS; i++) {
+    logicExpressions[i] = "";
+    digitalWrite(outputPins[i], LOW);
+  }
+}
+
+void parseMultipleExpressions(String input) {
+  resetOutputs();
+  input.trim();
+  int start = 0;
+  while (start < input.length()) {
+    int end = input.indexOf(';', start);
+    if (end == -1) {
+      end = input.length();
+    }
+    String expression = input.substring(start, end);
+    parseExpression(expression);
+    start = end + 1;
+  }
+}
+
+void parseExpression(String input) {
+  input.trim();
+  int eqIndex = input.indexOf('=');
+  if (eqIndex != -1 && input.startsWith("O")) {
+    int outputIndex = input.substring(1, eqIndex).toInt() - 1;
+    if (outputIndex >= 0 && outputIndex < MAX_OUTPUTS) {
+      logicExpressions[outputIndex] = input.substring(eqIndex + 1);
+    }
+  }
+}
+
+bool evaluateExpression(String expr) {
+  expr.trim();
+  expr.replace(" ", "");
+  for (int i = 0; i < MAX_INPUTS; i++) {
+    expr.replace("!I" + String(i + 1), String(!digitalRead(inputPins[i])));
+    expr.replace("I" + String(i + 1), String(digitalRead(inputPins[i])));
+  }
+  return evaluateComplexExpression(expr);
+}
+
+bool evaluateComplexExpression(String expr) {
+  struct Stack {
+    bool values[64];
+    char operators[64];
+    int valueTop = -1;
+    int operatorTop = -1;
+
+    void pushValue(bool value) {
+      values[++valueTop] = value;
+    }
+
+    bool popValue() {
+      return values[valueTop--];
+    }
+
+    void pushOperator(char op) {
+      operators[++operatorTop] = op;
+    }
+
+    char popOperator() {
+      return operators[operatorTop--];
+    }
+
+    char peekOperator() {
+      return operators[operatorTop];
+    }
+
+    bool isOperatorStackEmpty() {
+      return operatorTop == -1;
+    }
+  } stack;
+
+  for (int i = 0; i < expr.length(); i++) {
+    char c = expr.charAt(i);
+
+    if (c == '0' || c == '1') {
+      stack.pushValue(c == '1');
+    } else if (c == '(') {
+      stack.pushOperator(c);
+    } else if (c == ')') {
+      while (!stack.isOperatorStackEmpty() && stack.peekOperator() != '(') {
+        char op = stack.popOperator();
+        bool val2 = stack.popValue();
+        bool val1 = (op == '!') ? false : stack.popValue();
+        stack.pushValue(applyOperator(val1, val2, op));
+      }
+      stack.popOperator();
+    } else if (c == '&' || c == '|' || c == '!' || c == '^') {
+      while (!stack.isOperatorStackEmpty() && stack.peekOperator() != '(' && precedence(stack.peekOperator()) >= precedence(c)) {
+        char op = stack.popOperator();
+        bool val2 = stack.popValue();
+        bool val1 = (op == '!') ? false : stack.popValue();
+        stack.pushValue(applyOperator(val1, val2, op));
+      }
+      stack.pushOperator(c);
+    }
+  }
+
+  while (!stack.isOperatorStackEmpty()) {
+    char op = stack.popOperator();
+    bool val2 = stack.popValue();
+    bool val1 = (op == '!') ? false : stack.popValue();
+    stack.pushValue(applyOperator(val1, val2, op));
+  }
+
+  return stack.popValue();
+}
+
+bool applyOperator(bool a, bool b, char op) {
+  if (op == '&') return a && b;
+  if (op == '|') return a || b;
+  if (op == '^') return a != b;
+  if (op == '!') return !b;
+  return false;
+}
+
+int precedence(char op) {
+  if (op == '!') return 4;
+  if (op == '&') return 3;
+  if (op == '^') return 2;
+  if (op == '|') return 1;
+  return 0;
+}
+
+void updateOutputs() {
+  for (int i = 0; i < MAX_OUTPUTS; i++) {
+    if (logicExpressions[i] != "") {
+      bool outputValue = evaluateExpression(logicExpressions[i]);
+      if (outputValue) {
+        digitalWrite(outputPins[i], HIGH);
+      } else {
+        digitalWrite(outputPins[i], LOW);
+      }
+    }
+  }
+}