Refonte de la configuration des variables publiques liées au système

monte_charge/montchg.py

@@ -16,16 +16,29 @@ import time
 # Récupérer la scène UPBGE
 scene = bge.logic.getCurrentScene()
 
-# Configuration du brochage du jumeau réel
-pin_config = {
-    'voy_0' : [['d','o'],['Led niveau 0','pin']],
-    'voy_1' : [['d','o'],['Led niveau 1','pin']],
-    'pc_0' : [['d','i'],['Microrupteur niveau 0','pin']],
-    'pc_1' : [['d','i'],['Microrupteur niveau 1','pin']],
-    'ba_0' : [['d','i'],['Bp niveau 0','pin']],
-    'ba_1' : [['d','i'],['Bp niveau 1','pin']],
-    'mot_m' : [['d','o'],['Moteur','pin_m',]],
-    'mot_d' : [['d','o'],['Moteur','pin_d']]}
+# Configuration des variables publiques
+# 'nom_variable' :
+# - Objet 3D : [nom de l'objet 3D, propriété du stockage de la valeur (activate ou activated_real)]
+# - Configuration de la broche : [nom de la propriété stockant l'object broche (pyfirmata), type de broche par défaut('d','a' ou 'p'), 'mode de la broche par défaut ('i' ou 'o')]
+# - Configuration du graphique : ['marque', 'type de ligne', 'couleur', linewidth]] (matplotlib)
+#
+#  '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, les sorties réelles sont forcées par les sorties numériques et vice-versa.
+
+public_vars = {
+    'voy_0' : [['Led niveau 0','activated'], ['pin', 'd','o'], []],
+    'voy_1' : [['Led niveau 1','activated'], ['pin', 'd','o'], []],
+    'pc_0' : [['Microrupteur niveau 0','activated_real'], [], []],
+    'pc_0_r' : [['Microrupteur niveau 0','activated'], ['pin', 'd','i'], []],
+    'pc_1' : [['Microrupteur niveau 1','activated'], ['pin', 'd','i'], []],
+    'pc_1_r' : [['Microrupteur niveau 1','activated_real'], [], []],
+    'ba_0' : [['Bp niveau 0','activated'], ['pin', 'd','i'], []],
+    'ba_0_r' : [['Bp niveau 0','activated_real'], [], []],
+    'ba_1' : [['Bp niveau 1','activated'], ['pin', 'd','i'], []],
+    'ba_1_r' : [['Bp niveau 1','activated_real'], [], []],
+    'mot_m' : [['Moteur','up',], ['pin_up', 'd','o'], []],
+    'mot_d' : [['Moteur','down'], ['pin_down', 'd','o'], []]}
 
 # Couleurs
 color_passive = (0.800, 0.005, 0.315,1) # bouton non activable :  magenta
@@ -53,9 +66,9 @@ def  init(cont):
     twin.cmd_init() # Commandes
 
     # Brochage
-    for pin in pin_config:
-        # print (pin_config[pin][1][0], pin_config[pin][1][1])
-        scene.objects[pin_config[pin][1][0]][pin_config[pin][1][1]] = None
+    for pin in public_vars:
+        if public_vars[pin][1] != []:
+            scene.objects[public_vars[pin][0][0]][public_vars[pin][1][0]] = None
 
     # Mémorisation de la position et orientation des composants du système au départ
     scene.objects['Cabine']['init_lx']=scene.objects['Cabine'].worldPosition.x
@@ -94,8 +107,8 @@ def  init(cont):
     
     system_init() # Initialisation du système
 
-def get_pin_config():
-    return pin_config
+def get_public_vars():
+    return public_vars
 
 ###############################################################################
 # Actionneurs

monte_charge/montchg_cmd.py

@@ -1,4 +1,4 @@
-from montchg_lib import * # Bibliothèque portail coulissant
+from montchg_lib import * # Bibliothèque utilisateur du monte-charge
 
 ###############################################################################
 # montchg_cmd.py

monte_charge/montchg_doc.py

@@ -35,7 +35,7 @@ card_pin_text=""" Le brochage est un dictionnaire qui permet \n d'associer les o
  - type : a (analogique) ou d (numérique),
  - broche : numéro de la broche de carte,
  - mode : i (entrée), o (sortie) ou p (pwm).
- Par exemple : brochage = { 'ba_0':['d', 3, 'o'] }.\n
+ Par exemple : brochage = { 'voy_0':['d', 3, 'o'] }.\n
  Les objets numériques du jumeau sont : \n 'ba_0', 'ba_1', 'pc_0', 'pc_1', 'mot_m', 'mot_d', \n 'voy_0' et 'voy_1'."""
 card_pin_url=[]
 system_card_description.update({"pin-card" : [card_pin_title, card_pin_text, card_pin_url]})

portail_coulissant/porcou.py

@@ -16,20 +16,34 @@ import time
 # Récupérer la scène UPBGE
 scene = bge.logic.getCurrentScene()
 
-# Configuration du brochage du jumeau réel
-# 'nom_variable' : [['type de broche (d,a,p) ','mode de la broche (i,o)'],
-#                                       ['Objet 3D','pin'],
-#                                      ['marque', 'type de ligne', 'couleur', linewidth]] (matplotlib)
-pin_config = {
-    'bp_ext' : [['d','i'],['Bp cote rue','pin'],['o','-', 'blue', 1]],
-    'bp_int' : [['d','i'],['Bp cote cour','pin'],['o','-', 'darkblue', 1]],
-    'fdc_o' : [['d','i'],['Microrupteur fdc ouvert','pin'],['o','-', 'violet', 1]],
-    'fdc_f' : [['d','i'],['Microrupteur fdc ferme','pin'],['o','-', 'darkviolet', 1]],
-    'mot_o' : [['d','o'],['Moteur','pin_o'],['o','-', 'green', 1]],
-    'mot_f' : [['d','o'],['Moteur','pin_f'],['o','-', 'darkgreen', 1]],
-    'gyr' : [['d','o'],['Led','pin'],['o','-', 'orange', 1]],
-    'ir_emet' : [['d','o'],['Emetteur IR','pin'],['o','-', 'red', 1]],
-    'ir_recep' : [['d','i'],['Recepteur IR','pin'],['o','-', 'darkred', 1]]}
+# Configuration des variables publiques
+# 'nom_variable' :
+# - Objet 3D : [nom de l'objet 3D, propriété du stockage de la valeur (activate ou activated_real)]
+# - Configuration de la broche : [nom de la propriété stockant l'object broche (pyfirmata), type de broche par défaut('d','a' ou 'p'), 'mode de la broche par défaut ('i' ou 'o')]
+# - Configuration du graphique : ['marque', 'type de ligne', 'couleur', linewidth]] (matplotlib)
+#
+#  '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, les sorties réelles sont forcées par les sorties numériques et vice-versa.
+
+public_vars = {
+    'bp_ext' : [['Bp cote rue','activated'], ['pin', 'd','i'], ['o','-', 'green', 1]],
+    'bp_ext_r' : [['Bp cote rue','activated_real'], [], ['o','--', 'green', 1]],
+    'bp_int' : [['Bp cote cour','activated'], ['pin', 'd','i'], ['o','-', 'darkgreen', 1]],
+    'bp_int_r' : [['Bp cote cour','activated_real'], [], ['o','--', 'darkgreen', 1]],
+    'fdc_o' : [['Microrupteur fdc ouvert','activated'], ['pin',  'd','i'], ['o','-', 'orange', 1]],
+    'fdc_o_r' : [['Microrupteur fdc ouvert','activated_real'], [], ['o','--', 'orange', 1]],
+    'fdc_f' : [['Microrupteur fdc ferme','activated'], ['pin',  'd','i'], ['o','-', 'darkorange', 1]],
+    'fdc_f_r' : [['Microrupteur fdc ferme','activated_real'], [], ['o','--', 'darkorange', 1]],
+    'mot_o' : [['Moteur','open'], ['pin_open', 'd','o'], ['o','-', 'violet', 1]],
+    'mot_f' : [['Moteur','close'], ['pin_close', 'd','o'], ['o','-', 'darkviolet', 1]],
+    'mot_angle' : [['Moteur','alpha'], [], ['o','-', 'blue', 1]],
+    'mot_vitesse' : [['Moteur','omega'], [], ['o','-', 'darkblue', 1]],
+    'portail_x' : [['Portail','x'], [], ['o','-', 'turquoise', 1]],
+    'gyr' : [['Led','activated'], ['pin', 'd','o'], ['o','-', 'gold', 1]],
+    'ir_emet' : [['Emetteur IR', 'activated'], ['pin', 'd','o'],['o','-', 'red', 1]],
+    'ir_recep' : [['Recepteur IR','activated'], ['pin',  'd','i'],['o','-', 'darkred', 1]],
+    'ir_recep_r' : [['Recepteur IR','activated_real'], [],['o','--', 'darkred', 1]]}
 
 # Couleurs
 color_passive = (0.800, 0.005, 0.315,1) # bouton non activable :  magenta
@@ -57,9 +71,9 @@ def  init(cont):
     twin.cmd_init() # Commandes
 
     # Brochage
-    for pin in pin_config:
-        # print (pin_config[pin][1][0], pin_config[pin][1][1])
-        scene.objects[pin_config[pin][1][0]][pin_config[pin][1][1]] = None
+    for pin in public_vars:
+        if public_vars[pin][1] != []:
+            scene.objects[public_vars[pin][0][0]][public_vars[pin][1][0]] = None
 
     # Mémorisation de la position et orientation des composants du système
     scene.objects['Portail']['init_lx']=scene.objects['Portail'].worldPosition.x
@@ -91,8 +105,8 @@ def  init(cont):
     system_init() # Initialisation du système
     scene.objects['System']['plot_proc'] = None # Initialisation du processus plot 
 
-def get_pin_config():
-    return pin_config
+def get_public_vars():
+    return public_vars
 
 ###############################################################################
 # Actionneurs

portail_coulissant/porcou_cmd.py

@@ -1,4 +1,4 @@
-from porcou_lib import * # Bibliothèque portail coulissant
+from porcou_lib import * # Bibliothèque utilisateur du portail coulissant
 
 ###############################################################################
 # porcou_cmd.py
@@ -50,28 +50,42 @@ def commandes():
     #     mot_f(True)
     # mot_f(False)
     # gyr(False)
-    tdf= get_t()
-    print ("Début fermeture : ", tdf)
-    while fdc_f() ==False :
-        gyr(True)
-        mot_o(False)
-        mot_f(True)
-    mot_f(False)
-    gyr(False)
-    tff = get_t()
-    print ("Fin fermeture : ", tff)
-    print ("Temp fermeture : ", str(tff-tdf))
-    tdo= get_t()
-    print ("Début ouverture : ", tdo)
+
+    # Init
     while fdc_o() ==False :
         gyr(True)
         mot_f(False)
         mot_o(True)
     mot_o(False)
     gyr(False)
-    tfo = get_t()
-    print ("Fin ouverture : ", tfo)
-    print ("Temp ouverture : ", str(tfo-tdo))
+
+    # Fermeture
+    tf_d= get_t()
+    xf_d= get('portail_x')
+    while fdc_f() ==False :
+        gyr(True)
+        mot_o(False)
+        mot_f(True)
+        print (get('portail_x'), get('mot_angle'), get('mot_vitesse'))
+    mot_f(False)
+    gyr(False)
+    tf_f = get_t()
+    xf_f= get('portail_x')
+    print ("Fermeture : "+str(round(tf_f-tf_d,3)) +" s - distance : " +str(round(xf_f-xf_d,3))+" m")
+
+    # Ouverture
+    to_d= get_t()
+    xo_d= get('portail_x')
+    while fdc_o() ==False :
+        gyr(True)
+        mot_f(False)
+        mot_o(True)
+        print (get('portail_x'), get('mot_angle'), get('mot_vitesse'))
+    mot_o(False)
+    gyr(False)
+    to_f = get_t()
+    xo_f= get('portail_x')
+    print ("Ouverture : "+str(round(to_f-to_d,3)) +" s - distance : " +str(round(xf_f-xf_d,3))+" m")
 
     # plot(['gyr'])
     # plot(['bp_ext'])

portail_coulissant/porcou_lib.py

@@ -2,7 +2,7 @@ import bge # Bibliothèque Blender Game Engine (UPBGE)
 import subprocess # Multiprocessus
 from twin_threading import thread_cmd_start, thread_cmd_stop, thread_cmd_end # Multithreading (multitâches)
 from twin_serial import jumeau, jumeau_stop, serial_close # Liaison série
-from twin_plot import plot # Visualisation des données
+from twin_plot import plot, get # Visualisation des données
 import os
 import sys
 import time
@@ -98,9 +98,6 @@ def bp_int ():
 # Cycle
 ###############################################################################
 
-def get (var):
-    return truncate(scene.objects['System']['time'], 3)
-
 # Temporisation
 def tempo (duree):
     time.sleep(duree)
@@ -111,7 +108,8 @@ def truncate(n, decimals=0):
     return int(n* multiplier)/multiplier
 
 def get_t ():
-    return truncate(scene.objects['System']['time'], 3)
+    # return truncate(scene.objects['System']['time'], 3)
+    return round(scene.objects['System']['time'], 3)
 
 def set_t (date):
     scene.objects['System']['time']=date

twin_plot.py

@@ -20,14 +20,17 @@ scene = bge.logic.getCurrentScene()
 
 # Récupérer la configuration du graphique
 system=importlib.import_module(scene.objects['Doc']['system']) # Système
-plot_config = system.get_pin_config()
+plot_config = system.get_public_vars()
 
 ###############################################################################
-# Variable
+# Accès aux variables publiques du système
 ###############################################################################
 
 def get(data):
-    return scene.objects[plot_config[obj][1][0]]['activated']
+    if data in plot_config:
+        return scene.objects[plot_config[data][0][0]][plot_config[data][0][1]]
+    else:
+        print ("Erreur sur l'accès aux variables par get("+data+"), la variable '"+data+"' absente du système.")
 
 ###############################################################################
 # Création du graphique
@@ -36,17 +39,6 @@ def get(data):
 def plot(data):
     # subprocess.run([sys.executable, os.path.join(os.getcwd(), "twin_plot.py")], , stdin=subprocess.PIPE) # Process bloquant
 
-    # pin_config = {
-    # 'bp_ext' : [['d','i'],['Bp cote rue','pin'],['o','-', 'blue', 1]],
-    # 'bp_int' : [['d','i'],['Bp cote cour','pin'],['o','-', 'darkblue', 1]],
-    # 'fdc_o' : [['d','i'],['Microrupteur fdc ouvert','pin'],['o','-', 'violet', 1]],
-    # 'fdc_f' : [['d','i'],['Microrupteur fdc ferme','pin'],['o','-', 'darkviolet', 1]],
-    # 'mot_o' : [['d','o'],['Moteur','pin_o'],['o','-', 'green', 1]],
-    # 'mot_f' : [['d','o'],['Moteur','pin_f'],['o','-', 'darkgreen', 1]],
-    # 'gyr' : [['d','o'],['Led','pin'],['o','-', 'orange', 1]],
-    # 'ir_emet' : [['d','o'],['Emetteur IR','pin'],['o','-', 'red', 1]],
-    # 'ir_recep' : [['d','i'],['Recepteur IR','pin'],['o','-', 'darkred', 1]]}
-
     # Terminer le processus précédent
     if scene.objects['System']['plot_proc'] is not None:
         if scene.objects['System']['plot_proc'].poll()==None:
@@ -57,7 +49,7 @@ def plot(data):
     # Configuration des données
     scene.objects['System']['plot_data'] =[]
     for obj in data:
-        scene.objects['System']['plot_data'].append(plot_config[obj][1][0])
+        scene.objects['System']['plot_data'].append(plot_config[obj][0][0])
 
     # Démarrer le processus
     scene.objects['System']['plot_proc'] = subprocess.Popen([sys.executable, os.path.join(os.getcwd(), "twin_plot_qt.py")], stdin=subprocess.PIPE, encoding = 'utf8', universal_newlines=True)

twin_serial.py

@@ -22,7 +22,7 @@ scene = bge.logic.getCurrentScene()
 
 # Récupérer le brochage du jumeau réel
 system=importlib.import_module(scene.objects['Doc']['system']) # Système
-pin_config = system.get_pin_config()
+pin_config = system.get_public_vars()
 
 ###############################################################################
 # Liaison série
@@ -162,8 +162,6 @@ def  config(port, speed):
 def jumeau_get_pin(board, name, brochage):
     for pin in brochage :
         if pin ==name:
-            # print (pin_config[pin][0][0]+':'+str(brochage[pin])+':'+pin_config[pin][0][1])
-            # return board.get_pin(pin_config[pin][0][0]+':'+str(brochage[pin])+':'+pin_config[pin][0][1])
             return board.get_pin(brochage[pin][0]+':'+str(brochage[pin][1])+':'+brochage[pin][2])
     return None
 
@@ -178,7 +176,7 @@ def jumeau (brochage=None):
     # Brochage
     if brochage is not None:
         for pin in pin_config :
-            scene.objects[pin_config[pin][1][0]][pin_config[pin][1][1]] = jumeau_get_pin(board, pin, brochage)
+            scene.objects[pin_config[pin][0][0]][pin_config[pin][1][0]] = jumeau_get_pin(board, pin, brochage)
         return  board
     else:
         return None

volet_roulant/volrou.py

@@ -16,18 +16,35 @@ import time
 # Récupérer la scène UPBGE
 scene = bge.logic.getCurrentScene()
 
+# Configuration des variables publiques
+# 'nom_variable' :
+# - Objet 3D : [nom de l'objet 3D, propriété du stockage de la valeur (activate ou activated_real)]
+# - Configuration de la broche : [nom de la propriété stockant l'object broche (pyfirmata), type de broche par défaut('d','a' ou 'p'), 'mode de la broche par défaut ('i' ou 'o')]
+# - Configuration du graphique : ['marque', 'type de ligne', 'couleur', linewidth]] (matplotlib)
+#
+#  '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, les sorties réelles sont forcées par les sorties numériques et vice-versa.
+
 # Configuration du brochage du jumeau réel
-pin_config = {
-    'fdc_h' : [['d','i'],['Microrupteur haut','pin']],
-    'fdc_b' : [['d','i'],['Microrupteur bas','pin']],
-    'bp_m' : [['d','i'],['Bp monter','pin']],
-    'bp_d' : [['d','i'],['Bp descendre','pin']],
-    'bp_a' : [['d','i'],['Bp arret','pin']],
-    'mot_m' : [['d','o'],['Moteur','pin_m']],
-    'mot_d' : [['d','o'],['Moteur','pin_d']],
-    'bp_auto' : [['d','i'],['Bp auto','pin']],
-    'voy_auto' : [['d','o'],['Led auto','pin']],
-    'lum' : [['d','i'],['Recepteur LDR','pin']]}
+public_vars = {
+    'fdc_h' : [['Microrupteur haut','activated'], ['pin', 'd','i'], []],
+    'fdc_h_r' : [['Microrupteur haut','activated_real'], [], []],
+    'fdc_b' : [['Microrupteur bas','activated'], ['pin', 'd','i'], []],
+    'fdc_b_r' : [['Microrupteur bas','activated_real'], [], []],
+    'bp_m' : [['Bp monter','activated'], ['pin', 'd','i'], []],
+    'bp_m_r' : [['Bp monter','activated_real'], [], []],
+    'bp_d' : [['Bp descendre','activated'], ['pin', 'd','i'], []],
+    'bp_d_r' : [['Bp descendre','activated_real'], [], []],
+    'bp_a' : [['Bp arret','activated'], ['pin', 'd','i'], []],
+    'bp_a_r' : [['Bp arret','activated_real'], [], []],
+    'mot_m' : [['Moteur','up'], ['pin_up', 'd','o'], []],
+    'mot_d' : [['Moteur','down'], ['pin_down', 'd','o'], []],
+    'bp_auto' : [['Bp auto','activated'], ['pin', 'd','i'], []],
+    'bp_auto_r' : [['Bp auto','activated_real'], [], []],
+    'voy_auto' : [['Led auto','activated'], ['pin', 'd','o'], []],
+    'lum' : [['Recepteur LDR','activated'], ['pin', 'd','i'], []],
+    'lum_r' : [['Recepteur LDR','activated_real'], [], []]}
 
 # Couleurs
 color_passive = (0.800, 0.005, 0.315,1) # bouton non activable :  magenta
@@ -55,9 +72,9 @@ def  init(cont):
     twin.cmd_init() # Commandes
 
     # Brochage
-    for pin in pin_config:
-        # print (pin_config[pin][1][0], pin_config[pin][1][1])
-        scene.objects[pin_config[pin][1][0]][pin_config[pin][1][1]] = None
+    for pin in public_vars:
+        if public_vars[pin][1] != []:
+            scene.objects[public_vars[pin][0][0]][public_vars[pin][1][0]] = None
 
     # Groupe de focus pour les actionneurs
     twin.cycle_def_focusgroup([["Moteur","blue"],
@@ -80,8 +97,8 @@ def  init(cont):
     
     system_init() # Initialisation du système
 
-def get_pin_config():
-    return pin_config
+def get_public_vars():
+    return public_vars
 
 ###############################################################################
 # Actionneurs

volet_roulant/volrou_cmd.py

@@ -1,4 +1,4 @@
-from volrou_lib import * # Bibliothèque volet roulant
+from volrou_lib import * # Bibliothèque utilisateur du volet roulant
 
 ###############################################################################
 # volrou_cmd.py