arduino codeprot/Hardware_Puzzle

1 files changed, 125 insertions, 58 deletions

diff --git a/main/puzzle/hardware/main.c b/main/puzzle/hardware/main.c
index c1bf1ea..b17fbeb 100644
--- a/main/puzzle/hardware/main.c
+++ b/main/puzzle/hardware/main.c
@@ -2,6 +2,8 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <time.h>
+#include <Arduino.h> // Voor millis()
+#include <string.h>  // Voor de strlen functie
 
 typedef enum {
     UNINITIALIZED,
@@ -17,7 +19,7 @@ typedef enum {
 
 #define MORSE_CODE_LENGTH 4
 #define NUMBER_OF_POTENTIOMETERS 4
-#define CORRECT_LOGIC_GATES_VALUE {1, 0, 1, 0, 1, 0, 1, 0}
+const int CORRECT_LOGIC_GATES_VALUE[8] = {0, 1, 1, 0, 0, 0, 1, 0};
 #define LONG_TONE_DURATION 1000   // Duur van een lange toon (1 seconde)
 #define SHORT_TONE_DURATION 500   // Duur van een korte toon (0.5 seconde)
 #define SHORT_PAUSE_DURATION 500  // Duur van een korte pauze na een toon (0.5 seconde)
@@ -38,17 +40,17 @@ const char* MORSE_CODE[10] = {
 
 HardwarePuzzleState currentState = UNINITIALIZED;
 
-// Puzzle state structure
 typedef struct {
     PlayingSubState playing_substate;
-    char code[MORSE_CODE_LENGTH + 1];   // Buffer for the generated code
-    int logic_gate_values[8];           // Buffer for logic gate values
+    char code[MORSE_CODE_LENGTH + 1];
+    int logic_gate_values[8];
     int potentiometer_values[NUMBER_OF_POTENTIOMETERS];
     int correct_potentiometer_values[MORSE_CODE_LENGTH];
     bool tone_playing;
     int morse_code_step;
     int morse_code_number_step;
     unsigned long ms_delay;
+    char user_morse_code[MORSE_CODE_LENGTH + 1];
 } PuzzleState;
 
 PuzzleState puzzleState;
@@ -61,18 +63,25 @@ void on_stay();
 void puzzle_check();
 void change_gamestage(HardwarePuzzleState state);
 int play_morse_code();
+bool morse_code_input_correct();
+bool check_logic_gates();
+void read_serial_input();
+void read_morse_code_input();
 
+void setup() {
+    Serial.begin(9600);
 
-int main() {
-    srand(time(NULL)); 
+    // Willekeurigheidsinitialisatie met een variabele waarde
+    unsigned long seed = analogRead(A0) * analogRead(A1);
+    randomSeed(seed);
 
     enterState(UNINITIALIZED);
-    
-    while (currentState != SOLVED) {
-        enterState(currentState);
-    }
+}
 
-    return 0;
+void loop() {
+    if (currentState != SOLVED) {
+        on_stay();
+    }
 }
 
 void enterState(HardwarePuzzleState state) {
@@ -80,86 +89,142 @@ void enterState(HardwarePuzzleState state) {
 
     switch (currentState) {
         case UNINITIALIZED:
-            printf("System is uninitialized.\n");
-            enterState(IDLE); 
+            Serial.println("System is uninitialized.");
+            enterState(IDLE);
             break;
         case IDLE:
-            printf("System is idle. Starting puzzle...\n");
-            enterState(PLAYING); 
+            Serial.println("System is idle. Starting puzzle...");
+            enterState(PLAYING);
             break;
         case PLAYING:
-            printf("Playing the puzzle...\n");
-            puzzleState.playing_substate = PLAYING_MORSECODE; 
-            generate_random_four_digit_code();
-            change_gamestage(IDLE); 
+            Serial.println("Playing the puzzle...");
+            puzzleState.playing_substate = PLAYING_LOGICGATES; // Start with logic gates
+            Serial.println("Enter 8 logic gate values (0 or 1) separated by spaces:");
             break;
         case SOLVED:
-            printf("Congratulations! Puzzle solved.\n");
-            
+            Serial.println("Congratulations! Puzzle solved.");
             break;
     }
 }
 
 void generate_random_four_digit_code() {
-    printf("Generating random Morse code...\nCode: ");
+    Serial.print("Generating random Morse code...\nCode: ");
     for (int i = 0; i < MORSE_CODE_LENGTH; i++) {
-        puzzleState.correct_potentiometer_values[i] = rand() % 10;
-        puzzleState.code[i] = puzzleState.correct_potentiometer_values[i] + '0'; 
+        int random_index = random(0, 10); // Genereer een willekeurig getal tussen 0 en 9
+        puzzleState.correct_potentiometer_values[i] = random_index;
+        puzzleState.code[i] = random_index + '0'; // Zet het getal om naar een karakter
     }
     puzzleState.code[MORSE_CODE_LENGTH] = '\0'; 
-    printf("%s\n", puzzleState.code);
+    Serial.println(puzzleState.code);
 }
 
-// Render function based on the current substate
 void render() {
     if (puzzleState.ms_delay == 0) {
         puzzleState.ms_delay = millis() + play_morse_code();
     } else if (millis() >= puzzleState.ms_delay) {
         puzzleState.ms_delay = 0;
     }
-
-    if (puzzleState.playing_substate == PLAYING_MORSECODE) {
-        int values = puzzleState.potentiometer_values[0] * 1000 +
-                     puzzleState.potentiometer_values[1] * 100 +
-                     puzzleState.potentiometer_values[2] * 10 +
-                     puzzleState.potentiometer_values[3];
-        // Set display value using GPIO manager
-        // GpioManager::instance().set_display_value(values);
-    }
 }
 
-// Function to handle staying in the current state
 void on_stay() {
-    switch (puzzleState.playing_substate) {
-        case PLAYING_MORSECODE:
-            render();
+    switch (currentState) {
+        case PLAYING:
+            if (puzzleState.playing_substate == PLAYING_LOGICGATES) {
+                read_serial_input(); // Read input from serial monitor
+                if (check_logic_gates()) {
+                    puzzleState.playing_substate = PLAYING_MORSECODE;
+                    Serial.println("Logic gates correct. Proceeding to Morse code.");
+                    generate_random_four_digit_code(); // Generate Morse code after logic gates are correct
+                    Serial.println("Enter the Morse code as a 4-digit number:");
+                }
+            } else if (puzzleState.playing_substate == PLAYING_MORSECODE) {
+                read_morse_code_input(); // Read Morse code input from serial monitor
+                render();
+            }
             break;
-        case PLAYING_LOGICGATES:
-            // Get user input for logic gates
-                puzzle_check(); // Check puzzle status (uncomment when implemented)
+        default:
             break;
     }
 }
 
-// Function to check puzzle status based on the current substate
 void puzzle_check() {
     switch (puzzleState.playing_substate) {
         case PLAYING_LOGICGATES:
-            for (int i = 0; i < 8; i++) {
-                if (puzzleState.logic_gate_values[i] != CORRECT_LOGIC_GATES_VALUE[i]) {
-                    return;
-                }
+            if (check_logic_gates()) {
+                puzzleState.playing_substate = PLAYING_MORSECODE;
             }
-            puzzleState.playing_substate = PLAYING_MORSECODE;
             break;
         case PLAYING_MORSECODE:
-                if (morse_code_input_correct()) {
-                    currentState = SOLVED; // Puzzle solved, transition to SOLVED-state
-                }
+            if (morse_code_input_correct()) {
+                currentState = SOLVED; // Puzzle solved, transition to SOLVED-state
+            }
             break;
     }
 }
 
+bool morse_code_input_correct() {
+    // Compare user input with generated code
+    for (int i = 0; i < MORSE_CODE_LENGTH; i++) {
+        if (puzzleState.user_morse_code[i] != puzzleState.code[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool check_logic_gates() {
+    for (int i = 0; i < 8; i++) {
+        if (puzzleState.logic_gate_values[i] != CORRECT_LOGIC_GATES_VALUE[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+void read_serial_input() {
+    if (Serial.available() > 0) {
+        String input = Serial.readStringUntil('\n');
+        int index = 0;
+        for (int i = 0; i < input.length(); i++) {
+            if (input[i] == '0' || input[i] == '1') {
+                if (index < 8) {
+                    puzzleState.logic_gate_values[index] = input[i] - '0';
+                    index++;
+                }
+            }
+        }
+        if (index == 8) {
+            Serial.println("Logic gate values incorrect");
+            for (int i = 0; i < 8; i++) {
+                Serial.print(puzzleState.logic_gate_values[i]);
+                Serial.print(" ");
+            }
+            Serial.println();
+        } else {
+            Serial.println("Invalid input. Please enter 8 logic gate values (0 or 1) separated by spaces:");
+        }
+    }
+}
+
+void read_morse_code_input() {
+    if (Serial.available() > 0) {
+        String input = Serial.readStringUntil('\n');
+        if (input.length() == MORSE_CODE_LENGTH) {
+            input.toCharArray(puzzleState.user_morse_code, MORSE_CODE_LENGTH + 1);
+            Serial.print("Morse code input received: ");
+            Serial.println(puzzleState.user_morse_code);
+            if (morse_code_input_correct()) {
+                Serial.println("Morse code correct! Puzzle solved.");
+                currentState = SOLVED;
+            } else {
+                Serial.println("Morse code incorrect. Try again.");
+            }
+        } else {
+            Serial.println("Invalid input. Please enter the Morse code as a 4-digit number:");
+        }
+    }
+}
+
 int play_morse_code() {
     if (puzzleState.morse_code_step < MORSE_CODE_LENGTH) {
         if (puzzleState.morse_code_number_step < strlen(MORSE_CODE[0])) {
@@ -169,16 +234,19 @@ int play_morse_code() {
                 if (current_symbol >= '0' && current_symbol <= '9') {
                     int morse_index = current_symbol - '0';
                     char morse_signal = MORSE_CODE[morse_index][puzzleState.morse_code_number_step];
-                    if (morse_signal == '.') {                             //korte toon
-                        GpioManager::instance().set_buzzer_pin(440);
+                    if (morse_signal == '.') {
+                        // GpioManager::instance().set_buzzer_pin(440);
+                        //Serial.println("Playing short tone");
                         return SHORT_TONE_DURATION;
-                    } else if (morse_signal == '-') {                      //lange toon
-                        GpioManager::instance().set_buzzer_pin(440);
+                    } else if (morse_signal == '-') {
+                        // GpioManager::instance().set_buzzer_pin(440);
+                        //Serial.println("Playing long tone");
                         return LONG_TONE_DURATION;
                     }
                 }
             } else {
-                GpioManager::instance().set_buzzer_pin(0);
+                // GpioManager::instance().set_buzzer_pin(0);
+                //Serial.println("Pausing tone");
                 puzzleState.tone_playing = false;
                 puzzleState.morse_code_number_step++;
                 return SHORT_PAUSE_DURATION;
@@ -195,7 +263,6 @@ int play_morse_code() {
     return 0;
 }
 
-// Function to change the game stage (transition between states)
 void change_gamestage(HardwarePuzzleState state) {
     currentState = state;
-}
+}
\ No newline at end of file