V1 after team test

ESP8266/src/main.cpp

@@ -2,11 +2,11 @@
 #include <ESP8266WebServer.h>
 
 // Remplacez par les informations de votre réseau WiFi
-const char* ssid = "Le chateau de Chantenay";
+const char* ssid = "Refugees Welcome";
-const char* password = "crevette4ever";
+const char* password = "calais62";
 
 // Adresse du serveur HTTP sur le PC
-const char* host = "192.168.1.62";  // Remplacez par l'adresse IP de votre PC
+const char* host = "192.168.234.214";  // Remplacez par l'adresse IP de votre PC
 const int port = 5000;
 
 const int buttonPin = D7; // Définir le pin du bouton
@@ -14,12 +14,27 @@ bool lastButtonState = HIGH; // État précédent du bouton
 unsigned long lastDebounceTime = 0; // Dernier temps de changement d'état
 unsigned long debounceDelay = 50; // Délai de débounce (en millisecondes)
 
+const int ledPin = D5;
+unsigned long lastBlinkTime = 0;  // Dernier temps de clignotement
+const unsigned long blinkInterval = 500;  // Intervalle de clignotement (en millisecondes)
+// Énumération pour les états de la LED
+enum LEDState {
+    OFF,
+    ON,
+    BLINKING
+};
+LEDState ledState = OFF;  // État initial de la LED
+
+ESP8266WebServer server(5000); // Créer un serveur HTTP sur le port 80
+
 void setup() {
   Serial.begin(115200);
   delay(10);
   
+  pinMode(ledPin, OUTPUT);
   pinMode(buttonPin, INPUT_PULLUP);
 
+  digitalWrite(ledPin, LOW);
   WiFi.begin(ssid, password);
   Serial.print("Connexion à ");
   Serial.print(ssid);
@@ -28,12 +43,59 @@ void setup() {
     Serial.print(".");
   }
   Serial.println(" connectée");
+
+  server.on("/blink", []() {
+    // Cette fonction sera appelée lorsque le serveur reçoit une requête sur /update
+    Serial.println("Requête reçue sur /play");
+    // Par exemple, vous pouvez allumer la LED si la requête le demande
+    ledState = BLINKING; // Allumer la LED
+    server.send(200, "text/plain", "LED blink"); // Envoyer une réponse
+  });
+
+    // Définir le gestionnaire pour la requête entrante
+  server.on("/on", []() {
+    // Cette fonction sera appelée lorsque le serveur reçoit une requête sur /update
+    Serial.println("Requête reçue sur /win");
+    // Par exemple, vous pouvez allumer la LED si la requête le demande
+    ledState = ON; // Allumer la LED
+    server.send(200, "text/plain", "LED high"); // Envoyer une réponse
+  });
+
+  server.on("/off", []() {
+    // Cette fonction sera appelée lorsque le serveur reçoit une requête sur /update
+    Serial.println("Requête reçue sur /wait");
+    // Par exemple, vous pouvez allumer la LED si la requête le demande
+    ledState = OFF; // Allumer la LED
+    server.send(200, "text/plain", "LED low"); // Envoyer une réponse
+  });
+
+
+
+  server.begin(); // Démarrer le serveur
 }
 
 void loop() {
+  // Gérer les requêtes entrantes
+  server.handleClient();
+
+  // LED management
+  unsigned long currentTime = millis();
+
+  // Logique de clignotement en fonction de l'état
+  if (ledState == BLINKING) {
+      if (currentTime - lastBlinkTime >= blinkInterval) {
+          lastBlinkTime = currentTime;
+          digitalWrite(ledPin, !digitalRead(ledPin)); // Inverser l'état de la LED
+      }
+  } else if (ledState == ON) {
+      digitalWrite(ledPin, HIGH); // LED allumée
+  } else {
+      digitalWrite(ledPin, LOW); // LED éteinte
+  }
+
   int buttonState = digitalRead(buttonPin); // Lire l'état du bouton
   
-  // Vérifier le débounce
+  // Débounce
   if (buttonState != lastButtonState) {
     lastDebounceTime = millis(); // Réinitialiser le temps de débounce
   }
@@ -45,7 +107,7 @@ void loop() {
       Serial.println("Bouton pressé! Envoi de la requête...");
       WiFiClient client;
       if (client.connect(host, port)) {
-        client.print(String("GET /execute?box_id=1 HTTP/1.1\r\n") +
+        client.print(String("GET /execute HTTP/1.1\r\n") +
                      "Host: " + host + "\r\n" +
                      "Connection: close\r\n\r\n");
 

Python/buttons.json

@@ -1 +1 @@
-{"1": "192.168.1.34", "2": "192.168.1.42"}
+{"1": "192.168.234.240"}

Python/register.py

@@ -10,7 +10,7 @@ app = Flask(__name__)
 
 buttons = {}  # Dictionnaire pour stocker les boutons et leurs IP
 lock = threading.Lock()
-EXPECTED_BUTTONS = 2  # Nombre de boutons attendus
+EXPECTED_BUTTONS = 0 # Nombre de boutons attendus
 
 # Fichier pour enregistrer la correspondance
 BUTTONS_FILE = 'buttons.json'
@@ -53,4 +53,5 @@ def execute_script():
 
 if __name__ == '__main__':
     print("Serveur d'enregistrement démarré")
+    EXPECTED_BUTTONS = int(input("Nombre de buzzers ? "))
     serve(app, host='0.0.0.0', port=5000)  # Utiliser Waitress pour démarrer le serveur

Python/server.py

@@ -7,14 +7,17 @@ import keyboard
 import json
 import os
 from waitress import serve
+from pygame import mixer
 import time
+import requests  # Ajouté pour envoyer des requêtes HTTP
 
 app = Flask(__name__)
 
 DEBUG = False
+INGAME = True
 
 # Variables globales
-fastest = None
+port = 5000  # Définir le port utilisé par vos boutons
 lock = threading.Lock()
 order = []  # Liste pour suivre l'ordre des boutons
 button_ips = {}  # Dictionnaire pour enregistrer les adresses IP des boutons
@@ -25,109 +28,204 @@ if os.path.exists(json_file):
     with open(json_file, 'r') as f:
         button_ips = json.load(f)
 
+def init_mixer():
+    if not mixer.get_init():
+        mixer.init()
+        if DEBUG:
+            print("Mixer initialized.")
+
+def play_sound(file):
+    mixer.music.load(file)
+    mixer.music.play()
+
+def notify_button(ip, endpoint):
+    """ Fonction pour envoyer une requête à un bouton à son adresse IP. """
+    url = f"http://{ip}:{port}{endpoint}"  # Utiliser la variable `port` définie en haut
+    try:
+        response = requests.get(url)
+        if DEBUG:
+            print(f"Requête envoyée à {ip}{endpoint}: {response.status_code}")
+    except Exception as e:
+        print(f"Erreur lors de l'envoi de la requête à {ip}: {e}")
+
 @app.route('/execute')
 def execute_script():
-    global fastest
-    client_ip = request.remote_addr  # Obtenir l'adresse IP du client
 
-    # Vérifier si l'adresse IP est enregistrée
+    if INGAME:
-    button_id = None
+        client_ip = request.remote_addr  # Obtenir l'adresse IP du client
-    for button, ip in button_ips.items():
-        if ip == client_ip:
-            button_id = button
-            break
 
-    if button_id is None:  # Si l'IP n'est pas trouvée
+        # Vérifier si l'adresse IP est enregistrée
-        error_message = {"message": "Erreur : cette adresse IP n'est pas enregistrée."}
+        button_id = None
-        print(f"{error_message['message']} - IP: {client_ip}")
+        for button, ip in button_ips.items():
-        return jsonify(error_message), 400  # Retourne un code d'erreur 400
+            if ip == client_ip:
+                button_id = button
+                break
 
-    send_vlc_command('pl_pause', True)  # Mettre VLC en pause
+        # if button_id is None:  # Si l'IP n'est pas trouvée
+        #     error_message = {"message": "Erreur : cette adresse IP n'est pas enregistrée."}
+        #     print(f"{error_message['message']} - IP: {client_ip}")
+        #     return jsonify(error_message), 400  # Retourne un code d'erreur 400
 
-    # Utiliser un verrou pour gérer les accès concurrents
+        # Utiliser un verrou pour gérer les accès concurrents
-    with lock:
+        with lock:
-        if button_id not in order:
+            if button_id not in order:
-            order.append(button_id)  # Ajouter le boîtier à la liste d'ordre
+                send_vlc_command('pl_pause', True)  # Mettre VLC en pause
-            print(f"Boîtiers en ordre: {order}")
+                play_sound('coin.mp3')  # Son de canard au premier buzz
-            if fastest is None:
+                order.append(button_id)  # Ajouter le boîtier à la liste d'ordre
-                fastest = button_id  # Le premier à arriver devient le gagnant
+                print(f"Boîtiers en ordre: {order}")
-                response_message = {"message": "fastest"}
+
-                # print(f"Fastest is {button_id}")
+                # Notification au bouton premier dans l'ordre
+                if order[0] == button_id:
+                    notify_button(button_ips[button_id], '/on')  # Envoyer /on
+
+                    # Notifier tous les autres boutons enregistrés avec /off
+                    for other_button_id, ip in button_ips.items():
+                        if other_button_id != button_id:
+                            notify_button(ip, '/off')  # Envoyer /off
+
+                response_message = {"message": "added"}  # Réponse pour l'ajout à l'ordre
             else:
-                response_message = {"message": "second"}
+                response_message = {"message": "duplicate"}  # Requête répétée, rejetée
-                # print(f"{button_id} is second")
-        else:
-            response_message = {"message": "duplicate"}  # Requête répétée, rejetée
 
-    return jsonify(response_message), 200
+        return jsonify(response_message), 200
+    
+    else:
+        return jsonify({"message": "not allowed"}), 200
 
 def good_answer():
+    global INGAME
     while True:
-        # Attendre que la touche 'r' soit pressée pour vider l'ordre
+        # Attendre que la touche 'o' soit pressée pour vider l'ordre
         keyboard.wait('o')
         with lock:
-            fastest = None  # Réinitialiser le gagnant
             if order:
+                INGAME = False
                 print(f"--- Boîtier {order[0]} gagne ! ---")
-                order.clear() # Enlever le premier boîtier de l'ordre
+                play_sound('victory.mp3')
-        #seek_to_time('')
+                # Envoyer /off à tous les boutons
-        send_vlc_command('pl_play')
+                for button, ip in button_ips.items():
+                    notify_button(ip, '/off')  # Envoi de /off aux boutons
+                order.clear()  # Vider l'ordre
+                time.sleep(1)
+                send_vlc_command('pl_play')  # Reprendre la musique
 
 def incomplet_answer():
-    global fastest
     while True:
-        # Attendre que la touche 'r' soit pressée pour vider l'ordre
+        # Attendre que la touche 'x' soit pressée pour enlever le premier boîtier
         keyboard.wait('x')
         with lock:
-            fastest = None  # Réinitialiser le gagnant
             if order:
-                print(f"Boîtier {order[0]} : Réponse incomplète")
+                # Vérifier si le premier boîtier est retiré
+                first_button = order[0]
+                print(f"Boîtier {first_button} : Réponse incomplète")
                 order.pop(0)  # Enlever le premier boîtier de l'ordre
                 print(f"Boîtiers en ordre: {order}")
-            if not order:
-                send_vlc_command('pl_play')
 
-def no_answer():
+                # Si le bouton retiré était le premier, lui envoyer /off
-    global fastest
+                notify_button(button_ips[first_button], '/off')
-    while True:
+
-        # Attendre que la touche 'r' soit pressée pour vider l'ordre
+                # Si le second boîtier devient le premier, envoyer /on
-        keyboard.wait('p')
+                if order:
+                    second_button = order[0]
+                    notify_button(button_ips[second_button], '/on')
 
-        with lock:
-            fastest = None  # Réinitialiser le gagnant
-            if order:
-                print(f"Boîtier {order[0]} : Pas de réponse")
-                order.pop(0)  # Enlever le premier boîtier de l'ordre
-                print(f"Boîtiers en ordre: {order}")
             if not order:
-                send_vlc_command('pl_play')
+                # Envoyer /blink à tous les boutons
+                send_vlc_command('pl_play')  # Reprendre la musique
+                for button, ip in button_ips.items():
+                    notify_button(ip, '/blink')
 
 def next_song():
-    global fastest
+    global INGAME
     while True:
-        # Attendre que la touche 'r' soit pressée pour vider l'ordre
+        # Attendre que la touche 'n' soit pressée pour demander le prochain son
-        keyboard.wait('n')
-        print("Are you sure to next ?")
         keyboard.wait('n')
+        send_vlc_command('pl_pause')
+        for button, ip in button_ips.items():
+            notify_button(ip, '/off')
+        time.sleep(1)
+        play_sound('bell.mp3')
+        print("Music - Next in 2 seconds")
+        time.sleep(2)
+        send_vlc_command('pl_next')  # Passer à la chanson suivante
+        INGAME = True
         with lock:
-            fastest = None  # Réinitialiser le gagnant
+            # Si order est vide, envoyer /blink à tous les boutons
-            if order:
+            if not order:
-                order.pop(0)  # Enlever le premier boîtier de l'ordre
+                for button, ip in button_ips.items():
-        print('Next song')
+                    notify_button(ip, '/blink')  # Envoyer /blink à tous les boutons
-        send_vlc_command('pl_next')
+                send_vlc_command('pl_play')  # Reprendre la musique
+
+def play():
+    while True:
+        # Attendre que la touche 'space' soit pressée pour mettre VLC en pause
+        keyboard.wait('m')
+        print("Music - Play")
+        send_vlc_command('pl_play')
 
 def pause():
     while True:
-        # Attendre que la touche 'r' soit pressée pour vider l'ordre
+        # Attendre que la touche 'space' soit pressée pour mettre VLC en pause
-        keyboard.wait('space')
+        keyboard.wait('p')
+        print("Music - Pause")
         send_vlc_command('pl_pause', True)
 
+def light_on():
+    while True:
+        keyboard.wait('r')
+        print("Buzzer light - On")
+        for button, ip in button_ips.items():
+            notify_button(ip, '/on')
+
+def light_blink():
+    while True:
+        keyboard.wait('t')
+        print("Buzzer light - Blink")
+        for button, ip in button_ips.items():
+            notify_button(ip, '/blink')
+
+def light_off():
+    while True:
+        keyboard.wait('y')
+        print("Buzzer light - Off")
+        for button, ip in button_ips.items():
+            notify_button(ip, '/off')
+
+def buzzer_on():
+    global INGAME
+    while True:
+        keyboard.wait('f')
+        INGAME = True
+        print("Buzzer - Enable")
+        for button, ip in button_ips.items():
+            notify_button(ip, '/blink')
+
+def buzzer_off():
+    global INGAME
+    while True:
+        keyboard.wait('h')
+        INGAME = False
+        print("Buzzer - Disable")
+        for button, ip in button_ips.items():
+            notify_button(ip, '/off')
+
 if __name__ == '__main__':
     print("Serveur démarré")
+    init_mixer()
     threading.Thread(target=good_answer, daemon=True).start()
     threading.Thread(target=incomplet_answer, daemon=True).start()
-    threading.Thread(target=no_answer, daemon=True).start()
     threading.Thread(target=next_song, daemon=True).start()
+    threading.Thread(target=play, daemon=True).start()
     threading.Thread(target=pause, daemon=True).start()
+    threading.Thread(target=light_on, daemon=True).start()
+    threading.Thread(target=light_off, daemon=True).start()
+    threading.Thread(target=light_blink, daemon=True).start()
+    threading.Thread(target=buzzer_on, daemon=True).start()
+    threading.Thread(target=buzzer_off, daemon=True).start()
+
+    INGAME = True
+    print("Buzzer - Enable")
+    for button, ip in button_ips.items():
+        notify_button(ip, '/blink')
     
     serve(app, host='0.0.0.0', port=5000)

Python/vlc_control.py

@@ -1,4 +1,5 @@
 import requests
+import time
 
 # Configurer l'adresse et le port de l'interface Web de VLC
 VLC_WEB_URL = 'http://localhost:8080'
@@ -49,3 +50,36 @@ def seek_to_time(minutes, seconds):
     total_seconds = minutes * 60 + seconds
     send_vlc_command(f'seek&val={total_seconds}')
     
+def decrease_volume():
+    """
+    Decrease the volume of VLC to 0 with fixed step and duration.
+    """
+    if not is_vlc_running():
+        print(f"VLC n'est pas accessible à {VLC_WEB_URL}. Assurez-vous que VLC est ouvert et que l'interface Web est activée.")
+        return
+
+    try:
+        # Récupérer le volume actuel
+        status = get_vlc_status()
+        if status is None:
+            return
+        current_volume = int(status.get('volume', 256))
+
+        # Paramètres fixes
+        step_duration = 0.5  # Durée en secondes entre chaque diminution de volume
+        volume_step = 5     # Diminution du volume par étape
+
+        while current_volume > 0:
+            current_volume -= volume_step
+            if current_volume < 0:
+                current_volume = 0
+            send_vlc_command(f'volume&val={int(current_volume)}')
+            time.sleep(step_duration)
+
+        # S'assurer que le volume est à 0
+        send_vlc_command('volume&val=0')
+        if DEBUG:
+            print("Volume baissé à 0.")
+    except requests.RequestException as e:
+        if DEBUG:
+            print(f"Erreur lors de la diminution du volume : {e}")