Protocole Firmata accessible dans le script utilisateur

monte_charge/montchg.py

@@ -79,6 +79,9 @@ def  init(cont):
     
     system_init() # Initialisation du système
 
+def get_pin_config():
+    return pin_config
+
 ###############################################################################
 # Actionneurs
 ###############################################################################

monte_charge/montchg_cmd.py

@@ -29,12 +29,13 @@ from montchg_lib import * # Bibliothèque portail coulissant
 #
 ###############################################################################
 
-# Brochage du monte-charge
+# Brochage du monte-charge (Grove)
 brochage={
-    'pc_0' : 2,'pc_1' : 3,
-    'ba_0' : 4,'ba_1' : 5,
-    'mot_m' : 6,'mot_d' : 7,
-    'voy_0' : 8, 'voy_1' : 9}
+    'pc_0' : ['d',7,'i'],'pc_1' : ['d',8,'i'],
+    'ba_0' : ['a',0,'i'],'ba_1' : ['a',1,'i'],
+    'voy_0' : ['d',5,'o'],'voy_1' : ['d',6,'o']}
+    # 'mot_m' : ['d',5,'o'],'mot_d' : ['d',6,'o'],
+    # 'voy_0' : ['d',3,'o'], 'voy_1' : ['d',4,'o']}
 
 ###############################################################################
 # Fonctions

monte_charge/montchg_doc.py

@@ -13,26 +13,29 @@
 ################################################################################
 
 # system_card=["twins-card", "serial-card", "movement-card", "sensor-card", "gyro-card", "board-card", "model-card", "arduino-card"]
-system_card=["twins-card", "movement-card", "board-card", "model-card", "arduino-card"]
+system_card=["twins-card", "firmata-card", "movement-card", "board-card", "model-card", "arduino-card"]
 system_card_description ={}
 
 # Jumeau numérique
-# Message envoyé (asynchrone) : \n avancer : a, reculer : r, droite : d, \n gauche g, marquer : m et forer : f \n\n\n """
 card_twins_title="Jumeau numérique"
-card_twins_text=""" jumeau() \n -> Active le jumeau réel.\n  
- jumeau_config(port, vitesse) \n -> Définit la configuration de la liaison \n série.\n
- Si le port n'est pas spécifié, il sera \n recherché automatiquement (carte \n Arduino Uno ou Mega). \n
- La vitesse par défaut est 115200 baud."""
+card_twins_text=""" jumeau(brochage) \n -> Active le jumeau réel.\n
+ jumeau_stop() \n -> Désactive le jumeau réel.\n
+Le brochage est un dictionnaire, par \n exemple : brochage={ "bouton": ['d',2,'i'], \n "led": ['d',3,'o'] }.\n
+ Avec "carte=jumeau(brochage)", on peut \n utiliser l'objet "carte" pour communiquer \n directement avec le protocole Firmata."""
+  # jumeau_config(port, vitesse) \n -> Définit la configuration de la liaison \n série.\n
+ # Si le port n'est pas spécifié, il sera \n recherché automatiquement (carte \n Arduino Uno ou Mega). \n
+ # La vitesse par défaut est 115200 baud."""
 card_twins_url=[]
 system_card_description.update({"twins-card" : [card_twins_title, card_twins_text, card_twins_url]})
 
-# Liaison série
-# card_serial_title="Liaison série"
-# card_serial_text="""  serie_msg(texte) \n -> Envoi un message \n 
-#  texte=serie_rcpt() \n -> Reçoit un message"""
-# card_serial_url=[["Liaison série : pySerial","https://pythonhosted.org/pyserial/"],
-#                  ["Protocole Firmata : pyFirmata","https://github.com/tino/pyFirmata"]]
-# card_description.update({"serial-card" : [card_serial_title, card_serial_text, card_serial_url]})
+# Firmata
+card_firmata_title="Protocole Firmata"
+card_firmata_text=""" La communication entre les jumeaux \n est basée sur le protocole Firmata.\n
+ broche = carte.get_pin('type:broche:mode') \n -> Créer une entrée/sortie (broche) \n - type : a (analogique) ou d (numérique) \n - mode : i (entrée) , o (sortie) ou p (pwm). \n
+ broche.read() \n -> Retourne la valeur de la broche.\n
+ broche.write(valeur) \n -> Écrire la valeur sur la broche."""
+card_firmata_url=[["Protocole Firmata : pyFirmata","https://github.com/tino/pyFirmata"]]
+system_card_description.update({"firmata-card" : [card_firmata_title, card_firmata_text, card_firmata_url]})
 
 # Ouvrir et fermer
 card_movement_title="Monter et descendre"

monte_charge/montchg_lib.py

@@ -1,6 +1,6 @@
 import bge # Bibliothèque Blender Game Engine (UPBGE)
 from twin_threading import thread_cmd_start, thread_cmd_stop, thread_cmd_end # Multithreading
-import twin_serial # Liaison série
+from twin_serial import jumeau, jumeau_stop, serial_close # Liaison série
 import time
 
 ###############################################################################
@@ -16,9 +16,6 @@ import time
 # Récupérer la scène UPBGE
 scene = bge.logic.getCurrentScene()
 
-# Récupérer le brochage du jumeau réel
-from montchg import pin_config
-
 # UPBGE constants
 JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
 JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
@@ -85,35 +82,6 @@ def ba_1 ():
     else:
         return False
 
-###############################################################################
-# Jumeau
-###############################################################################
-
-# Créer une broche
-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 None
-
-# Activer le jumelage
-def jumeau (brochage=None):
-    
-    # Carte
-    board =twin_serial.open()
-    scene.objects['System']['board']=board
-    # print ("jumeau : ", scene.objects['System']['board'])
-
-    # 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)
-
-# Désactiver le jumelage
-def jumeau_stop ():
-    twin_serial.close(scene.objects['System']['board'])
-
 ###############################################################################
 # Cycle
 ###############################################################################
@@ -125,14 +93,14 @@ def tempo (duree):
 # Arrêt
 def stop():
     if scene.objects['System']['twins']:
-        twin_serial.close(scene.objects['System']['board'])
+        serial_close(scene.objects['System']['board'])
         time.sleep(1)
     thread_cmd_stop()
 
 # Fin naturelle
 def end():
     if scene.objects['System']['twins']:
-        twin_serial.close(scene.objects['System']['board'])
+        serial_close(scene.objects['System']['board'])
         time.sleep(1)
     thread_cmd_end()
 

portail_coulissant/porcou.py

@@ -77,6 +77,9 @@ def  init(cont):
     
     system_init() # Initialisation du système
 
+def get_pin_config():
+    return pin_config
+
 ###############################################################################
 # Actionneurs
 ###############################################################################
@@ -238,6 +241,7 @@ def ir_emet (cont):
                 scene.objects['Recepteur IR']['activated'] = True
 
             # Couleurs
+            # FIXME : à faire
             if obj['activated'] == True and obj.color !=color_activated:
                 obj.color =color_activated
             if obj['activated'] == False :
@@ -248,6 +252,7 @@ def ir_emet (cont):
 
 ##
 # Récepteur IR
+# FIXME : Modele 3D -> Arduino à faire
 ##
 
 def ir_recep (cont):
@@ -261,12 +266,13 @@ def ir_recep (cont):
         # Active
         if obj['active']:
            
-            # Forçage (click)
+            # Forçage par clic
             if obj['click'] == True:
                 obj['activated'] = True
                 scene.objects['Emetteur IR']['activated'] = True
 
             # Couleurs
+            # FIXME : à faire
             if obj['activated'] == True and obj.color !=color_activated:
                 obj.color =color_activated
             if obj['activated'] == False :
@@ -332,4 +338,4 @@ def system_reset ():
     scene.objects['Emetteur IR']['active'] =False
     scene.objects['Recepteur IR']['activated'] =False
     scene.objects['Recepteur IR']['active'] =False
-    scene.objects['Recepteur IR']['activated_real'] =False
+    scene.objects['Recepteur IR']['activated_real'] =True # Absence d'obstacle -> True, présence d'obstacle -> False

portail_coulissant/porcou_cmd.py

@@ -28,13 +28,13 @@ from porcou_lib import * # Bibliothèque portail coulissant
 #
 ###############################################################################
 
-# Brochage du portail coulissant
+# Brochage du portail coulissant (Grove)
 brochage={
-    'bp_ext' : 2,'bp_int' : 3,
-    'fdc_o' : 4,'fdc_f' : 5,
-    'mot_o' : 6,'mot_f' : 7,
-    'gyr' : 4,
-    'ir_emet' : 9,'ir_recep' : 10}
+    'bp_ext' : ['a',0,'i'],'bp_int' : ['a',1,'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',2,'o'],'ir_recep' : ['a',3,'i']}
 
 ###############################################################################
 # Fonctions
@@ -48,45 +48,14 @@ def commandes():
 
     jumeau(brochage)
 
-    # Mise en place : Fermeture
-    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)
-
-    # Fonctionnement normal
-    print ("Attente")
-    while True :
-        
-        # Ouverture
-        if bp_int() or bp_ext()  :
-            print ("Ouverture")
-            while fdc_o() ==False:
-                gyr(True)
-                mot_f(False)
-                mot_o(True)
-            gyr(False)
-            mot_o(False)
-
-            print ("Temporisation")
-            tempo(2) # Temporisation
-
-            # Fermeture
-            print ("Fermeture")
-            while fdc_f() ==False:
-                gyr(True)
-                mot_o(False)
-                mot_f(True)
-            gyr(False)
-            mot_f(False)
-            print ("Attente")
-
+    # Ecrire votre code ici ...
+    gyr(True) # Activer le gyrophare
+    while True:
+        pass
+ 
     fin() # A garder
 
+
 ###############################################################################
 # En: External call << DONT CHANGE THIS SECTION >>
 # Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>

portail_coulissant/porcou_doc.py

@@ -13,27 +13,29 @@
 ################################################################################
 
 # system_card=["twins-card", "serial-card", "movement-card", "sensor-card", "gyro-card", "board-card", "model-card", "arduino-card"]
-system_card=["twins-card", "movement-card", "sensor-card", "gyro-card", "board-card", "model-card", "arduino-card"]
-# system_card=["twins-card"]
+system_card=["twins-card", "firmata-card", "movement-card", "sensor-card", "gyro-card", "board-card", "model-card", "arduino-card"]
 system_card_description ={}
 
 # Jumeau numérique
-# Message envoyé (asynchrone) : \n avancer : a, reculer : r, droite : d, \n gauche g, marquer : m et forer : f \n\n\n """
 card_twins_title="Jumeau numérique"
-card_twins_text=""" jumeau() \n -> Active le jumeau réel.\n  
- jumeau_config(port, vitesse) \n -> Définit la configuration de la liaison \n série.\n
- Si le port n'est pas spécifié, il sera \n recherché automatiquement (carte \n Arduino Uno ou Mega). \n
- La vitesse par défaut est 115200 baud."""
+card_twins_text=""" jumeau(brochage) \n -> Active le jumeau réel.\n
+ jumeau_stop() \n -> Désactive le jumeau réel.\n
+Le brochage est un dictionnaire, par \n exemple : brochage={ "bouton": ['d',2,'i'], \n "led": ['d',3,'o'] }.\n
+ Avec "carte=jumeau(brochage)", on peut \n utiliser l'objet "carte" pour communiquer \n directement avec le protocole Firmata."""
+  # jumeau_config(port, vitesse) \n -> Définit la configuration de la liaison \n série.\n
+ # Si le port n'est pas spécifié, il sera \n recherché automatiquement (carte \n Arduino Uno ou Mega). \n
+ # La vitesse par défaut est 115200 baud."""
 card_twins_url=[]
 system_card_description.update({"twins-card" : [card_twins_title, card_twins_text, card_twins_url]})
 
-# Liaison série
-# card_serial_title="Liaison série"
-# card_serial_text="""  serie_msg(texte) \n -> Envoi un message \n 
-#  texte=serie_rcpt() \n -> Reçoit un message"""
-# card_serial_url=[["Liaison série : pySerial","https://pythonhosted.org/pyserial/"],
-#                  ["Protocole Firmata : pyFirmata","https://github.com/tino/pyFirmata"]]
-# card_description.update({"serial-card" : [card_serial_title, card_serial_text, card_serial_url]})
+# Firmata
+card_firmata_title="Protocole Firmata"
+card_firmata_text=""" La communication entre les jumeaux \n est basée sur le protocole Firmata.\n
+ broche = carte.get_pin('type:broche:mode') \n -> Créer une entrée/sortie (broche) \n - type : a (analogique) ou d (numérique) \n - mode : i (entrée) , o (sortie) ou p (pwm). \n
+ broche.read() \n -> Retourne la valeur de la broche.\n
+ broche.write(valeur) \n -> Écrire la valeur sur la broche."""
+card_firmata_url=[["Protocole Firmata : pyFirmata","https://github.com/tino/pyFirmata"]]
+system_card_description.update({"firmata-card" : [card_firmata_title, card_firmata_text, card_firmata_url]})
 
 # Ouvrir et fermer
 card_movement_title="Ouvrir et fermer"

portail_coulissant/porcou_lib.py

@@ -1,6 +1,7 @@
 import bge # Bibliothèque Blender Game Engine (UPBGE)
 from twin_threading import thread_cmd_start, thread_cmd_stop, thread_cmd_end # Multithreading
-import twin_serial # Liaison série
+from twin_serial import jumeau, jumeau_stop, serial_close # Liaison série
+# import twin_serial # Liaison série
 import time
 
 ###############################################################################
@@ -16,9 +17,6 @@ import time
 # Récupérer la scène UPBGE
 scene = bge.logic.getCurrentScene()
 
-# Récupérer le brochage du jumeau réel
-from porcou import pin_config
-
 # UPBGE constants
 JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
 JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
@@ -68,6 +66,7 @@ def fdc_f ():
         return False
 
 # Compte-rendu du capteur barrage IR
+# Absence d'obstacle -> True, présence d'obstacle -> False
 def ir_recep ():
     if scene.objects['Recepteur IR']['activated'] or scene.objects['Recepteur IR']['activated_real']==False:
        return False
@@ -92,35 +91,6 @@ def bp_int ():
     else:
         return False
 
-###############################################################################
-# Jumeau
-###############################################################################
-
-# Créer une broche
-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 None
-
-# Activer le jumelage
-def jumeau (brochage=None):
-    
-    # Carte
-    board =twin_serial.open()
-    scene.objects['System']['board']=board
-    # print ("jumeau : ", scene.objects['System']['board'])
-
-    # 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)
-
-# Désactiver le jumelage
-def jumeau_stop ():
-    twin_serial.close(scene.objects['System']['board'])
-
 ###############################################################################
 # Cycle
 ###############################################################################
@@ -132,14 +102,14 @@ def tempo (duree):
 # Arrêt
 def stop():
     if scene.objects['System']['twins']:
-        twin_serial.close(scene.objects['System']['board'])
+        serial_close(scene.objects['System']['board'])
         time.sleep(1)
     thread_cmd_stop()
 
 # Fin naturelle
 def end():
     if scene.objects['System']['twins']:
-        twin_serial.close(scene.objects['System']['board'])
+        serial_close(scene.objects['System']['board'])
         time.sleep(1)
     thread_cmd_end()
 

twin_config.xml

@@ -1,7 +1,7 @@
 <data>
     <screen>
-	<width>1609</width>
-	<height>905</height>
+	<width>1325</width>
+	<height>745</height>
 	<quality>1</quality>
   </screen>
 </data>

twin_doc.py

@@ -79,9 +79,9 @@ card_description.update({"loop-card" : [card_loop_title, card_loop_text, card_lo
 # Flux
 card_flow_title="Contrôle du flux"
 card_flow_text=""" Les structures (if, while, for) peuvent \n être gérées plus finement par les \n fonctions "break", "continue" et  "pass". \n
- - "break" : termine l'itération en cours et \n   arrête la boucle.
- - "continue" : termine l'itération en cours \n   et reprend la boucle.
- - "pass" : instruction vide.""" 
+ - break : termine l'itération en cours et \n   arrête la boucle.
+ - continue : termine l'itération en cours \n   et reprend la boucle.
+ - pass : instruction vide.""" 
 card_flow_url=[["w3schools.com : break","https://www.w3schools.com/python/ref_keyword_break.asp"],
              ["w3schools.com : continue","https://www.w3schools.com/python/ref_keyword_break.asp"],
              ["w3schools.com : pass","https://www.w3schools.com/python/ref_keyword_pass.asp"]]

twin_serial.py

@@ -1,5 +1,6 @@
 import bge # Bibliothèque Blender Game Engine (UPBGE)
 import numpy as np
+import importlib
 import time
 
 import serial # Liaison série
@@ -19,6 +20,14 @@ from serial.tools.list_ports import comports # Détection du port automatique
 # UPBGE scene
 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()
+
+###############################################################################
+# Liaison série
+###############################################################################
+
 ##
 # Recherche automatique du port
 ##
@@ -79,7 +88,7 @@ def  devices():
 # pyfirmata : baudrate=57600
 ##
 
-def  open():
+def  serial_open():
 
     # UI : étape 1
     scene.objects['Twins-text']['Text'] = "Connection en cours ..."
@@ -116,7 +125,7 @@ def  open():
 # Fermeture de la communication série
 ##
 
-def  close(board):
+def  serial_close(board):
     if scene.objects['System']['twins']:
         scene.objects['Twins-text']['Text'] = "Connection fermée."
         board.exit() # Fermer proprement la communication avec la carte
@@ -145,6 +154,43 @@ def  config(port, speed):
     #     serial_msg5 = "FC\n"
     #     twins_serial.write(serial_msg5.encode())
 
+###############################################################################
+# Jumeau
+###############################################################################
+
+# Créer une broche
+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
+
+# Activer le jumelage
+def jumeau (brochage=None):
+    
+    # Carte
+    board =serial_open()
+    scene.objects['System']['board']=board
+    # print ("jumeau : ", scene.objects['System']['board'])
+
+    # 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)
+        return  board
+    else:
+        return None
+
+# Désactiver le jumelage
+def jumeau_stop ():
+    serial_close(scene.objects['System']['board'])
+
+###############################################################################
+# Message
+###############################################################################
+
 ##
 # Envoi d'un message vers la communication série
 # FIXME : plus tard

volet_roulant/volrou.py

@@ -70,6 +70,9 @@ def  init(cont):
     
     system_init() # Initialisation du système
 
+def get_pin_config():
+    return pin_config
+
 ###############################################################################
 # Actionneurs
 ###############################################################################
@@ -346,7 +349,6 @@ def system_init ():
     scene.objects['Led moteur-on'].setVisible(False,False)
     scene.objects['Led alimentation'].setVisible(True,False)
     scene.objects['Led alimentation-on'].setVisible(False,False)
-
     system_reset()
 
 ##

volet_roulant/volrou_cmd.py

@@ -31,14 +31,12 @@ from volrou_lib import * # Bibliothèque volet roulant
 #
 ###############################################################################
 
-# Brochage du volet roulant
-# brochage={
-#     'fdc_h' : 2,'fdc_b' : 3,
-#     'bp_m' : 4,'bp_d' : 5, 'bp_a' : 6,
-#     'mot_m' : 7,'mot_d' : 8,
-#     'bp_auto' : 9, 'voy_auto' : 10, 'lum' : 11}
-
-brochage={'voy_auto' : 4}
+# Brochage du volet roulant (Grove)
+brochage={
+    'fdc_h' : ['d',7,'i'],'fdc_b' : ['d',8,'i'],
+    'bp_m' : ['a',0,'i'],'bp_d' : ['a',1,'i'], 'bp_a' : ['d',2,'i'],
+    'mot_m' : ['d',5,'o'],'mot_d' : ['d',6,'o'],
+    'bp_auto' : ['a',3,'i'], 'voy_auto' : ['d',4,'o'], 'lum' : ['a',2,'i']}
 
 ###############################################################################
 # Fonctions

volet_roulant/volrou_doc.py

@@ -13,26 +13,29 @@
 ################################################################################
 
  # system_card=["twins-card", "serial-card", "movement-card", "sensor-card", "board-card", "model-card", "arduino-card"]
-system_card=["twins-card", "movement-card", "sensor-card", "board-card", "model-card", "arduino-card"]
+system_card=["twins-card", "firmata-card", "movement-card", "sensor-card", "board-card", "model-card", "arduino-card"]
 system_card_description ={}
 
 # Jumeau numérique
-# Message envoyé (asynchrone) : \n avancer : a, reculer : r, droite : d, \n gauche g, marquer : m et forer : f \n\n\n """
 card_twins_title="Jumeau numérique"
-card_twins_text=""" jumeau() \n -> Active le jumeau réel.\n  
- jumeau_config(port, vitesse) \n -> Définit la configuration de la liaison \n série.\n
- Si le port n'est pas spécifié, il sera \n recherché automatiquement (carte \n Arduino Uno ou Mega). \n
- La vitesse par défaut est 115200 baud."""
+card_twins_text=""" jumeau(brochage) \n -> Active le jumeau réel.\n
+ jumeau_stop() \n -> Désactive le jumeau réel.\n
+Le brochage est un dictionnaire, par \n exemple : brochage={ "bouton": ['d',2,'i'], \n "led": ['d',3,'o'] }.\n
+ Avec "carte=jumeau(brochage)", on peut \n utiliser l'objet "carte" pour communiquer \n directement avec le protocole Firmata."""
+  # jumeau_config(port, vitesse) \n -> Définit la configuration de la liaison \n série.\n
+ # Si le port n'est pas spécifié, il sera \n recherché automatiquement (carte \n Arduino Uno ou Mega). \n
+ # La vitesse par défaut est 115200 baud."""
 card_twins_url=[]
 system_card_description.update({"twins-card" : [card_twins_title, card_twins_text, card_twins_url]})
 
-# Liaison série
-# card_serial_title="Liaison série"
-# card_serial_text="""  serie_msg(texte) \n -> Envoi un message \n 
-#  texte=serie_rcpt() \n -> Reçoit un message"""
-# card_serial_url=[["Liaison série : pySerial","https://pythonhosted.org/pyserial/"],
-#                  ["Protocole Firmata : pyFirmata","https://github.com/tino/pyFirmata"]]
-# card_description.update({"serial-card" : [card_serial_title, card_serial_text, card_serial_url]})
+# Firmata
+card_firmata_title="Protocole Firmata"
+card_firmata_text=""" La communication entre les jumeaux \n est basée sur le protocole Firmata.\n
+ broche = carte.get_pin('type:broche:mode') \n -> Créer une entrée/sortie (broche) \n - type : a (analogique) ou d (numérique) \n - mode : i (entrée) , o (sortie) ou p (pwm). \n
+ broche.read() \n -> Retourne la valeur de la broche.\n
+ broche.write(valeur) \n -> Écrire la valeur sur la broche."""
+card_firmata_url=[["Protocole Firmata : pyFirmata","https://github.com/tino/pyFirmata"]]
+system_card_description.update({"firmata-card" : [card_firmata_title, card_firmata_text, card_firmata_url]})
 
 # Ouvrir et fermer
 card_movement_title="Monter et descendre"

volet_roulant/volrou_lib.py

@@ -1,6 +1,6 @@
 import bge # Bibliothèque Blender Game Engine (UPBGE)
 from twin_threading import thread_cmd_start, thread_cmd_stop, thread_cmd_end # Multithreading
-import twin_serial # Liaison série
+from twin_serial import jumeau, jumeau_stop, serial_close # Liaison série
 import time
 
 ###############################################################################
@@ -16,9 +16,6 @@ import time
 # Récupérer la scène UPBGE
 scene = bge.logic.getCurrentScene()
 
-# Récupérer le brochage du jumeau réel
-from volrou import pin_config
-
 # UPBGE constants
 JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
 JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
@@ -97,35 +94,6 @@ def bp_d ():
 def bp_auto ():
     return scene.objects['Bp auto']['activated']
 
-###############################################################################
-# Jumeau
-###############################################################################
-
-# Créer une broche
-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 None
-
-# Activer le jumelage
-def jumeau (brochage=None):
-    
-    # Carte
-    board =twin_serial.open()
-    scene.objects['System']['board']=board
-    # print ("jumeau : ", scene.objects['System']['board'])
-
-    # 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)
-
-# Désactiver le jumelage
-def jumeau_stop ():
-    twin_serial.close(scene.objects['System']['board'])
-
 ###############################################################################
 # Cycle
 ###############################################################################
@@ -137,14 +105,14 @@ def tempo (duree):
 # Arrêt
 def stop():
     if scene.objects['System']['twins']:
-        twin_serial.close(scene.objects['System']['board'])
+        serial_close(scene.objects['System']['board'])
         time.sleep(1)
     thread_cmd_stop()
 
 # Fin naturelle
 def end():
     if scene.objects['System']['twins']:
-        twin_serial.close(scene.objects['System']['board'])
+        serial_close(scene.objects['System']['board'])
         time.sleep(1)
     thread_cmd_end()