mirror of
https://forge.apps.education.fr/blender-edutech/blender-edutech-tutoriels.git
synced 2024-01-27 09:42:33 +01:00
Tutoriel 3 : capteur imu
This commit is contained in:
parent
ededfd27b4
commit
87eb5d1c78
Binary file not shown.
@ -1,9 +1,11 @@
|
||||
import bge # Bibliothèque Blender Game Engine (BGE)
|
||||
import pyfirmata # Protocole Firmata
|
||||
import bpy # Blender
|
||||
import serial # Liaison série
|
||||
import time
|
||||
|
||||
###############################################################################
|
||||
# 3-labyrinthe-manette.py
|
||||
# @title: Module (unique) de la scène 3D du labyrinthe à bille pilotable avec la manette
|
||||
# 3-labyrinthe-imu.py
|
||||
# @title: Module (unique) de la scène 3D du labyrinthe à bille pilotable avec une centrale inertielle (capteur IMU)
|
||||
# @project: Blender-EduTech - Tutoriel : Tutoriel 3 Labyrinthe à bille - Interfacer avec une carte Arduino
|
||||
# @lang: fr
|
||||
# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
|
||||
@ -16,6 +18,8 @@ import pyfirmata # Protocole Firmata
|
||||
|
||||
# Récupérer la scène 3D
|
||||
scene = bge.logic.getCurrentScene()
|
||||
eevee = bpy.context.scene.eevee
|
||||
fps_time=0.0
|
||||
# print("Objets de la scene : ", scene.objects) # Lister les objets de la scène
|
||||
|
||||
# Constantes
|
||||
@ -28,77 +32,107 @@ 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")
|
||||
|
||||
# Iterateur pour les entrees
|
||||
it = pyfirmata.util.Iterator(carte)
|
||||
it.start()
|
||||
|
||||
# Definition des 4 boutons
|
||||
bt_haut = carte.get_pin('d:2:i')
|
||||
bt_bas = carte.get_pin('d:3:i')
|
||||
bt_gauche = carte.get_pin('d:4:i')
|
||||
bt_droit = carte.get_pin('d:5:i')
|
||||
|
||||
# led = carte.get_pin('d:13:o')
|
||||
# serial_baud=500000
|
||||
serial_baud=115200 # 7 fps
|
||||
# serial_baud=38400 # 6 fps
|
||||
# serial_baud=9600 # 2 fps
|
||||
# serial_comm = serial.Serial('COM4',serial_baud) # Windows
|
||||
serial_comm = serial.Serial('/dev/ttyACM0',serial_baud) # GNU/Linux
|
||||
print (serial_comm)
|
||||
|
||||
###############################################################################
|
||||
# Gestion de la manette Arduino
|
||||
# Gestion de la centrale inertielle (capteur IMU (inertial measurement unit))
|
||||
###############################################################################
|
||||
|
||||
def manette(cont):
|
||||
# Extraction d'un texte compris entre deux bornes textuelles
|
||||
def txt_extrac(txt, borne_avant, borne_apres):
|
||||
# print ("find sur (", txt ,") avec (",borne_avant,") -> ", txt.find(borne_avant))
|
||||
# print ("find sur (", txt ,") avec (",borne_apres,") -> ", txt.find(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 # resolution 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)
|
||||
|
||||
|
||||
def capteur(cont):
|
||||
# global fps_time
|
||||
obj = cont.owner # obj est l'objet associé au contrôleur donc 'Plateau'
|
||||
resolution = 0.01
|
||||
|
||||
# Bouton haut - Broche 2
|
||||
if bt_haut.read() == True and bt_bas.read() == False:
|
||||
obj.applyRotation((-resolution,0,0), False)
|
||||
|
||||
# Bouton bas - Broche 3
|
||||
if bt_haut.read() == False and bt_bas.read() == True:
|
||||
obj.applyRotation((+resolution,0,0), False)
|
||||
|
||||
# Bouton gauche - Broche 4
|
||||
if bt_gauche.read() == True and bt_droit.read() == False:
|
||||
obj.applyRotation((0, -resolution,0), False)
|
||||
|
||||
# Bouton droit - Broche 5
|
||||
if bt_gauche.read() == False and bt_droit.read() == True :
|
||||
obj.applyRotation((0, resolution,0), False)
|
||||
|
||||
###############################################################################
|
||||
# Gestion du clavier
|
||||
###############################################################################
|
||||
|
||||
# Flèches pour tourner le plateau
|
||||
def clavier(cont):
|
||||
obj = cont.owner # obj est l'objet associé au contrôleur donc 'Plateau'
|
||||
# obj = scene.objects['Plateau']
|
||||
keyboard = bge.logic.keyboard
|
||||
resolution = 0.01
|
||||
resolution = 0.2
|
||||
|
||||
# Touche ESC -> Quitter
|
||||
keyboard = bge.logic.keyboard
|
||||
if keyboard.inputs[bge.events.ESCKEY].status[0] == ACTIVATE:
|
||||
carte.exit()
|
||||
serial_comm.close()
|
||||
bge.logic.endGame()
|
||||
|
||||
# Flèche haut - Up arrow
|
||||
if keyboard.inputs[bge.events.UPARROWKEY].status[0] == ACTIVATE:
|
||||
obj.applyRotation((-resolution,0,0), False)
|
||||
# # Gestion du FPS - Tous les tics
|
||||
# milliseconds = int(time.time() * 1000) # Tous les tics
|
||||
# if milliseconds != fps_time:
|
||||
# fps = int(1000/(milliseconds-fps_time))
|
||||
# else:
|
||||
# fps = "----"
|
||||
# # print ("Durée entre deux tics (16 ms), fps (60) :", milliseconds-fps_time, fps)
|
||||
# fps_time = milliseconds
|
||||
|
||||
# Flèche bas - Down arrow
|
||||
if keyboard.inputs[bge.events.DOWNARROWKEY].status[0] == ACTIVATE:
|
||||
obj.applyRotation((resolution,0,0), False)
|
||||
# Désactivation du capteur pendant la chute
|
||||
if scene.objects['Bille']['chute']:
|
||||
return
|
||||
# else:
|
||||
# return
|
||||
|
||||
# Flèche gauche - Left arrow
|
||||
if keyboard.inputs[bge.events.LEFTARROWKEY].status[0] == ACTIVATE:
|
||||
obj.applyRotation((0, -resolution,0), False)
|
||||
# Lecture de la liaison série : programme Arduino : 3-labyrinthe-imu.ino
|
||||
serial_msg = str(serial_comm.readline()) # Communication série : Arduino -> UPBGE
|
||||
txt = serial_msg.split(',',2)
|
||||
# print (txt)
|
||||
x_txt = txt[0][2:]
|
||||
y_txt = txt[1][:-5]
|
||||
# print (x_txt, y_txt)
|
||||
# obj['IMU x']=-float(x_txt)
|
||||
# obj['IMU y']=-float(y_txt)
|
||||
# obj['Rx']=obj.worldOrientation.to_euler().x*57.3 # 360 / (2 * pi)
|
||||
# obj['Ry']=obj.worldOrientation.to_euler().y*57.3 # 360 / (2 * pi)
|
||||
# obj['Rz']=obj.worldOrientation.to_euler().z*57.3 # 360 / (2 * pi)
|
||||
|
||||
# Flèche droit - Right arrow
|
||||
if keyboard.inputs[bge.events.RIGHTARROWKEY].status[0] == ACTIVATE:
|
||||
obj.applyRotation((0, resolution,0), False)
|
||||
x=-(float(x_txt)/57.3) * resolution # 1/ 360 / (2 * pi)
|
||||
y=-(float(y_txt)/57.3) * resolution # 1/ 360 / (2 * pi)
|
||||
|
||||
# Roll et Pitch
|
||||
# applyRotationTo(scene.objects['Plateau'], x,0, 0)
|
||||
applyRotationTo(scene.objects['Plateau'], x,y, 0)
|
||||
# obj.applyRotation((0,0,-obj.worldOrientation.to_euler().z), False)
|
||||
|
||||
###############################################################################
|
||||
# Gameplay
|
||||
@ -107,6 +141,7 @@ def clavier(cont):
|
||||
# Initialisation de la scène
|
||||
def init(cont):
|
||||
obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
|
||||
eevee_qualite(0)
|
||||
|
||||
# Mémorisation de la position de départ de la bille
|
||||
obj['init_x']=obj.worldPosition.x
|
||||
@ -122,13 +157,17 @@ 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
|
||||
obj['vitesse z']=obj.worldLinearVelocity.z # la propriété z est mis à jour avec la position globale en z de la bille
|
||||
|
||||
# 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:
|
||||
# Chute ?
|
||||
if obj['z'] < -10 and scene.objects['Panneau victoire'].visible == False:
|
||||
obj['chute']=True
|
||||
scene.objects['Plateau']['chute']=True
|
||||
|
||||
# Redémarrer la partie
|
||||
def chute(cont):
|
||||
obj = cont.owner # obj est l'objet associé au contrôleur donc 'Bille'
|
||||
obj_plateau = scene.objects['Plateau'] # obj_plateau est l'objet 'Plateau'
|
||||
print ("Chuuuu.....te")
|
||||
|
||||
# Replacement du plateau (tous les angles à 0 en plusieurs fois)
|
||||
@ -141,6 +180,8 @@ def cycle(cont):
|
||||
obj.worldPosition.x = obj['init_x']
|
||||
obj.worldPosition.y = obj['init_y']
|
||||
obj.worldPosition.z = obj['init_z']+0.5 # On repose la bille
|
||||
time.sleep(0.1)
|
||||
obj['chute']=False
|
||||
|
||||
# Victoire (colision de la bille avec l'arrivée)
|
||||
def victoire(cont):
|
||||
@ -176,6 +217,84 @@ def victoire_fermer(cont):
|
||||
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
|
||||
|
||||
###############################################################################
|
||||
# Qualité du rendu EEVEE de 0 à 4
|
||||
###############################################################################
|
||||
|
||||
def eevee_qualite(qualite):
|
||||
|
||||
# Inconvenant
|
||||
if qualite== 0:
|
||||
eevee.use_eevee_smaa = False # Subpixel Morphological Antialiasing
|
||||
eevee.use_ssr = False # Screen space reflection
|
||||
eevee.use_gtao = False # Ambient occlusion
|
||||
eevee.taa_render_samples = 1
|
||||
eevee.taa_samples = 1
|
||||
eevee.use_volumetric_lights = False
|
||||
eevee.use_volumetric_shadows = False
|
||||
eevee.shadow_cascade_size='64'
|
||||
eevee.shadow_cube_size='64'
|
||||
|
||||
# Basse
|
||||
if qualite== 1:
|
||||
eevee.use_eevee_smaa = True
|
||||
eevee.smaa_quality= 'LOW'
|
||||
eevee.use_ssr = True # Screen space reflection
|
||||
eevee.use_ssr_refraction = False # Screen space refractions
|
||||
eevee.use_ssr_halfres = True
|
||||
eevee.use_gtao = False
|
||||
eevee.taa_render_samples = 32
|
||||
eevee.taa_samples = 8
|
||||
eevee.use_volumetric_lights = True
|
||||
eevee.use_volumetric_shadows = False
|
||||
eevee.shadow_cascade_size='1024'
|
||||
eevee.shadow_cube_size='512'
|
||||
|
||||
# Moyenne
|
||||
if qualite== 2:
|
||||
eevee.use_eevee_smaa = True
|
||||
eevee.smaa_quality= 'MEDIUM'
|
||||
eevee.use_ssr = True # Screen space reflection
|
||||
eevee.use_ssr_refraction = True # Screen space refractions
|
||||
eevee.use_ssr_halfres = True
|
||||
eevee.use_gtao = False
|
||||
eevee.taa_render_samples = 64
|
||||
eevee.taa_samples = 16
|
||||
eevee.use_volumetric_lights = True
|
||||
eevee.use_volumetric_shadows = False
|
||||
eevee.shadow_cascade_size='1024'
|
||||
eevee.shadow_cube_size='512'
|
||||
|
||||
# Haute
|
||||
if qualite== 3:
|
||||
eevee.use_eevee_smaa = True
|
||||
eevee.smaa_quality= 'HIGH'
|
||||
eevee.use_ssr = True
|
||||
eevee.use_ssr_refraction = True
|
||||
eevee.use_ssr_halfres = False
|
||||
eevee.use_gtao = False
|
||||
eevee.taa_render_samples = 64
|
||||
eevee.taa_samples = 16
|
||||
eevee.use_volumetric_lights = True
|
||||
eevee.use_volumetric_shadows = False
|
||||
eevee.shadow_cascade_size='1024'
|
||||
eevee.shadow_cube_size='512'
|
||||
|
||||
# Épique
|
||||
if qualite== 4:
|
||||
eevee.use_eevee_smaa = True
|
||||
eevee.smaa_quality= 'ULTRA'
|
||||
eevee.use_ssr = True
|
||||
eevee.use_ssr_refraction = True
|
||||
eevee.use_ssr_halfres = False
|
||||
eevee.use_gtao = True
|
||||
eevee.taa_render_samples = 64
|
||||
eevee.taa_samples = 16
|
||||
eevee.use_volumetric_lights = True
|
||||
eevee.use_volumetric_shadows = True
|
||||
eevee.shadow_cascade_size='4096'
|
||||
eevee.shadow_cube_size='4096'
|
||||
|
||||
###############################################################################
|
||||
# Gestion du Joystick USB
|
||||
###############################################################################
|
||||
|
||||
@ -62,8 +62,8 @@ void setup() {
|
||||
|
||||
// Moniteur serie
|
||||
Serial.begin(115200); // 7 fps
|
||||
/* Serial.begin(38400); */ // 6 fps
|
||||
/* Serial.begin(9600); */ // trop lent 2fps
|
||||
// Serial.begin(9600); // trop lent 2fps
|
||||
//Serial.begin(500000);
|
||||
|
||||
// I2C
|
||||
Wire.begin();
|
||||
|
||||
Loading…
Reference in New Issue
Block a user