Tutoriels 5 : version intermédiaire

labyrinthe/4-arduino_pyserial/4-labyrinthe.py

@@ -37,6 +37,8 @@ if serial_comm is None:
 
 ###############################################################################
 # Gestion de la centrale inertielle (capteur IMU (inertial measurement unit))
+# Les valeurs du capteur sont transmises en degré.
+# Les valeurs de l'inclinaison du plateau dans UPBGE sont à fournir en radian.
 ###############################################################################
 
 # Lecture du capteur IMU
@@ -66,8 +68,8 @@ def  capteur(cont):
         x_txt = txt[0][2:]
         y_txt = txt[1][:-5]
         if x_txt != " NAN" and y_txt != " NAN": # NAN : Not A Number
-            x=-(float(x_txt)/57.3) * echelle # 1/ 360 / (2 * pi) 
+            x=-(float(x_txt)/57.3) * echelle # 57,3 = 360 / (2 * pi)
-            y=-(float(y_txt)/57.3)  * echelle # 1/ 360 / (2 * pi)
+            y=-(float(y_txt)/57.3)  * echelle # 57,3 = 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 :

labyrinthe/5-microbit/5-labyrinthe-microbit-1.py

@@ -0,0 +1,57 @@
+from microbit import uart, sleep
+from microbit import *
+
+###############################################################################
+# 5-labyrinthe-microbit.py
+# @title: Programme pour la carte micro:bit de gestion de la centrale inertielle
+# @project: Blender-EduTech - Tutoriel 5 : Labyrinthe à bille - Interfacer avec une carte micro:bit
+# @lang: fr
+# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
+# @copyright: Copyright (C) 2023 Philippe Roy
+# @license: GNU GPL
+#
+# Commandes declenchees par UPBGE pour le scene du labyrinthe
+#
+###############################################################################
+
+###############################################################################
+# Initialisation
+###############################################################################
+
+attente_image = Image("00000:00000:00900:00000:00000")
+display.show(attente_image)  # Témoin de fonctionnement
+
+uart.init(baudrate= 115200) # Initialisation du port série
+
+# ###############################################################################
+# Boucle principale
+# ###############################################################################
+
+while True:
+    accel_x=accelerometer.get_x()
+    accel_y=accelerometer.get_y()
+    uart.write(str(accel_x)+","+str(accel_y)+"\n")        
+    
+    # Affichage de la l'inclinaison
+    if accel_x < -30: # Ouest
+        if accel_y <-30:
+            display.show(Image.ARROW_NW)
+        elif accel_y >30:
+            display.show(Image.ARROW_SW)
+        else:
+            display.show(Image.ARROW_W)
+    elif accel_x > 30: # Est
+        if accel_y <-30:
+            display.show(Image.ARROW_NE)
+        elif accel_y >30:
+            display.show(Image.ARROW_SE)
+        else:
+            display.show(Image.ARROW_E)
+    else: # Nord ou Sud
+        if accel_y < -30 :
+            display.show(Image.ARROW_N)
+        elif accel_y > 30 :
+            display.show(Image.ARROW_S)
+        else: # Au centre
+            display.show(attente_image)
+    sleep(100)

labyrinthe/5-microbit/5-labyrinthe-microbit.py

@@ -1,3 +1,4 @@
+from microbit import uart, sleep
 from microbit import *
 
 ###############################################################################
@@ -9,16 +10,48 @@ from microbit import *
 # @copyright: Copyright (C) 2023 Philippe Roy
 # @license: GNU GPL
 #
-# Commandes déclenchées par UPBGE pour le scène du labyrinthe
+# Commandes declenchees par UPBGE pour le scene du labyrinthe
 #
 ###############################################################################
 
+###############################################################################
+# Initialisation
+###############################################################################
+
+attente_image = Image("00000:00000:00900:00000:00000")
+display.show(attente_image)  # Témoin de fonctionnement
+
+uart.init(baudrate= 115200) # Initialisation du port série
+
+# ###############################################################################
+# Boucle principale
+# ###############################################################################
+
 while True:
     accel_x=accelerometer.get_x()
-    if accel_x < -30 :
+    accel_y=accelerometer.get_y()
-        display.show(Image.ARROW_W)
+    uart.write(str(accel_x)+","+str(accel_y)+"\n")        
-    if accel_x > 30 :
+    
-        display.show(Image.ARROW_E)
+    # Affichage de la l'inclinaison
-    if accel_x > -30 and accel_x < 30 :
+    if accel_x < -30: # Ouest
-        display.show(Image.YES)
+        if accel_y <-30:
+            display.show(Image.ARROW_NW)
+        elif accel_y >30:
+            display.show(Image.ARROW_SW)
+        else:
+            display.show(Image.ARROW_W)
+    elif accel_x > 30: # Est
+        if accel_y <-30:
+            display.show(Image.ARROW_NE)
+        elif accel_y >30:
+            display.show(Image.ARROW_SE)
+        else:
+            display.show(Image.ARROW_E)
+    else: # Nord ou Sud
+        if accel_y < -30 :
+            display.show(Image.ARROW_N)
+        elif accel_y > 30 :
+            display.show(Image.ARROW_S)
+        else: # Au centre
+            display.show(attente_image)
     sleep(100)

labyrinthe/5-microbit/5-labyrinthe.py

@@ -36,7 +36,9 @@ if serial_comm is None:
     bge.logic.endGame()
 
 ###############################################################################
-# Gestion de la centrale inertielle (capteur IMU (inertial measurement unit))
+# Gestion de la centrale inertielle de la carte micro:bit
+# Les valeurs du capteur sont transmises de 0 à 1024 (10 bits) où 1024 -> 90°.
+# Les valeurs de l'inclinaison du plateau dans UPBGE sont à fournir en radian.
 ###############################################################################
 
 # Lecture du capteur IMU
@@ -55,19 +57,20 @@ def  capteur(cont):
     # Lecture de la liaison série : programme Arduino : 4-labyrinthe-imu.ino
     serial_msg_in = str(serial_comm.readline())
 
-    # Mettre la bille à la position de départ avec une vitesse nulle
+    # # Mettre la bille à la position de départ avec une vitesse nulle
-    if serial_msg_in.find("start")>0:
+    # if serial_msg_in.find("start")>0:
-        if obj_bille['victoire'] or obj_bille['chute']:
+    #     if obj_bille['victoire'] or obj_bille['chute']:
-            depart()
+    #         depart()
 
     # Roll et Pitch
     if serial_msg_in.find(",")>0:
         txt = serial_msg_in.split(',',2)
-        x_txt = txt[0][2:]
+        y_txt = txt[0][2:]
-        y_txt = txt[1][:-5]
+        x_txt = txt[1][:-3]
-        if x_txt != " NAN" and y_txt != " NAN": # NAN : Not A Number
+        # print (serial_msg_in, ":", x_txt,y_txt)
-            x=-(float(x_txt)/57.3) * echelle # 1/ 360 / (2 * pi) 
+        if x_txt != "" and y_txt != "": # Absence de valeur
-            y=-(float(y_txt)/57.3)  * echelle # 1/ 360 / (2 * pi)
+            x=(float(x_txt)/651.8) * echelle # 651.8 = 1024 / (pi/2)
+            y=(float(y_txt)/651.8)  * echelle # 651.8 = 1024 / (pi/2)
             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 :
@@ -96,26 +99,31 @@ 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
 
-    # Écriture 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:
+    # if obj['victoire']==False and obj['chute']==False:
-        # obj['x'] = obj.worldPosition.x # de -3.5 à 3.5
+    #     # obj['x'] = obj.worldPosition.x # de -3.5 à 3.5
-        # obj['y'] = obj.worldPosition.y # 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
+    #     obj['Lx']=-1*round(obj.worldPosition.x-3.5)  # de 7 à 0
-        if obj['Lx']<0: obj['Lx']=0 
+    #     if obj['Lx']<0: obj['Lx']=0 
-        if obj['Lx']>7: obj['Lx']=7
+    #     if obj['Lx']>7: obj['Lx']=7
-        obj['Ly']=-1*round(obj.worldPosition.y-3.5) # de 0 à 7
+    #     obj['Ly']=-1*round(obj.worldPosition.y-3.5) # de 0 à 7
-        if obj['Ly']<0: obj['Ly']=0
+    #     if obj['Ly']<0: obj['Ly']=0
-        if obj['Ly']>7:  obj['Ly']=7
+    #     if obj['Ly']>7:  obj['Ly']=7
-        serial_msg_out = str(obj['Lx'])+str(obj['Ly'])+"\n"
+    #     serial_msg_out = str(obj['Lx'])+str(obj['Ly'])+"\n"
-        serial_comm.write(serial_msg_out.encode())
+    #     serial_comm.write(serial_msg_out.encode())
 
     # Si l'altitude de bille < -10 et pas de victoire -> chute
-    if obj['z'] < -10 and obj['victoire'] == False :
+    if obj['z'] < -10 and obj['victoire'] == False:
+        print ("Chuuuu.....te")
+        depart() # Replacer la bille au départ
 
-        # Afficher image de chute sur la matrice de leds
+    # # Si l'altitude de bille < -10 et pas de victoire -> chute
-        serial_msg_out = "91\n"
+    # if obj['z'] < -10 and obj['victoire'] == False :
-        serial_comm.write(serial_msg_out.encode())
+
-        obj['chute'] = True
+        # # Afficher image de chute sur la matrice de leds
+        # serial_msg_out = "91\n"
+        # serial_comm.write(serial_msg_out.encode())
+        # obj['chute'] = True
 
 # Départ de la bille
 def  depart():
@@ -138,9 +146,9 @@ def  depart():
 # Victoire (collision de la bille avec l'arrivée)
 def victoire(cont):
 
-    # Afficher image de victoire sur la matrice de leds
+    # # Afficher image de victoire sur la matrice de leds
-    serial_msg_out = "92\n"
+    # serial_msg_out = "92\n"
-    serial_comm.write(serial_msg_out.encode())
+    # serial_comm.write(serial_msg_out.encode())
     scene.objects['Bille']['victoire']=True
 
     # Animation du Panneau victoire