Tutoriels 3 et 4 : point d'étape

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

@@ -5,7 +5,7 @@
 /******************************************************************************
  * 4-labyrinthe-imu.ino
  * @title: Programme pour la carte Arduino de gestion de centrale inertielle (capteur IMU)
- * @project: Blender-EduTech - Tutoriel 3 : Labyrinthe à bille - Interfacer avec une carte Arduino par la liaision série
+ * @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 
@@ -63,7 +63,7 @@ void setup() {
   matrix.setBlinkRate(BLINK_OFF);
   matrix.clear();
   matrix.display();
-  /* matrix.writeOnePicture(0xff90b2a2a6a4ae82); // Labyrinthe */
+  // matrix.writeOnePicture(0xff90b2a2a6a4ae82); // Labyrinthe
  }
 
 /******************************************************************************
@@ -99,14 +99,20 @@ void loop() {
     /*****
      * Led Matrix : UPBGE -> Arduino
      *****/
+
+    /* matrix.writeNumber(0, 800); */
+    /* matrix.display(); */
+    
     if (serial_msg_complet) {
 	matrix.clear();
 	int xy= serial_msg.toInt(); // Message par chiffre : XY
 
-	// Postion de la bille en x et y
+	// Position de la bille en x et y
+	if (xy<90) {
 	    int x= xy/10;
 	    int y= xy-(x*10);
-	if (xy<90) matrix.writePixel(x, y, true);
+	    matrix.writePixel(x, y, true);
+	}
 	
 	// Départ - Flèches
 	if (xy==90) {
@@ -125,10 +131,8 @@ void loop() {
 	}
 
 	// Victoire
-	if (xy==92) {
+	if (xy==92)  matrix.writeOnePicture(0x003c428100666600);
 	/* matrix.writeIcon(10); */
-	    matrix.writeOnePicture(0x003c428100666600);
-	}
 
 	/* Orientation du plateau (N, NE, SE, S, SO, O, NO) */
 	/* if (serial_msg.length() ==2) { */
@@ -153,7 +157,7 @@ void loop() {
 
     
 /******************************************************************************
- * Évenement provoqué UPBGE (via la liaison série)
+ * Évènement provoqué par UPBGE (via la liaison série)
  ******************************************************************************/
 
 void serialEvent() {

labyrinthe/4-arduino_pyserial/4-labyrinthe.py

@@ -1,10 +1,11 @@
 import bge # Bibliothèque Blender Game Engine (BGE)
+import time
 import serial # Liaison série
 
 ###############################################################################
 # 4-labyrinthe.py
 # @title: Module (unique) de la scène 3D du labyrinthe à bille pilotable avec une centrale inertielle (capteur IMU)
-# @project: Blender-EduTech - Tutoriel 3 : Labyrinthe à bille - Interfacer avec une carte Arduino par la liaision série
+# @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
@@ -30,59 +31,19 @@ ACTIVATE = bge.logic.KX_INPUT_ACTIVE
 
 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
+serial_comm = serial.Serial('/dev/ttyACM0',serial_baud, timeout=0.016) # GNU/Linux
 print (serial_comm)
-serial_matrix_led=False # Afficher la position de la bille sur la matrice de leds
 
 ###############################################################################
 # Gestion de la centrale inertielle (capteur IMU (inertial measurement unit))
 ###############################################################################
 
-# Extraction d'un texte compris entre deux bornes textuelles
-def txt_extrac(txt, borne_avant, borne_apres):
-    if txt.find(borne_avant)>0 and txt.find(borne_apres)>0:
-        txt1 = txt.split(borne_avant, 2)
-        txt2 = txt1[1].split(borne_apres, 2)
-        return (txt2[0])
-    else:
-        return ("")
-
-# Atteindre une orientation  (bas niveau)
-def applyRotationTo(obj, rx=None, ry=None, rz=None, Local=True):
-    rres=0.001 # Résolution rotation
-
-    # x
-    if rx is not None:
-        while (abs(rx-obj.worldOrientation.to_euler().x) > rres) :
-            if obj.worldOrientation.to_euler().x-rx > rres:
-                obj.applyRotation((-rres, 0, 0), Local)
-            if rx-obj.worldOrientation.to_euler().x > rres:
-                obj.applyRotation((rres, 0, 0), Local)
-            # print ("delta x ",rx-obj.worldOrientation.to_euler().x)
-        
-    # y
-    if ry is not None:
-        while (abs(ry-obj.worldOrientation.to_euler().y) > rres) :
-            if obj.worldOrientation.to_euler().y-ry > rres:
-                obj.applyRotation((0, -rres, 0), Local)
-            if ry-obj.worldOrientation.to_euler().y > rres:
-                obj.applyRotation((0, rres, 0), Local)
-            # print ("delta y ",ry-obj.worldOrientation.to_euler().y)
-
-    # z
-    if rz is not None:
-        while (abs(rz-obj.worldOrientation.to_euler().z) > rres) :
-            if obj.worldOrientation.to_euler().z-rz > rres:
-                obj.applyRotation((0, 0, -rres), Local)
-            if rz-obj.worldOrientation.to_euler().z > rres:
-                obj.applyRotation((0, 0, rres), Local)
-            # print ("delta z ",rz-obj.worldOrientation.to_euler().z)
-
 # Lecture du capteur IMU
 def  capteur(cont):
     obj = cont.owner # obj est l'objet associé au contrôleur donc 'Plateau'
     obj_bille = scene.objects['Bille']
-    resolution = 0.2
+    echelle = 0.2 # Facteur d'échelle entre la capteur et la 3D
+    ecart=0.001 # Écart maxi sur la rotation
 
     # Touche ESC -> Quitter
     keyboard = bge.logic.keyboard
@@ -102,22 +63,27 @@ def  capteur(cont):
     # 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']:
-            obj_bille.worldLinearVelocity=(0, 0, 0)
+            depart()
-            obj_bille.worldAngularVelocity=(0, 0, 0)
+            # obj_bille.worldLinearVelocity=(0, 0, 0)
-            obj_bille.worldPosition.x = obj_bille['init_x']
+            # obj_bille.worldAngularVelocity=(0, 0, 0)
-            obj_bille.worldPosition.y = obj_bille['init_y']
+            # obj_bille.worldPosition.x = obj_bille['init_x']
-            obj_bille.worldPosition.z = obj_bille['init_z']+0.5 # On repose la bille
+            # obj_bille.worldPosition.y = obj_bille['init_y']
-            obj_bille['victoire']=False
+            # obj_bille.worldPosition.z = obj_bille['init_z']+0.5 # On repose la bille
-            obj_bille['chute'] = False
+            # obj_bille['victoire']=False
+            # obj_bille['chute'] = False
 
     # Roll et Pitch
     if serial_msg_in.find(",")>0:
         txt = serial_msg_in.split(',',2)
         x_txt = txt[0][2:]
         y_txt = txt[1][:-5]
-        x=-(float(x_txt)/57.3) * resolution # 1/ 360 / (2 * pi) 
+        if x_txt != " NAN" and y_txt != " NAN": # NAN : Not A Number
-        y=-(float(y_txt)/57.3)  * resolution # 1/ 360 / (2 * pi)
+            x=-(float(x_txt)/57.3) * echelle # 1/ 360 / (2 * pi) 
-        applyRotationTo(scene.objects['Plateau'], x,y, 0)
+            y=-(float(y_txt)/57.3)  * echelle # 1/ 360 / (2 * pi)
+            while abs(x-obj.worldOrientation.to_euler().x) > ecart :
+                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
@@ -156,8 +122,8 @@ def  init(cont):
     obj['init_z']=obj.worldPosition.z
 
     # Afficher image de début (flèches) sur la matrice de leds
-    serial_msg_out = "90\n"
+    # serial_msg_out = "90\n"
-    serial_comm.write(serial_msg_out.encode())
+    # 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)
@@ -168,10 +134,9 @@ 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['vitesse z']=obj.worldLinearVelocity.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 : 3-labyrinthe-imu.ino
+    # Ecriture de la position de la bille sur la liaison série : programme Arduino : 4-labyrinthe-imu.ino
-    if serial_matrix_led and obj['victoire']==False and obj['chute']==False:
+    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
         obj['Lx']=-1*round(obj.worldPosition.x-3.5)  # de 7 à 0
@@ -192,6 +157,17 @@ def  cycle(cont):
         serial_comm.write(serial_msg_out.encode())
         obj['chute'] = True
 
+# Départ de la bille
+def  depart():
+    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):
 
@@ -231,6 +207,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
-        serial_msg_out = "90\n" # Afficher image de début (flèches) sur la matrice de leds
+        depart()
-        serial_comm.write(serial_msg_out.encode())
+        # 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-imu/4-labyrinthe-imu.ino

@@ -4,7 +4,7 @@
 /******************************************************************************
  * 4-labyrinthe-imu.ino
  * @title: Programme pour la carte Arduino de gestion de centrale inertielle (capteur IMU)
- * @project: Blender-EduTech - Tutoriel 3 : Labyrinthe à bille - Interfacer avec une carte Arduino par la liaision série
+ * @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 

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

@@ -4,7 +4,7 @@ import serial # Liaison série
 ###############################################################################
 # 4-labyrinthe.py
 # @title: Module (unique) de la scène 3D du labyrinthe à bille pilotable avec une centrale inertielle (capteur IMU)
-# @project: Blender-EduTech - Tutoriel 3 : Labyrinthe à bille - Interfacer avec une carte Arduino par la liaision série
+# @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