Portail coulissant : commande moteur par le shield

portail_coulissant/porcou.py

@@ -2,6 +2,7 @@ import bge # Bibliothèque Blender Game Engine (UPBGE)
 import twin # Bibliothèque de l'environnement 3D des jumeaux numériques
 import math
 import time
+import runpy # Exécution de script Python légère (sans import)
 
 ###############################################################################
 # porcou.py
@@ -9,7 +10,7 @@ import time
 # @project: Blender-EduTech
 # @lang: fr
 # @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
-# @copyright: Copyright (C) 2020-2023 Philippe Roy
+# @copyright: Copyright (C) 2020-2024 Philippe Roy
 # @license: GNU GPL
 ###############################################################################
 
@@ -26,6 +27,9 @@ scene = bge.logic.getCurrentScene()
 #  'nom_variable_r' est la valeur réelle de la variable (valeur numérique) 'nom_variable' issue du jumelage numérique.
 #  Dans ce cas, il n'y a pas configuration de broche car elle est présente sur la variable 'nom_variable'.
 #  Ce distinguo ne concerne que les entrées, car les sorties sont pilotées par le numérique.
+#
+# 'mot_s' et 'mot_v' ne concernent que la maquette Grove (variante 1, par défaut)
+# 'mot_o' et 'mot_f' ne concernent que la maquette AutoProg (variante 2)
 
 public_vars = {
     't' : [['System','time','a'],[],[]],
@@ -39,6 +43,8 @@ public_vars = {
     'fdc_f_r' : [['Microrupteur fdc ferme','activated_real','d'],[],['.','--','darkorange',1]],
     'mot_o' : [['Moteur','open','d'],['pin_open','d','o'],['.','-','violet',1]],
     'mot_f' : [['Moteur','close','d'],['pin_close','d','o'],['.','-','darkviolet',1]],
+    'mot_s' : [['Moteur','direction','d'],['pin_direction','d','o'],['.','-','blue',1]],
+    'mot_v' : [['Moteur','speed_real','a'],['pin_speed','p','o'],['.','-','darkblue',1]],
     'mot_angle' : [['Moteur','alpha','a'],[],['.','-','blue',1]],
     'mot_vitesse' : [['Moteur','speed','a'],[],['.','-','darkblue',1]],
     'mot_pas' : [['Moteur','step','a'],[],[]],
@@ -116,6 +122,14 @@ def get_public_vars():
 # Actionneurs
 ###############################################################################
 
+# Pour la commande du moteur de la variante 1 version Grove , le brochage du  shield moteur CC 4 x 1,2 A DRI0039 (DFROBOT) est fixe,
+# il doit respecter le tableau suivant : 
+# Motor # Direction pin (Forward/Backward) # Speed pin # Speed range (PWM)
+# M1 	  #    4 	LOW 	HIGH 	                                    #   3                   # 0-255
+# M2 	  #  12 	HIGH 	LOW 	                                    # 11 	                # 0-255
+# M3      #    8 	LOW 	HIGH 	                                   #   5                    # 0-255
+# M4	   #   7 	HIGH 	LOW 	                                    #   6 	                # 0-255
+
 ##
 # Moteur et portail
 ##
@@ -154,10 +168,20 @@ def mot (cont):
            
             # Modele 3D -> Arduino
             if scene.objects['System']['twins'] and obj['prior_real']:
-                if  scene.objects['Moteur']['pin_open'] is not None :
+
-                    if  scene.objects['Moteur']['pin_close'] is not None:
+                # Version Grove
-                        scene.objects['Moteur']['pin_close'].write(0)
+                if scene.objects['System']['variant'] == 1:
-                        scene.objects['Moteur']['pin_open'].write(1)
+                    if  scene.objects['Moteur']['pin_direction'] is not None:
+                        if  scene.objects['Moteur']['pin_speed'] is not None:
+                            scene.objects['Moteur']['pin_direction'].write(1)
+                            scene.objects['Moteur']['pin_speed'].write(1)
+
+                # Version AutoProg
+                if scene.objects['System']['variant'] == 2:
+                    if  scene.objects['Moteur']['pin_open'] is not None :
+                        if  scene.objects['Moteur']['pin_close'] is not None:
+                            scene.objects['Moteur']['pin_close'].write(0)
+                            scene.objects['Moteur']['pin_open'].write(1)
 
         # Fermer
         # else: # Pas de priorité
@@ -177,10 +201,20 @@ def mot (cont):
 
             # Modele 3D -> Arduino
             if scene.objects['System']['twins'] and obj['prior_real']:
-                if  scene.objects['Moteur']['pin_close'] is not None:
+
-                    if  scene.objects['Moteur']['pin_open'] is not None:
+                # Version Grove
-                        scene.objects['Moteur']['pin_open'].write(0)
+                if scene.objects['System']['variant'] == 1:
-                        scene.objects['Moteur']['pin_close'].write(1)
+                    if  scene.objects['Moteur']['pin_direction'] is not None:
+                        if  scene.objects['Moteur']['pin_speed'] is not None:
+                            scene.objects['Moteur']['pin_direction'].write(0)
+                            scene.objects['Moteur']['pin_speed'].write(1)
+
+                # Version AutoProg
+                if scene.objects['System']['variant'] == 2:
+                    if  scene.objects['Moteur']['pin_close'] is not None:
+                        if  scene.objects['Moteur']['pin_open'] is not None:
+                            scene.objects['Moteur']['pin_open'].write(0)
+                            scene.objects['Moteur']['pin_close'].write(1)
 
         # Arrêrer
         if obj['open']== False and obj['close'] == False and obj['prior']:
@@ -193,10 +227,20 @@ def mot (cont):
 
             # Modele 3D -> Arduino
             if scene.objects['System']['twins'] and obj['prior_real']:
-                if  scene.objects['Moteur']['pin_close'] is not None:
+
-                    if  scene.objects['Moteur']['pin_open'] is not None:
+                # Version Grove
-                        scene.objects['Moteur']['pin_open'].write(0)
+                if scene.objects['System']['variant'] == 1:
-                        scene.objects['Moteur']['pin_close'].write(0)
+                    if  scene.objects['Moteur']['pin_direction'] is not None:
+                        if  scene.objects['Moteur']['pin_speed'] is not None:
+                            scene.objects['Moteur']['pin_direction'].write(0)
+                            scene.objects['Moteur']['pin_speed'].write(0)
+
+                # Version AutoProg
+                if scene.objects['System']['variant'] == 2:
+                    if  scene.objects['Moteur']['pin_close'] is not None:
+                        if  scene.objects['Moteur']['pin_open'] is not None:
+                            scene.objects['Moteur']['pin_open'].write(0)
+                            scene.objects['Moteur']['pin_close'].write(0)
 
 ###############################################################################
 # Capteurs fin de course
@@ -388,6 +432,9 @@ def system_init ():
 
 def system_reset ():
 
+    # Mise en place de la variante
+    runpy.run_path(scene.objects['System']['script'], run_name='init')
+
     # Entrées à l'état initial
     objs= ['Microrupteur fdc ouvert', 'Microrupteur fdc ferme', 'Bp cote cour','Bp cote rue']
     for obj in objs:

portail_coulissant/porcou_cmd.py

@@ -40,78 +40,106 @@ from porcou_lib import * # Bibliothèque utilisateur du portail coulissant
 #
 ###############################################################################
 
+# Brochage du portail coulissant (AutoProgUno)
+# brochage={
+    # 'bp_ext' : ['d',2,'i'],'bp_int' : ['d',3,'i'],
+    # 'fdc_o' : ['d',7,'i'],'fdc_f' : ['d',8,'i'],
+    # 'mot_o' : ['d',5,'o'],'mot_f' : ['d',6,'o'],
+    # 'gyr' : ['d',4,'o'],
+    # 'ir_emet' : ['d',9,'o'],'ir_recep' : ['d',10,'i']}
+    
 # Brochage du portail coulissant (Grove)
 brochage={
     'bp_ext' : ['d',6,'i'],'bp_int' : ['d',5,'i'],
     'fdc_o' : ['a',1,'i'],'fdc_f' : ['a',0,'i'],
-    'mot_o' : ['d',2,'o'],'mot_f' : ['d',3,'o'],
+    'mot_s' : ['d',4,'o'],'mot_v' : ['d',3,'o'],
-    'gyr' : ['d',4,'o'],
+    'gyr' : ['d',2,'o'],
-    'ir_emet' : ['d',8,'o'],'ir_recep' : ['d',7,'i']}
+    'ir_emet' : ['d',7,'o'],'ir_recep' : ['d',8,'i']}
+
+# Motor Direction(Forward/Backward)	Speed Speed range
+# M1 	4 	LOW 	HIGH 	        3 	0-255
+# M2 	12 	HIGH 	LOW 	        11 	0-255
+# M3 	8 	LOW 	HIGH 	        5 	0-255
+# M4	7 	HIGH 	LOW 	        6 	0-255
 
 ###############################################################################
 # Fonctions
 ###############################################################################
 
+# Fermer le portail
+def fermer():
+    print ("Fermeture")
+    ir_emet(True)
+    while fdc_f() ==False:
+        gyr(True)
+        mot_o(False)
+        mot_f(True)
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+        # if ir_recep()==False or bp_int() or bp_ext() : # Ouverture en cas présence d'obstacle ou boutons
+        if bp_int() or bp_ext() : # Ouverture en cas présence d'obstacle ou boutons
+            ouvrir()
+            print ("Temporisation")
+            tempo(2) # Temporisation 2s
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+    gyr(False)
+    mot_f(False)
+    ir_emet(False)
+
+# Ouvrir le portail
+def ouvrir():
+    print ("Ouverture")
+    while fdc_o() ==False:
+        gyr(True)
+        mot_f(False)
+        mot_o(True)
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+    gyr(False)
+    mot_o(False)
+
 ###############################################################################
 # Commandes
 ###############################################################################
 
 def commandes():
 
-    # Mise en place : Fermeture
+    # jumeau(brochage)
-    mot_vitesse (1256)  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
-    print ("Version sans sécurité : sans réouverture")
-    print ("Mise en place : Fermeture")
-    while fdc_f() ==False :
-        gyr(True)
-        mot_o(False)
-        mot_f(True)
-    mot_f(False)
-    gyr(False)
 
-    # Données
+    # while True :    
-    # daq(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
+    #     gyr(True)
-    # plot(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
+    #     tempo(0.1) # Donne du temps à communication avec le jumeau réel
-    # reset_t()
+
-    
+    # Mise en place : Fermeture
-    # daq(['bp_ext', 'bp_ext_r', 'bp_int', 'bp_int_r', 'fdc_o', 'fdc_o_r', 'fdc_f', 'fdc_f_r', 'mot_o', 'mot_f', 'gyr', 'mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse', 'ir_emet', 'ir_recep', 'ir_recep_r'])
+    print ("Version avec sécurité : avec réouverture si bouton ou capteur barrage")
-    # plot([['bp_ext', 'bp_ext_r'], ['bp_int', 'bp_int_r'], ['fdc_o', 'fdc_o_r'], ['fdc_f', 'fdc_f_r'], 'mot_o', 'mot_f', 'gyr', ['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse']])
+    print ("Mise en place : Fermeture")
+    mot_vitesse(1000)
+    fermer()
 
     # Jumelage
-    jumeau(brochage)
+    print ("Attente")
-    # jumeau_mode(True, True, True, True)
+    # jumeau(brochage)
 
     # Fonctionnement normal
-    print ("Attente")
     while True :
         tempo(0.1) # Donne du temps à communication avec le jumeau réel
-        
+
-        # Ouverture
+        # Ouverture 
-        if bp_int() or bp_ext()  :
+        if bp_int() or bp_ext() :
-            print ("Ouverture")
+            ouvrir()
-            while fdc_o() ==False:
-                gyr(True)
-                mot_f(False)
-                mot_o(True)
-                tempo(0.1) # Donne du temps à communication avec le jumeau réel
-            mot_o(False)
 
             print ("Temporisation")
-            tempo(2) # Temporisation
+            tempo(2) # Temporisation 2s
 
             # Fermeture
-            print ("Fermeture")
+            fermer()
-            while fdc_f() ==False:
-                mot_o(False)
-                mot_f(True)
-                tempo(0.1) # Donne du temps à communication avec le jumeau réel
-            gyr(False)
-            mot_f(False)
             print ("Attente")
 
 ###############################################################################
 # En: External call << DONT CHANGE THIS SECTION >>
 # Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+#
+# Variante 1 (par défaut) : version Grove  : la carte moteur est le shield moteur Arduino CC 4 x 1,2 A DRI0039 (DFROBOT)
+# Variante 2 : version AutoProg : la carte moteur est le module AutoProg K-AP-MMOT-KIT
+#
 ###############################################################################
 
 def cycle():
@@ -122,3 +150,5 @@ if __name__=='start':
     start(cycle)
 if __name__=='stop':
     stop()
+if __name__=='init':
+    variant(2) # Variante 1 de la maquette 3D du portail coulissant

portail_coulissant/porcou_doc.py

@@ -1,13 +1,19 @@
+import bge # Bibliothèque Blender Game Engine (UPBGE)
+import runpy # Exécution de script Python légère (sans import)
+
 ###############################################################################
 # porcou_doc.py
 # @title: Documentation du portail coulissant
 # @project: Blender-EduTech
 # @lang: fr
 # @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
-# @copyright: Copyright (C) 2020-2023 Philippe Roy
+# @copyright: Copyright (C) 2020-2024 Philippe Roy
 # @license: GNU GPL
 ###############################################################################
 
+# UPBGE scene
+scene = bge.logic.getCurrentScene()
+
 # Texte en X : 426.474 m
 
 ################################################################################
@@ -33,22 +39,35 @@ system_card_description.update({"twins-card" : [card_twins_title, card_twins_tex
 
 # Brochage
 card_pin_title="Brochage"
-card_pin_text=""" Le brochage est un dictionnaire qui permet \n d'associer les objets 3D du jumeau \n numérique aux broches du jumeau réel, 
+card_pin_text_grove=""" Le brochage est un dictionnaire d'association \n des objets numériques aux broches réelles.
  brochage = { nom:[type, broche, mode] } :
  - nom : nom de l'objet 3D,
  - type : a (analogique) ou d (binaire),
  - broche : numéro de la broche de carte,
  - mode : i (entrée), o (sortie) ou p (pwm).
  Par exemple : brochage = { 'gyr':['d',3,'o'] }.\n
- Les objets numériques du jumeau sont : \n 'bp_ext', 'bp_int', 'fdc_o', 'fdc_f', 'mot_o',\n 'mot_f', 'gyr', 'ir_emet' et 'ir_recep'."""
+ Les objets numériques sont : 'gyr', 'bp_ext', \n 'bp_int', 'fdc_o', 'fdc_f', 'ir_emet' et 'ir_recep'.
+ Pour le moteur (maquette Grove) : 'mot_s' \n (sens, 0 ou 1) et 'mot_v' (vitesse, 0 à 255)."""
+
+card_pin_text_autoprog=""" Le brochage est un dictionnaire d'association \n des objets numériques aux broches réelles.
+ brochage = { nom:[type, broche, mode] } :
+ - nom : nom de l'objet 3D,
+ - type : a (analogique) ou d (binaire),
+ - broche : numéro de la broche de carte,
+ - mode : i (entrée), o (sortie) ou p (pwm).
+ Par exemple : brochage = { 'gyr':['d',3,'o'] }.\n
+ Les objets numériques sont : 'gyr', 'bp_ext', \n 'bp_int', 'fdc_o', 'fdc_f', 'ir_emet' et 'ir_recep'.
+ Pour le moteur (maquette AutoProg) : \n 'mot_o' (ouvrir) et 'mot_f' (fermer) """
+
 card_pin_url=[]
-system_card_description.update({"pin-card" : [card_pin_title, card_pin_text, card_pin_url]})
+system_card_description.update({"pin-card" : [card_pin_title, card_pin_text_grove, card_pin_url, card_pin_text_autoprog]}) # Deux descriptions
 
 # Données
 card_data_title="Accès aux données"
 card_data_text=""" get(variable) \n -> Retourne la valeur de la variable à \n l'instant t. Par exemple : val = get('bp_ext').\n
- Entrées/sorties : 'bp_ext', 'bp_int', 'fdc_o', \n 'fdc_f', 'mot_o', 'mot_f', 'gyr', 'ir_emet', \n 'ir_recep'.\n
+ Entrées/sorties : 'bp_ext', 'bp_int', 'fdc_o', \n 'fdc_f', 'mot_o', 'mot_f', 'gyr', 'ir_emet' et 
- Variables réels (si il y a jumelage) : 'bp_ext_r', \n 'bp_int_r', 'fdc_o_r', 'fdc_f_r', 'ir_recep_r'.\n
+ 'ir_recep'.  Maquette Grove (en +) :  'mot_s' \n (sens, 0 ou 1) et 'mot_v' (vitesse, 0-255). \n
+ Entrées réels (si il y a jumelage) : 'bp_ext_r', \n 'bp_int_r', 'fdc_o_r', 'fdc_f_r', 'ir_recep_r'.
  Autres variables : 't' (temps), 'mot_angle', \n 'mot_vitesse', 'portail_x', 'portail_vitesse'."""
 card_data_url=[]
 system_card_description.update({"data-card" : [card_data_title, card_data_text, card_data_url]})
@@ -68,11 +87,14 @@ system_card_description.update({"daq-card" : [card_daq_title, card_daq_text, car
 
 # Ouvrir et fermer
 card_movement_title="Ouvrir et fermer"
-card_movement_text=""" mot_o(True | False) \n -> Ouvrir le portail (moteur sens trigo).
+card_movement_text=""" mot_o(True | False) -> Ouvrir le portail.
- mot_f(True | False) \n -> Fermer le portail (moteur sens horaire).\n
+ mot_f(True | False) -> Fermer le portail.\n
  fdc_o() \n -> Capteur fin de course portail ouvert.
  fdc_f() \n -> Capteur fin de course portail fermé.\n 
- mot_vitesse(vitesse) -> Change la vitesse \n du moteur numérique en rad/s. Si 'vitesse' \n est ommis, elle sera réinitialisée."""
+ mot_vitesse(vitesse) -> Change la vitesse \n du moteur numérique en rad/s.
+ mot_vitesse_r(vitesse) -> Change la vitesse \n du moteur réel en rad/s (maquette Grove).
+ Si 'vitesse' est ommis, elle sera réinitialisée."""
+
  # fdc_o() \n -> Capteur fin de course portail ouvert.\n Retourne True si le portail est ouvert. \n
  # fdc_f() \n -> Capteur fin de course portail fermé.\n Retourne True si le portail est fermé.\n
 
@@ -101,11 +123,12 @@ system_card_description.update({"board-card" : [card_board_title, card_board_tex
 
 # Maquette
 card_model_title="Maquette"
-card_model_text=""" Le modèle 3D est basé sur la maquette \n développée par l'entreprise A4 \n Technologie. \n 
+card_model_text=""" Le modèle 3D est basé sur la maquette \n développée par l'entreprise A4 \n Technologie. Il existe aussi une maquette \n auto-construite à partir de modules Grove. \n 
- Les documents techniques et \n pédagogiques signés A4 Technologie \n sont diffusés librement sous licence \n Creative Commons BY-NC-SA. \n
+ Tous deux sont diffusées librement sous \n licence Creative Commons BY-NC-SA. \n
  Le pilotage de la maquette se fait par une \n carte Arduino (Uno ou Mega) reliée à \n l'ordinateur via la liaison série (USB) et le \n protocole Firmata."""
-card_model_url=[["A4 Technologie","https://www.a4.fr"],
+card_model_url=[["Maquette A4 Technologie","https://www.a4.fr/wiki/index.php?title=Portail_coulissant_(BE-APORT-COUL)"],
-                ["Maquette A4 Technologie","https://www.a4.fr/wiki/index.php?title=Portail_coulissant_(BE-APORT-COUL)"]]
+                ["Maquette auto-construite","https://forge.aeif.fr/blender-edutech/blender-edutech-modeles3d/-/tree/main/portail_coulissant"],
+                ["Système Grove","https://wiki.seeedstudio.com/Grove_System/"]]
 system_card_description.update({"model-card" : [card_model_title, card_model_text, card_model_url]})
 
 # Firmata
@@ -139,3 +162,15 @@ def get_system_card():
 
 def get_system_card_description():
     return system_card_description
+
+    # # Mise en place de la variante
+    # print ("aa")
+    # print (scene.objects['System']['script'])
+    # print ("bb")
+    # # runpy.run_path(scene.objects['System']['script'], run_name='init')
+    # # if scene.objects['System']['variant'] ==2:
+    # #     system_card_description.update({"pin-card" : [card_pin_title, card_pin_text_autoprog, card_pin_url]})
+    # # else:
+    # #     system_card_description.update({"pin-card" : [card_pin_title, card_pin_text_grove, card_pin_url]})
+    
+    # return system_card_description

portail_coulissant/porcou_lib.py

@@ -3,6 +3,7 @@ import twin_threading # Multithreading (multitâches)
 from twin_serial import jumeau, jumeau_stop, serial_close,  jumeau_mode_system, jumeau_mode_object # Liaison série
 from twin_daq import get, daq, csv_generate, plot, plot_generate # Acquisition des données
 import time
+import importlib
 
 ###############################################################################
 # porcou_lib.py
@@ -10,7 +11,7 @@ import time
 # @project: Blender-EduTech
 # @lang: fr
 # @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
-# @copyright: Copyright (C) 2020-2023 Philippe Roy
+# @copyright: Copyright (C) 2020-2024 Philippe Roy
 # @license: GNU GPL
 ###############################################################################
 
@@ -53,6 +54,10 @@ def mot_f (order):
 def mot_vitesse (speed=125.6):
     scene.objects['Moteur']['speed_setting']=speed # Vitesse du moteur numérique : 125.6 rad /s ( 20 tr / s )
 
+# Réglage de la vitesse du moteur réel : Maquette Grove de 0 à 255
+def mot_vitesse_r (speed):
+    scene.objects['Moteur']['speed_real_setting']=speed # Vitesse du moteur numérique : 125.6 rad /s ( 20 tr / s )
+
 # Ordre pour le capteur barrage IR
 def ir_emet(order):
     scene.objects['Emetteur IR']['active']=order
@@ -138,6 +143,60 @@ def reset_t ():
 def start(fct):
     twin_threading.start(threads_cmd, "commands", fct)
 
+##
+# Variante
+#
+# La variante 1 (par défaut) appelée 'version Grove' : correspond à la maquette auto-construite basée sur des modules Grove
+# La variante 2 appelée 'version AutoProg' : correspond à la maquette de 4A technologie basée sur des modules AutoProg
+#
+# Au niveau de la commande, la différence sur entre les deux variantes est uniquement sur la commande moteur :
+# - variante 1 : la carte moteur est le shield moteur Arduino CC 4 x 1,2 A DRI0039 (DFROBOT)
+# - variante 2 : la carte moteur est le module AutoProg K-AP-MMOT-KIT
+#
+# Configuration des variantes du modèle 3D -> variant_dict : 
+# 'nom de l'objet 3D' : liste des variantes où l'objet est présent. 
+# Les objets hors dictionnaire sont présent quelque soit la variante sélectionnée.
+##
+
+def variant(variant_num):
+    if variant_num != scene.objects['System']['variant']:
+        print ("Variante de la maquette numérique:", variant_num)
+        scene.objects['System']['variant']=variant_num
+    
+        # FIXME : MaJ de la documentation dynamique -> plus tards
+        # if 'Doc_text-l1-pin-card' in scene.objects:
+        #     card_description ={}
+        #     system=importlib.import_module(scene.objects['System']['system']+'_doc') # Système
+        #     card_description.update(system.get_system_card_description())
+        #     if variant_num == 1 : # Grove (par défaut)
+        #         lines = card_description["pin-card"][1].split("\n")
+        #     if variant_num == 2 : # Autoprog (par défaut)
+        #         lines = card_description["pin-card"][3].split("\n")
+
+        #     print (lines)
+        #     print (scene.objects)
+
+        #     for i in range (13):
+        #         if i >= len(lines):
+        #             scene.objects['Doc_text-l'+str(i+1)+'-pin-card']['Text']=""
+        #         else:
+        #             if len(lines[i]) ==0:
+        #                 scene.objects['Doc_text-l'+str(i+1)+'-pin-card']['Text']=""
+        #             else:
+        #                 scene.objects['Doc_text-l'+str(i+1)+'-pin-card'].blenderObject.data.body=lines[i] # Bug de la propriétés 'Text' (UPBGE) -> passage par 'body' de bpy (Blender)
+
+
+    # FIXME : Affichage de la maquette  Grove -> plus tards
+    # variant_dict = {'Bp auto':[1], 'Bg auto':[2], 'Bg auto-on':[2]}
+    # variant_list = list(variant_dict)
+    # for name in variant_list:
+    #     if variant_num in variant_dict[name]:
+    #         scene.objects[name].setVisible(True,True)
+    #         scene.objects[name].restorePhysics()
+    #     else:
+    #         scene.objects[name].setVisible(False,True)
+    #         scene.objects[name].suspendPhysics()
+
 ##
 # Arrêt
 ##

twin.py

@@ -151,12 +151,6 @@ def cmd_init():
     scene.objects['Script-text']['Text']=scene.objects['System']['script']
     scene.objects['Twins-text']['Text']="Connection fermée."
 
-    # Mise en place de la variante
-    # scene.objects['System']['variant'] = int(twin_config[0][2].text)
-    # scene.active_camera = scene.objects["Camera"]
-    # scene.objects['Sun'].setVisible(True,True)
-    # scene.addOverlayCollection(scene.cameras['Camera-Hud'], bpy.data.collections['Hud'])
-
     # Windows
     windows=("Doc", "Doc_chap-general", "Doc_chap-system", "Doc_chap-python", "About", "Credits")
     for window in windows:

twin_config.xml

@@ -2,7 +2,7 @@
     <screen>
 	<width>1609</width>
 	<height>905</height>
-	<quality>4</quality>
+	<quality>0</quality>
     </screen>
     <plot>
 	<config>True</config>

volet_roulant/volrou_cmd-bak.py

@@ -58,6 +58,10 @@ def commandes():
 ###############################################################################
 # En: External call << DONT CHANGE THIS SECTION >>
 # Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+#
+# Variante 1 : Le mode automatique s'active avec le bouton poussoir bp_auto et se désactive avec l'appui sur bp_m, bp_a ou bp_d.
+# Variante 2 : Le mode automatique s'active et se désactive avec le bouton à glissière bg_auto.
+#
 ###############################################################################
 
 def cycle():
@@ -68,3 +72,5 @@ if __name__=='start':
     start(cycle)
 if __name__=='stop':
     stop()
+if __name__=='init':
+    variant(1) # Variante 1 de la maquette 3D du volet roulant

volet_roulant/volrou_cmd-grove.py

@@ -140,6 +140,10 @@ def commandes():
 ###############################################################################
 # En: External call << DONT CHANGE THIS SECTION >>
 # Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+#
+# Variante 1 : Le mode automatique s'active avec le bouton poussoir bp_auto et se désactive avec l'appui sur bp_m, bp_a ou bp_d.
+# Variante 2 : Le mode automatique s'active et se désactive avec le bouton à glissière bg_auto.
+#
 ###############################################################################
 
 def cycle():
@@ -150,3 +154,5 @@ if __name__=='start':
     start(cycle)
 if __name__=='stop':
     stop()
+if __name__=='init':
+    variant(1) # Variante 1 de la maquette 3D du volet roulant

volet_roulant/volrou_cmd-test.py

@@ -103,6 +103,10 @@ def commandes():
 ###############################################################################
 # En: External call << DONT CHANGE THIS SECTION >>
 # Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+#
+# Variante 1 : Le mode automatique s'active avec le bouton poussoir bp_auto et se désactive avec l'appui sur bp_m, bp_a ou bp_d.
+# Variante 2 : Le mode automatique s'active et se désactive avec le bouton à glissière bg_auto.
+#
 ###############################################################################
 
 def cycle():
@@ -113,3 +117,5 @@ if __name__=='start':
     start(cycle)
 if __name__=='stop':
     stop()
+if __name__=='init':
+    variant(1) # Variante 1 de la maquette 3D du volet roulant

volet_roulant/volrou_cmd.py

@@ -140,6 +140,10 @@ def commandes():
 ###############################################################################
 # En: External call << DONT CHANGE THIS SECTION >>
 # Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+#
+# Variante 1 : Le mode automatique s'active avec le bouton poussoir bp_auto et se désactive avec l'appui sur bp_m, bp_a ou bp_d.
+# Variante 2 : Le mode automatique s'active et se désactive avec le bouton à glissière bg_auto.
+#
 ###############################################################################
 
 def cycle():
@@ -150,3 +154,5 @@ if __name__=='start':
     start(cycle)
 if __name__=='stop':
     stop()
+if __name__=='init':
+    variant(1) # Variante 1 de la maquette 3D du volet roulant

volet_roulant/volrou_lib.py

@@ -10,7 +10,7 @@ import time
 # @project: Blender-EduTech
 # @lang: fr
 # @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
-# @copyright: Copyright (C) 2022-2023 Philippe Roy
+# @copyright: Copyright (C) 2022-2024 Philippe Roy
 # @license: GNU GPL
 ###############################################################################
 
@@ -155,14 +155,15 @@ def start(fct):
 ##
 # Variante
 #
-# Variante 1 : Le mode automatique s'active avec le bouton poussoir bp_auto et se désactive avec l'appui sur bp_m, bp_a ou bp_d.
+# Variante 0 : valeur par défaut : boutons 'bp_auto' et 'bg_auto' absents -> il faut donc définir obligatoirement la variante.
-# Variante 2 : Le mode automatique s'active et se désactive avec  le bouton à glissière bg_auto.
+# Variante 1 : Le mode automatique s'active avec le bouton poussoir 'bp_auto' et se désactive avec l'appui sur 'bp_m', 'bp_a' ou 'bp_d'.
+# Variante 2 : Le mode automatique s'active et se désactive avec le bouton à glissière 'bg_auto'.
 #
-# La variante 1 correspond à la maquette réelle de 4A technologie.
+# La variante 1 correspond à la maquette de 4A technologie.
 #
 # Configuration des variantes du modèle 3D -> variant_dict : 
 # 'nom de l'objet 3D' : liste des variantes où l'objet est présent. 
-# Par défaut les objets sont présents quelque soit la variante sélectionnée.
+# Les objets hors dictionnaire sont présent quelque soit la variante sélectionnée.
 ##
 
 def variant(variant_num):