Ajout des propriétés à Bille : chute et victoire

labyrinthe/2-python/2-labyrinthe.py

@@ -72,28 +72,34 @@ def  init(cont):
 def  cycle(cont):
     obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
     obj['z']=obj.worldPosition.z # la propriété z est mis à jour avec la position globale en z de la bille
-    obj_plateau = scene.objects['Plateau'] # obj_plateau est l'objet 'Plateau'
-    obj_plateau['rot_x']=obj_plateau.worldOrientation.to_euler().x # propriété 'rot_x' mis à jour avec l'orientation globale en x du plateau
-    obj_plateau['rot_y']=obj_plateau.worldOrientation.to_euler().y # propriété 'rot_y' mis à jour avec l'orientation globale en y du plateau
-    obj_plateau['rot_z']=obj_plateau.worldOrientation.to_euler().z # propriété 'rot_z' mis à jour avec l'orientation globale en z du plateau
 
-    # Redémarrer la partie si la bille a chuté et si la panneau victoire n'est pas visible
-    if obj['z'] < -20 and scene.objects['Panneau victoire'].visible == False:
+    # Si l'altitude de bille < -10 et pas de victoire -> chute
+    if obj['z'] < -10 and obj['victoire'] == False:
         print ("Chuuuu.....te")
+        depart() # Replacer la bille au départ
 
-        # Replacement du plateau (tous les angles à 0 en plusieurs fois)
-        while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
-            obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
+# Départ de la bille
+def  depart():
+    obj_bille = scene.objects['Bille']
+    obj_plateau = scene.objects['Plateau']
 
-        # Mettre la bille à la position de départ avec une vitesse nulle
-        obj.worldLinearVelocity=(0, 0, 0)
-        obj.worldAngularVelocity=(0, 0, 0)
-        obj.worldPosition.x = obj['init_x']
-        obj.worldPosition.y = obj['init_y']
-        obj.worldPosition.z = obj['init_z']+0.5 # On repose la bille
+    # Replacement du plateau (tous les angles à 0 en plusieurs fois)
+    while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
+        obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
 
-# Victoire (colision de la bille avec l'arrivée)
+    # Mettre la bille à la position de départ avec une vitesse nulle
+    obj_bille = scene.objects['Bille']
+    obj_bille.worldLinearVelocity=(0, 0, 0)
+    obj_bille.worldAngularVelocity=(0, 0, 0)
+    obj_bille.worldPosition.x = obj_bille['init_x']
+    obj_bille.worldPosition.y = obj_bille['init_y']
+    obj_bille.worldPosition.z = obj_bille['init_z']+0.5 # On repose la bille
+    obj_bille['victoire']=False
+    obj_bille['chute'] = False
+
+# Victoire (collision de la bille avec l'arrivée)
 def victoire(cont):
+    scene.objects['Bille']['victoire']=True
     scene.objects['Panneau victoire'].setVisible(True,True) # Afficher le panneau de la victoire
     scene.objects['Panneau victoire - plan'].restorePhysics() # Restaurer la physique du panneau cliquable
     start = 1
@@ -124,7 +130,7 @@ def victoire_fermer(cont):
     if cont.sensors['Click'].status == JUST_ACTIVATED and cont.sensors['MO'].positive:
         scene.objects['Panneau victoire'].setVisible(False,True) # Cacher le panneau de la victoire
         scene.objects['Panneau victoire - plan'].suspendPhysics (True) # Suspendre la physique du panneau cliquable
-        scene.objects['Bille']['z']= -21 # On provoque le redémarrage si la bille est ressortie
+        depart() # Replacer la bille au départ
 
 ###############################################################################    
 # Gestion du Joystick (Joystick USB)

labyrinthe/3-arduino_pyfirmata/3-labyrinthe.py

@@ -1,6 +1,5 @@
 import bge # Bibliothèque Blender Game Engine (BGE)
 import pyfirmata # Protocole Firmata
-import time # Protocole Firmata
 import labyrinthe_carte # Liaison avec la carte
 
 ###############################################################################
@@ -25,6 +24,7 @@ JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
 JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
 ACTIVATE = bge.logic.KX_INPUT_ACTIVE
 
+# Communication avec la carte Arduino
 # carte = pyfirmata.Arduino('COM4') # Windows
 # carte = pyfirmata.Arduino('/dev/ttyACM0') # GNU/Linux
 # print("Communication Carte Arduino établie")
@@ -155,23 +155,33 @@ def cycle(cont):
     obj_plateau['rot_y']=obj_plateau.worldOrientation.to_euler().y # propriété 'rot_y' mis à jour avec l'orientation globale en y du plateau
     obj_plateau['rot_z']=obj_plateau.worldOrientation.to_euler().z # propriété 'rot_z' mis à jour avec l'orientation globale en z du plateau
 
-    # Redémarrer la partie si la bille a chuté et si la panneau victoire n'est pas visible
-    if obj['z'] < -20 and scene.objects['Panneau victoire'].visible == False:
+    # Si l'altitude de bille < -10 et pas de victoire -> chute
+    if obj['z'] < -10 and obj['victoire'] == False:
         print ("Chuuuu.....te")
+        depart() # Replacer la bille au départ
 
-        # Replacement du plateau (tous les angles à 0 en plusieurs fois)
-        while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
-            obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
+# Départ de la bille
+def  depart():
+    obj_bille = scene.objects['Bille']
+    obj_plateau = scene.objects['Plateau']
 
-        # Mettre la bille à la position de départ avec une vitesse nulle
-        obj.worldLinearVelocity=(0, 0, 0)
-        obj.worldAngularVelocity=(0, 0, 0)
-        obj.worldPosition.x = obj['init_x']
-        obj.worldPosition.y = obj['init_y']
-        obj.worldPosition.z = obj['init_z']+0.5 # On repose la bille
+    # Replacement du plateau (tous les angles à 0 en plusieurs fois)
+    while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
+        obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
 
-# Victoire (colision de la bille avec l'arrivée)
+    # Mettre la bille à la position de départ avec une vitesse nulle
+    obj_bille = scene.objects['Bille']
+    obj_bille.worldLinearVelocity=(0, 0, 0)
+    obj_bille.worldAngularVelocity=(0, 0, 0)
+    obj_bille.worldPosition.x = obj_bille['init_x']
+    obj_bille.worldPosition.y = obj_bille['init_y']
+    obj_bille.worldPosition.z = obj_bille['init_z']+0.5 # On repose la bille
+    obj_bille['victoire']=False
+    obj_bille['chute'] = False
+
+# Victoire (collision de la bille avec l'arrivée)
 def victoire(cont):
+    scene.objects['Bille']['victoire']=True
     scene.objects['Panneau victoire'].setVisible(True,True) # Afficher le panneau de la victoire
     scene.objects['Panneau victoire - plan'].restorePhysics() # Restaurer la physique du panneau cliquable
     start = 1
@@ -202,4 +212,4 @@ def victoire_fermer(cont):
     if cont.sensors['Click'].status == JUST_ACTIVATED and cont.sensors['MO'].positive:
         scene.objects['Panneau victoire'].setVisible(False,True) # Cacher le panneau de la victoire
         scene.objects['Panneau victoire - plan'].suspendPhysics (True) # Suspendre la physique du panneau cliquable
-        scene.objects['Bille']['z']= -21 # On provoque le redémarrage si la bille est ressortie
+        depart() # Replacer la bille au départ

labyrinthe/3-arduino_pyfirmata/labyrinthe_carte.py

@@ -5,7 +5,7 @@ from serial.tools.list_ports import comports # Détection du port automatique
 ###############################################################################
 # labyrinthe_carte.py
 # @title: Détection automatique de la carte Arduino ou microbit
-# @project: Blender-EduTech - Tutoriels 3, 4 et 5 : Labyrinthe à bille - Interfacer avec une carte Arduino/microbit
+# @project: Blender-EduTech - Tutoriel 3 : Labyrinthe à bille - Interfacer avec une carte Arduino par le protocole Firmata
 # @lang: fr
 # @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
 # @copyright: Copyright (C) 2023 Philippe Roy
@@ -50,18 +50,3 @@ def init_firmata():
         except:
             print("Communication avec Carte Arduino impossible")
             return None
-
- # Établir la communication avec la carte avec la liaison série avec une vitesse
-def init_serial(speed=115200):
-    [port, carte_name] =autoget_port()
-    if port is None:
-        print("Communication avec Carte Arduino/microbit impossible")
-        return None
-    else:
-        try:
-            carte = serial.Serial(port,speed)
-            print("Communication avec Carte Arduino/microbit établie sur "+port+" à la vitesse "+speed+"bauds")
-            return carte
-        except:
-            print("Communication avec Carte Arduino/microbit impossible")
-            return None

labyrinthe/4-arduino_pyserial/4-labyrinthe-imu/4-labyrinthe-imu.ino

@@ -63,7 +63,6 @@ void setup() {
   matrix.setBlinkRate(BLINK_OFF);
   matrix.clear();
   matrix.display();
-  // matrix.writeOnePicture(0xff90b2a2a6a4ae82); // Labyrinthe
  }
 
 /******************************************************************************
@@ -99,9 +98,6 @@ void loop() {
     /*****
      * Led Matrix : UPBGE -> Arduino
      *****/
-
-    /* matrix.writeNumber(0, 800); */
-    /* matrix.display(); */
     
     if (serial_msg_complet) {
 	matrix.clear();
@@ -114,40 +110,16 @@ void loop() {
 	    matrix.writePixel(x, y, true);
 	}
 	
-	// Départ - Flèches
-	if (xy==90) {
-	    matrix.writeOnePicture(0xe7c3a51818a5c3e7);
-	    matrix.display();
-	    delay(500);
-	    Serial.println("start"); // Relance le jeu
-	}
-
 	// Chute
 	if (xy==91) {
 	    matrix.writeOnePicture(0x81423c0000666600);
 	    matrix.display();
-	    delay(500);
+	    delay(1000);
 	    Serial.println("start"); // Relance le jeu
 	}
 
 	// Victoire
 	if (xy==92)  matrix.writeOnePicture(0x003c428100666600);
-	/* matrix.writeIcon(10); */
-
-	/* Orientation du plateau (N, NE, SE, S, SO, O, NO) */
-	/* if (serial_msg.length() ==2) { */
-	/*     if (serial_msg[0] == 'X') matrix.clear(); */
-	/*     if (serial_msg[0] == 'N') matrix.writeOnePicture(0x00000000000000ff); */
-	/*     if (serial_msg[0] == 'E') matrix.writeOnePicture(0x8080808080808080); */
-	/*     if (serial_msg[0] == 'S') matrix.writeOnePicture(0xff00000000000000); */
-	/*     if (serial_msg[0] == 'O') matrix.writeOnePicture(0x0101010101010101); */
-	/* } */
-	/* if (serial_msg.length() ==3) { */
-	/*     if ((serial_msg[0] == 'N') and (serial_msg[1] == 'E')) matrix.writeOnePicture(0x00000000808080f0); */
-	/*     if ((serial_msg[0] == 'S') and (serial_msg[1] == 'E')) matrix.writeOnePicture(0xf080808000000000); */
-	/*     if ((serial_msg[0] == 'S') and (serial_msg[1] == 'O')) matrix.writeOnePicture(0x0f01010100000000); */
-	/*     if ((serial_msg[0] == 'N') and (serial_msg[1] == 'O')) matrix.writeOnePicture(0x000000000101010f); */
-	/* } */
 	
 	matrix.display();
 	serial_msg = "";

labyrinthe/4-arduino_pyserial/4-labyrinthe.py

@@ -1,6 +1,6 @@
 import bge # Bibliothèque Blender Game Engine (BGE)
-import time
 import serial # Liaison série
+import labyrinthe_carte # Liaison avec la carte
 
 ###############################################################################
 # 4-labyrinthe.py
@@ -20,19 +20,20 @@ scene = bge.logic.getCurrentScene()
 # print("Objets de la scene : ", scene.objects) # Lister les objets de la scène
 
 # Constantes
-
 JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
 JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
 ACTIVATE = bge.logic.KX_INPUT_ACTIVE
 
-###############################################################################
 # Communication avec la carte Arduino
-###############################################################################
+# serial_baud=115200
+# # serial_comm = serial.Serial('COM4',serial_baud, timeout=0.016) # Windows
+# serial_comm = serial.Serial('/dev/ttyACM1',serial_baud, timeout=0.016) # GNU/Linux
+# print (serial_comm)
 
-serial_baud=115200
-# serial_comm = serial.Serial('COM4',serial_baud, timeout=0.016) # Windows
-serial_comm = serial.Serial('/dev/ttyACM0',serial_baud, timeout=0.016) # GNU/Linux
-print (serial_comm)
+# Détection de la carte avec la liaison série
+serial_comm = labyrinthe_carte.init_serial()
+if serial_comm is None:
+    bge.logic.endGame()
 
 ###############################################################################
 # Gestion de la centrale inertielle (capteur IMU (inertial measurement unit))
@@ -51,26 +52,13 @@ def  capteur(cont):
         serial_comm.close()
         bge.logic.endGame()
 
-    # Lecture de la liaison série : programme Arduino : 3-labyrinthe-imu.ino
+    # Lecture de la liaison série : programme Arduino : 4-labyrinthe-imu.ino
     serial_msg_in = str(serial_comm.readline())
 
-    # Affiche le message uniquement
-    # if serial_msg_in.find("Print")>0 or serial_msg_in.find("Debug")>0 or serial_msg_in.find("Echo")>0:
-    #     print ("Communication port série : ", serial_msg_in)
-    #     serial_msg_in=""
-    #     return
-
     # Mettre la bille à la position de départ avec une vitesse nulle
     if serial_msg_in.find("start")>0:
         if obj_bille['victoire'] or obj_bille['chute']:
             depart()
-            # obj_bille.worldLinearVelocity=(0, 0, 0)
-            # obj_bille.worldAngularVelocity=(0, 0, 0)
-            # obj_bille.worldPosition.x = obj_bille['init_x']
-            # obj_bille.worldPosition.y = obj_bille['init_y']
-            # obj_bille.worldPosition.z = obj_bille['init_z']+0.5 # On repose la bille
-            # obj_bille['victoire']=False
-            # obj_bille['chute'] = False
 
     # Roll et Pitch
     if serial_msg_in.find(",")>0:
@@ -84,36 +72,13 @@ def  capteur(cont):
                 obj.applyRotation((x-obj.worldOrientation.to_euler().x, 0, -obj.worldOrientation.to_euler().z), False)
             while abs(y-obj.worldOrientation.to_euler().y) > ecart :
                 obj.applyRotation((0, y-obj.worldOrientation.to_euler().y, -obj.worldOrientation.to_euler().z), False)
-
-        # Ecriture de l'orientation du plateau sur la liaison série : programme Arduino : 3-labyrinthe-imu.ino
-        # obj['Rx']=obj.worldOrientation.to_euler().x*57.3
-        # obj['Ry']=obj.worldOrientation.to_euler().y*57.3
-        # obj['Rz']=obj.worldOrientation.to_euler().z*57.3
-        # if obj['Rx']<-2 and obj['Ry'] >-2 and obj['Ry'] <2:
-        #     serial_msg_out = "N\n"
-        # if obj['Rx']>2 and obj['Ry'] >-2 and obj['Ry'] <2:
-        #     serial_msg_out = "S\n"
-        # if obj['Rx']>-2 and obj['Rx']<2 and obj['Ry'] <-2 :
-        #     serial_msg_out = "O\n"
-        # if obj['Rx']>-2 and obj['Rx']<2 and obj['Ry'] > 2 :
-        #     serial_msg_out = "E\n"
-        # if obj['Rx']<-2 and obj['Ry'] <-2 :
-        #     serial_msg_out = "NO\n"
-        # if obj['Rx']<-2 and obj['Ry'] > 2 :
-        #     serial_msg_out = "NE\n"
-        # if obj['Rx']>2 and obj['Ry'] <-2 :
-        #     serial_msg_out = "SO\n"
-        # if obj['Rx']>2 and obj['Ry'] > 2 :
-        #     serial_msg_out = "SE\n"
-        # if obj['Rx']>-2 and obj['Rx']<2 and obj['Ry'] >-2 and obj['Ry'] <2:
-        #     serial_msg_out = "X\n"
    
 ###############################################################################
 # Gameplay
 ###############################################################################
 
 # Initialisation de la scène
-def  init(cont):
+def init(cont):
     obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
 
     # Mémorisation de la position de départ de la bille
@@ -121,21 +86,17 @@ def  init(cont):
     obj['init_y']=obj.worldPosition.y
     obj['init_z']=obj.worldPosition.z
 
-    # Afficher image de début (flèches) sur la matrice de leds
-    # serial_msg_out = "90\n"
-    # serial_comm.write(serial_msg_out.encode())
-
     # Cacher le panneau de la victoire et suspendre la physique du panneau cliquable
     scene.objects['Panneau victoire'].setVisible(False,True)
     scene.objects['Panneau victoire - plan'].suspendPhysics (True)
     scene.objects['Bouton fermer'].color = (0, 0, 0, 1) # Noir
 
 # Cycle (boucle de contrôle de la bille)
-def  cycle(cont):
+def cycle(cont):
     obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
     obj['z']=obj.worldPosition.z # la propriété z est mis à jour avec la position globale en z de la bille
 
-    # Ecriture de la position de la bille sur la liaison série : programme Arduino : 4-labyrinthe-imu.ino
+    # Écriture de la position de la bille sur la liaison série : programme Arduino : 4-labyrinthe-imu.ino
     if obj['victoire']==False and obj['chute']==False:
         # obj['x'] = obj.worldPosition.x # de -3.5 à 3.5
         # obj['y'] = obj.worldPosition.y # de 3.5 à -3.5
@@ -148,11 +109,10 @@ def  cycle(cont):
         serial_msg_out = str(obj['Lx'])+str(obj['Ly'])+"\n"
         serial_comm.write(serial_msg_out.encode())
 
-    # Chute ?
-    if obj['z'] < -10 and obj['victoire'] == False:
+    # Si l'altitude de bille < -10 et pas de victoire -> chute
+    if obj['z'] < -10 and obj['victoire'] == False :
 
         # Afficher image de chute sur la matrice de leds
-        print ("Chuuuu.....te")
         serial_msg_out = "91\n"
         serial_comm.write(serial_msg_out.encode())
         obj['chute'] = True
@@ -160,6 +120,13 @@ def  cycle(cont):
 # Départ de la bille
 def  depart():
     obj_bille = scene.objects['Bille']
+    obj_plateau = scene.objects['Plateau']
+
+    # Replacement du plateau (tous les angles à 0 en plusieurs fois)
+    while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
+        obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
+
+    # Mettre la bille à la position de départ avec une vitesse nulle
     obj_bille.worldLinearVelocity=(0, 0, 0)
     obj_bille.worldAngularVelocity=(0, 0, 0)
     obj_bille.worldPosition.x = obj_bille['init_x']
@@ -168,7 +135,7 @@ def  depart():
     obj_bille['victoire']=False
     obj_bille['chute'] = False
 
-# Victoire (colision de la bille avec l'arrivée)
+# Victoire (collision de la bille avec l'arrivée)
 def victoire(cont):
 
     # Afficher image de victoire sur la matrice de leds
@@ -208,6 +175,3 @@ def victoire_fermer(cont):
         scene.objects['Panneau victoire'].setVisible(False,True) # Cacher le panneau de la victoire
         scene.objects['Panneau victoire - plan'].suspendPhysics (True) # Suspendre la physique du panneau cliquable
         depart()
-        # serial_msg_out = "90\n" # Afficher image de début (flèches) sur la matrice de leds
-        # serial_comm.write(serial_msg_out.encode())
-        # scene.objects['Bille']['z']= -21 # On provoque le redémarrage si la bille est ressortie

labyrinthe/4-arduino_pyserial/etape1/4-labyrinthe.py

@@ -19,19 +19,21 @@ scene = bge.logic.getCurrentScene()
 # print("Objets de la scene : ", scene.objects) # Lister les objets de la scène
 
 # Constantes
-
 JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
 JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
 ACTIVATE = bge.logic.KX_INPUT_ACTIVE
 
-###############################################################################
 # Communication avec la carte Arduino
-###############################################################################
+# serial_baud=115200
+# # serial_comm = serial.Serial('COM4',serial_baud, timeout=0.016) # Windows
+# serial_comm = serial.Serial('/dev/ttyACM0',serial_baud, timeout=0.016) # GNU/Linux
+# print (serial_comm)
 
-serial_baud=115200
-# serial_comm = serial.Serial('COM4',serial_baud, timeout=0.016) # Windows
-serial_comm = serial.Serial('/dev/ttyACM0',serial_baud, timeout=0.016) # GNU/Linux
-print (serial_comm)
+# Détection de la carte avec la liaison série
+serial_comm = labyrinthe_carte.init_serial()
+if serial_comm is None:
+    bge.logic.endGame()
+print("Communication Carte Arduino établie")
 
 ###############################################################################
 # Gestion de la centrale inertielle (capteur IMU (inertial measurement unit))
@@ -50,7 +52,7 @@ def capteur(cont):
         serial_comm.close()
         bge.logic.endGame()
 
-    # Lecture de la liaison série : programme Arduino : 3-labyrinthe-imu.ino
+    # Lecture de la liaison série : programme Arduino : 4-labyrinthe-imu.ino
     serial_msg_in = str(serial_comm.readline())
 
     # Roulis/Roll(x) et Tangage/Pitch(y)
@@ -88,28 +90,34 @@ def  init(cont):
 def  cycle(cont):
     obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
     obj['z']=obj.worldPosition.z # la propriété z est mis à jour avec la position globale en z de la bille
-    obj_plateau = scene.objects['Plateau'] # obj_plateau est l'objet 'Plateau'
-    obj_plateau['rot_x']=obj_plateau.worldOrientation.to_euler().x # propriété 'rot_x' mis à jour avec l'orientation globale en x du plateau
-    obj_plateau['rot_y']=obj_plateau.worldOrientation.to_euler().y # propriété 'rot_y' mis à jour avec l'orientation globale en y du plateau
-    obj_plateau['rot_z']=obj_plateau.worldOrientation.to_euler().z # propriété 'rot_z' mis à jour avec l'orientation globale en z du plateau
 
-    # Redémarrer la partie si la bille a chuté et si la panneau victoire n'est pas visible
-    if obj['z'] < -20 and scene.objects['Panneau victoire'].visible == False:
+    # Si l'altitude de bille < -10 et pas de victoire -> chute
+    if obj['z'] < -10 and obj['victoire'] == False:
         print ("Chuuuu.....te")
+        depart()
 
-        # Replacement du plateau (tous les angles à 0 en plusieurs fois)
-        while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
-            obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
+# Départ de la bille
+def  depart():
+    obj_bille = scene.objects['Bille']
+    obj_plateau = scene.objects['Plateau']
 
-        # Mettre la bille à la position de départ avec une vitesse nulle
-        obj.worldLinearVelocity=(0, 0, 0)
-        obj.worldAngularVelocity=(0, 0, 0)
-        obj.worldPosition.x = obj['init_x']
-        obj.worldPosition.y = obj['init_y']
-        obj.worldPosition.z = obj['init_z']+0.5 # On repose la bille
+    # Replacement du plateau (tous les angles à 0 en plusieurs fois)
+    while obj_plateau.worldOrientation.to_euler().x != 0 and obj_plateau.worldOrientation.to_euler().y !=0 and obj_plateau.worldOrientation.to_euler().z !=0 :
+        obj_plateau.applyRotation((-obj_plateau.worldOrientation.to_euler().x, -obj_plateau.worldOrientation.to_euler().y, -obj_plateau.worldOrientation.to_euler().z), False)
+
+    # Mettre la bille à la position de départ avec une vitesse nulle
+    obj_bille = scene.objects['Bille']
+    obj_bille.worldLinearVelocity=(0, 0, 0)
+    obj_bille.worldAngularVelocity=(0, 0, 0)
+    obj_bille.worldPosition.x = obj_bille['init_x']
+    obj_bille.worldPosition.y = obj_bille['init_y']
+    obj_bille.worldPosition.z = obj_bille['init_z']+0.5 # On repose la bille
+    obj_bille['victoire']=False
+    obj_bille['chute'] = False
 
 # Victoire (colision de la bille avec l'arrivée)
 def victoire(cont):
+    scene.objects['Bille']['victoire']=True
     scene.objects['Panneau victoire'].setVisible(True,True) # Afficher le panneau de la victoire
     scene.objects['Panneau victoire - plan'].restorePhysics() # Restaurer la physique du panneau cliquable
     start = 1
@@ -140,4 +148,4 @@ def victoire_fermer(cont):
     if cont.sensors['Click'].status == JUST_ACTIVATED and cont.sensors['MO'].positive:
         scene.objects['Panneau victoire'].setVisible(False,True) # Cacher le panneau de la victoire
         scene.objects['Panneau victoire - plan'].suspendPhysics (True) # Suspendre la physique du panneau cliquable
-        scene.objects['Bille']['z']= -21 # On provoque le redémarrage si la bille est ressortie
+        depart()

labyrinthe/4-arduino_pyserial/labyrinthe_carte.py

@@ -0,0 +1,52 @@
+import serial # Liaison série
+from serial.tools.list_ports import comports # Détection du port automatique
+
+###############################################################################
+# labyrinthe_carte.py
+# @title: Détection automatique de la carte Arduino ou microbit
+# @project: Blender-EduTech - Tutoriel 4 : Labyrinthe à bille - Interfacer avec une carte Arduino par la liaision série
+# @lang: fr
+# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
+# @copyright: Copyright (C) 2023 Philippe Roy
+# @license: GNU GPL
+#
+# Détection automatique de la carte Arduino ou microbit
+#
+###############################################################################
+
+###############################################################################
+# Communication avec la carte Arduino
+###############################################################################
+
+# Recherche automatique du port (microbit, Arduino Uno et Arduino Mega)
+def autoget_port():
+    # USB Vendor ID,  USB Product ID
+    carte_dict={'microbit' :[3368, 516],
+        'uno' :[9025, 67],
+        'mega' :[9025, 66]}
+    for com in comports(): # micro:bit
+        if com.vid == carte_dict['microbit'][0] and com.pid == carte_dict['microbit'][1]:
+            return [com.device,"micro:bit"]
+    for com in comports(): # Arduino Uno
+        if com.vid == carte_dict['uno'][0] and com.pid == carte_dict['uno'][1]:
+            return [com.device,"Arduino Uno"]
+    for com in comports(): # Arduino Mega
+        if com.vid == carte_dict['mega'][0] and com.pid == carte_dict['mega'][1]:
+            return [com.device,"Arduino Mega"]
+    return [None,""]
+
+ # Établir la communication avec la carte par la liaison série avec une vitesse
+def init_serial(speed=115200):
+    [port, carte_name] =autoget_port()
+    print (port, carte_name)
+    if port is None:
+        print("Carte Arduino/microbit introuvable")
+        return None
+    else:
+        serial_comm = serial.Serial(port, speed, timeout=0.016)
+        if serial_comm is None:
+            print("Communication avec Carte Arduino/microbit impossible")
+            return None
+        else:
+            print("Communication avec Carte Arduino/microbit établie sur "+port+" à la vitesse "+str(speed)+" bauds")
+            return serial_comm