Ajout des scripts de test jumelage Grove et ajout des capteurs analogiques

monte_charge/montchg.py

@@ -31,8 +31,8 @@ public_vars = {
     't' : [['System','time','a'], [], []],
     'voy_0' : [['Led niveau 0','activated','d'], ['pin', 'd','o'], []],
     'voy_1' : [['Led niveau 1','activated','d'], ['pin', 'd','o'], []],
-    'pc_0' : [['Microrupteur niveau 0','activated_real','d'], [], []],
+    'pc_0' : [['Microrupteur niveau 0','activated','d'], ['pin', 'd','i'], []],
-    'pc_0_r' : [['Microrupteur niveau 0','activated','d'], ['pin', 'd','i'], []],
+    'pc_0_r' : [['Microrupteur niveau 0','activated_real','d'], [], []],
     'pc_1' : [['Microrupteur niveau 1','activated','d'], ['pin', 'd','i'], []],
     'pc_1_r' : [['Microrupteur niveau 1','activated_real','d'], [], []],
     'ba_0' : [['Bp niveau 0','activated','d'], ['pin', 'd','i'], []],

monte_charge/montchg_cmd-grove.py

@@ -0,0 +1,108 @@
+from montchg_lib import * # Bibliothèque utilisateur du monte-charge
+
+###############################################################################
+# montchg_cmd-grove.py
+# @title: Script de test pour le jumelage du monte-charge à des composants Grove
+###############################################################################
+
+###############################################################################
+# Instructions élémentaires pour le monte-charge
+#
+# Actions (ordre = True ou False) :
+# - Monter le monte-charge (moteur sens trigo) : mot_m(True | False)
+# - Descendre le monte-charge (moteur sens horaire) : mot_d(True | False)
+#
+# Capteurs (valeur retournée = True ou False) :
+# - Capteur présence cabine niveau 0 : pc_0()
+# - Capteur présence cabine niveau 1 : pc_1()
+#
+# Consignes du pupitre (valeur retournée = True ou False) :
+# - Bouton poussoir appel niveau 0 : ba_0()
+# - Bouton poussoir appel niveau 1 : ba_1()
+#
+# Retours d'information du pupitre (allumer = True ou False) :
+# - Voyant témoin d'étage niveau 0 : voy_0(True | False)
+# - Voyant témoin d'étage niveau  1 : voy_1(True | False)
+#
+# Gestion du temps :
+# - Temporisation en seconde : tempo(duree)
+#
+###############################################################################
+
+# Brochage du monte-charge (Grove)
+brochage={
+    'pc_0' : ['d',7,'i'], 'pc_1' : ['d',8,'i'],
+    'ba_0' : ['a',0,'i'], 'ba_1' : ['a',1,'i'],
+    'voy_0' : ['d',3,'o'], 'voy_1' : ['d',4,'o'],
+    'mot_m' : ['d',5,'o'], 'mot_d' : ['d',6,'o']}
+
+###############################################################################
+# Fonctions
+###############################################################################
+
+###############################################################################
+# Commandes
+###############################################################################
+
+def commandes():
+
+    # daq(['mot_angle', 'mot_vitesse', 'cabine_z', 'cabine_vitesse'])
+    # plot(['mot_angle', 'mot_vitesse'])
+    jumeau(brochage)
+    jumeau_mode(True, True, True, True)
+
+    # Mise en place : Aller au niveau 0
+    print ("Monte-charge sans la mémorisation des appels")
+    print ("Mise en place : Aller au niveau 0 ...")
+    while pc_0() ==False:
+        mot_m(False)
+        mot_d(True)
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+    mot_d(False)
+    print ("Mise en place : Aller au niveau 0 : Ok")
+
+    # Fonctionnement normal
+    print ("Attente")
+    while True:
+
+        # Aller au niveau 0 
+        if ba_0() and pc_0() ==False:
+            print ("Déplacement pour le niveau 0 ...")
+            voy_0(True)
+            while pc_0() ==False:
+                mot_m(False)
+                mot_d(True)
+                tempo(0.1) # Donne du temps à communication avec le jumeau réel
+            mot_d(False)
+            tempo(2) # Temporisation 2s
+            voy_0(False)
+            print ("Déplacement pour le niveau 0 : Ok")
+            print ("Attente")
+
+        # Aller au niveau 1 
+        if ba_1() and pc_1() ==False:
+            print ("Déplacement pour le niveau 1 ...")
+            voy_1(True)
+            while pc_1() ==False:
+                mot_d(False)
+                mot_m(True)
+                tempo(0.1) # Donne du temps à communication avec le jumeau réel
+            mot_m(False)
+            tempo(2) # Temporisation 2s
+            voy_1(False)
+            print ("Déplacement pour le niveau 1 : Ok")
+            print ("Attente")
+
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+
+    fin() # A garder
+
+###############################################################################
+# En: External call << DONT CHANGE THIS SECTION >>
+# Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+###############################################################################
+
+if __name__=='start':
+    start(commandes)
+if __name__=='stop':
+    stop()

monte_charge/montchg_cmd-test.py

@@ -0,0 +1,115 @@
+from montchg_lib import * # Bibliothèque utilisateur du monte-charge
+
+###############################################################################
+# montchg_cmd.py
+# @title: Commandes du monte-charge
+###############################################################################
+
+###############################################################################
+# Instructions élémentaires pour le monte-charge
+#
+# Actions (ordre = True ou False) :
+# - Monter le monte-charge (moteur sens trigo) : mot_m(True | False)
+# - Descendre le monte-charge (moteur sens horaire) : mot_d(True | False)
+#
+# Capteurs (valeur retournée = True ou False) :
+# - Capteur présence cabine niveau 0 : pc_0()
+# - Capteur présence cabine niveau 1 : pc_1()
+#
+# Consignes du pupitre (valeur retournée = True ou False) :
+# - Bouton poussoir appel niveau 0 : ba_0()
+# - Bouton poussoir appel niveau 1 : ba_1()
+#
+# Retours d'information du pupitre (allumer = True ou False) :
+# - Voyant témoin d'étage niveau 0 : voy_0(True | False)
+# - Voyant témoin d'étage niveau  1 : voy_1(True | False)
+#
+# Gestion du temps :
+# - Temporisation en seconde : tempo(duree)
+#
+###############################################################################
+
+# Brochage du monte-charge
+brochage={
+    'ba_0' : [],'ba_1' : [],
+    'pc_0' : [],'pc_1' : [],
+    'mot_m' : [],'mot_d' : [],
+    'voy_0' : [], 'voy_1' : []}
+
+###############################################################################
+# Fonctions
+###############################################################################
+
+###############################################################################
+# Commandes
+###############################################################################
+
+def commandes():
+
+    daq(['mot_angle', 'mot_vitesse', 'cabine_z', 'cabine_vitesse'])
+    plot(['mot_angle', 'mot_vitesse'])
+    # plot(['mot_angle', 'mot_vitesse', ['cabine_z', 'cabine_vitesse']])
+    # plot([['mot_angle', 'mot_vitesse']])
+    # plot(['mot_angle'])
+    jumeau_mode(True, True, True, True)
+
+    mot_vitesse (500) 
+    # Init -> Descendre
+    while pc_0() ==False :
+        voy_0(True)
+        mot_m(False)
+        mot_d(True)
+    mot_d(False)
+    voy_0(False)
+    print ("")
+
+    daq(['mot_angle', 'mot_vitesse', 'cabine_z', 'cabine_vitesse'])
+
+    # Monter
+    mot_digitset (500) 
+    t0,z0, a0= get('t'), get('cabine_z'), get('mot_angle')
+    print ("Début monter :  cabine_z : "+str(round(z0, 3)) + " - mot_angle : " + str(round(a0, 3)))
+    while pc_1() ==False :
+        voy_1(True)
+        mot_d(False)
+        mot_m(True)
+        mot_pas, mot_vitesse, cabine_pas, cabine_vitesse= get('mot_pas'), get('mot_vitesse'), get('cabine_pas'), get('cabine_vitesse')
+    mot_m(False)
+    voy_1(False)
+    t1,z1, a1= get('t'), get('cabine_z'), get('mot_angle')
+    print ("Fin monter :  cabine_z : "+str(round(z1, 3)) + " - mot_angle : " + str(round(a1, 3)))
+    print ("")
+    print ("Monter : "+str(round(t1-t0, 3)) +" s - distance : " +str(round(z1-z0, 3))+" mm - angle : " +str(round(a1-a0, 3))+
+           " rad - cabine_vitesse : " +str(round(cabine_vitesse, 3))+" mm/s - moteur_vitesse : " +str(round(mot_vitesse, 3))+
+           " rad/s - cabine_pas : " +str(round(cabine_pas, 3))+" mm/impulsion - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
+    print ("")
+
+    # Descendre
+    mot_digitset ()  # 5 tr/s 
+    t0,z0, a0= get('t'), get('cabine_z'), get('mot_angle')
+    print ("Début descendre :  cabine_z : "+str(round(z0, 3)) + " - mot_angle : " + str(round(a0, 3)))
+    while pc_0() ==False :
+        voy_0(True)
+        mot_m(False)
+        mot_d(True)
+        mot_pas, mot_vitesse, cabine_pas, cabine_vitesse= get('mot_pas'), get('mot_vitesse'), get('cabine_pas'), get('cabine_vitesse')
+    mot_d(False)
+    voy_0(False)
+    t1,z1, a1= get('t'), get('cabine_z'), get('mot_angle')
+    print ("Fin descendre :  cabine_z : "+str(round(z1, 3)) + " - mot_angle : " + str(round(a1, 3)))
+    print ("")
+    print ("Descendre : "+str(round(t1-t0, 3)) +" s - distance : " +str(round(z1-z0, 3))+" mm - angle : " +str(round(a1-a0, 3))+
+           " rad - cabine_vitesse : " +str(round(cabine_vitesse, 3))+" mm/s - moteur_vitesse : " +str(round(mot_vitesse, 3))+
+           " rad/s - cabine_pas : " +str(round(cabine_pas, 3))+" mm/impulsion - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
+
+    fin() # A garder
+
+###############################################################################
+# En: External call << DONT CHANGE THIS SECTION >>
+# Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+###############################################################################
+
+if __name__=='start':
+    start(commandes)
+if __name__=='stop':
+    stop()

monte_charge/montchg_cmd.py

@@ -1,8 +1,8 @@
 from montchg_lib import * # Bibliothèque utilisateur du monte-charge
 
 ###############################################################################
-# montchg_cmd.py
+# montchg_cmd-grove.py
-# @title: Commandes du monte-charge
+# @title: Script de test pour le jumelage du monte-charge à des composants Grove
 ###############################################################################
 
 ###############################################################################
@@ -29,6 +29,13 @@ from montchg_lib import * # Bibliothèque utilisateur du monte-charge
 #
 ###############################################################################
 
+# Brochage du monte-charge (Grove)
+brochage={
+    'pc_0' : ['d',7,'i'], 'pc_1' : ['d',8,'i'],
+    'ba_0' : ['a',0,'i'], 'ba_1' : ['a',1,'i'],
+    'voy_0' : ['d',3,'o'], 'voy_1' : ['d',4,'o'],
+    'mot_m' : ['d',5,'o'], 'mot_d' : ['d',6,'o']}
+
 ###############################################################################
 # Fonctions
 ###############################################################################
@@ -39,62 +46,55 @@ from montchg_lib import * # Bibliothèque utilisateur du monte-charge
 
 def commandes():
 
-    daq(['mot_angle', 'mot_vitesse', 'cabine_z', 'cabine_vitesse'])
+    # daq(['mot_angle', 'mot_vitesse', 'cabine_z', 'cabine_vitesse'])
+    # plot(['mot_angle', 'mot_vitesse'])
+    jumeau(brochage)
     jumeau_mode(True, True, True, True)
 
-    mot_vitesse (500) 
+    # Mise en place : Aller au niveau 0
-    # Init -> Descendre
+    print ("Monte-charge sans la mémorisation des appels")
-    while pc_0() ==False :
+    print ("Mise en place : Aller au niveau 0 ...")
-        voy_0(True)
+    while pc_0() ==False:
         mot_m(False)
         mot_d(True)
+        tempo(0.1)
     mot_d(False)
-    voy_0(False)
+    print ("Mise en place : Aller au niveau 0 : Ok")
-    print ("")
 
-    # daq(['mot_angle', 'mot_vitesse', 'cabine_z', 'cabine_vitesse'])
+    # Fonctionnement normal
+    print ("Attente")
+    while True:
 
-    # # Monter
+        # Aller au niveau 0 
-    # mot_digitset (500) 
+        if ba_0() and pc_0() ==False:
-    # t0,z0, a0= get('t'), get('cabine_z'), get('mot_angle')
+            print ("Déplacement pour le niveau 0 ...")
-    # print ("Début monter :  cabine_z : "+str(round(z0, 3)) + " - mot_angle : " + str(round(a0, 3)))
+            voy_0(True)
-    # while pc_1() ==False :
+            while pc_0() ==False:
-    #     voy_1(True)
+                mot_m(False)
-    #     mot_d(False)
+                mot_d(True)
-    #     mot_m(True)
+                tempo(0.1)
-    #     mot_pas, mot_vitesse, cabine_pas, cabine_vitesse= get('mot_pas'), get('mot_vitesse'), get('cabine_pas'), get('cabine_vitesse')
+            mot_d(False)
-    # mot_m(False)
+            tempo(2) # Temporisation 2s
-    # voy_1(False)
+            voy_0(False)
-    # t1,z1, a1= get('t'), get('cabine_z'), get('mot_angle')
+            print ("Déplacement pour le niveau 0 : Ok")
-    # print ("Fin monter :  cabine_z : "+str(round(z1, 3)) + " - mot_angle : " + str(round(a1, 3)))
+            print ("Attente")
-    # print ("")
-    # print ("Monter : "+str(round(t1-t0, 3)) +" s - distance : " +str(round(z1-z0, 3))+" mm - angle : " +str(round(a1-a0, 3))+
-    #        " rad - cabine_vitesse : " +str(round(cabine_vitesse, 3))+" mm/s - moteur_vitesse : " +str(round(mot_vitesse, 3))+
-    #        " rad/s - cabine_pas : " +str(round(cabine_pas, 3))+" mm/impulsion - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
-    # print ("")
 
-    # # Descendre
+        # Aller au niveau 1 
-    # mot_digitset ()  # 5 tr/s 
+        if ba_1() and pc_1() ==False:
-    # t0,z0, a0= get('t'), get('cabine_z'), get('mot_angle')
+            print ("Déplacement pour le niveau 1 ...")
-    # print ("Début descendre :  cabine_z : "+str(round(z0, 3)) + " - mot_angle : " + str(round(a0, 3)))
+            voy_1(True)
-    # while pc_0() ==False :
+            while pc_1() ==False:
-    #     voy_0(True)
+                mot_d(False)
-    #     mot_m(False)
+                mot_m(True)
-    #     mot_d(True)
+                tempo(0.1)
-    #     mot_pas, mot_vitesse, cabine_pas, cabine_vitesse= get('mot_pas'), get('mot_vitesse'), get('cabine_pas'), get('cabine_vitesse')
+            mot_m(False)
-    # mot_d(False)
+            tempo(2) # Temporisation 2s
-    # voy_0(False)
+            voy_1(False)
-    # t1,z1, a1= get('t'), get('cabine_z'), get('mot_angle')
+            print ("Déplacement pour le niveau 1 : Ok")
-    # print ("Fin descendre :  cabine_z : "+str(round(z1, 3)) + " - mot_angle : " + str(round(a1, 3)))
+            print ("Attente")
-    # print ("")
+
-    # print ("Descendre : "+str(round(t1-t0, 3)) +" s - distance : " +str(round(z1-z0, 3))+" mm - angle : " +str(round(a1-a0, 3))+
+        tempo(0.1)
-    #        " rad - cabine_vitesse : " +str(round(cabine_vitesse, 3))+" mm/s - moteur_vitesse : " +str(round(mot_vitesse, 3))+
-    #        " rad/s - cabine_pas : " +str(round(cabine_pas, 3))+" mm/impulsion - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
 
-    # plot(['mot_angle', 'mot_vitesse', ['cabine_z', 'cabine_vitesse']])
-    # plot([['mot_angle', 'mot_vitesse']])
-    plot(['mot_angle', 'mot_vitesse'])
-    # plot(['mot_angle'])
     fin() # A garder
 
 ###############################################################################

portail_coulissant/porcou_cmd-autoprog.py

@@ -0,0 +1,145 @@
+from porcou_lib import * # Bibliothèque utilisateur du portail coulissant
+
+###############################################################################
+# porcou_cmd-autoprog.py
+# @title: Script de test pour le jumelage du portail coulissant à la maquette réelle A4 Technologie
+###############################################################################
+
+###############################################################################
+# Instructions élémentaires pour le portail coulissant
+#
+# Actions (ordre = True ou False) :
+# - Gyrophare : gyr(True | False)
+# - Ouvrir le portail (moteur sens trigo) : mot_o(True | False)
+# - Fermer le portail (moteur sens horaire) : mot_f(True | False)
+# - Définir la vitesse du moteur : mot_vitesse (vitesse) , vitesse en rad / s, si vitesse est omis la valeur par défaut est 125.6 rad /s ( 20 tr / s ))
+# - Emetteur pour le capteur barrage IR  : ir_emet(True | False)
+#
+# Capteurs (valeur retournée = True ou False) :
+# - Capteur fin de course portail ouvert : fdc_o()
+# - Capteur fin de course portail fermé : fdc_f()
+# - Capteur barrage IR  (absence d'obstacle) : ir_recep()
+#
+# Consignes du pupitre (valeur retournée = True ou False) :
+# - Bouton poussoir coté rue : bp_ext()
+# - Bouton poussoir coté cour : bp_int()
+#
+# Gestion du temps :
+# - Temporisation en seconde : tempo(duree)
+# - Réinitialisation de la valeur du temp (t)  : reset_t()
+#
+# Acquisition de données :
+# - Lancer l'enregistrement : daq([variable1, variable2, ... ])
+# - Afficher les graphiques : plot([variable1, variable2, ... ])
+#
+# Jumelage :
+# - Démarrer le jumelage : jumeau({brochage})
+# - Arrêter le jumelage : jumeau_stop({brochage})
+# - Définir les règles d'activation : jumeau_mode({brochage})
+#
+###############################################################################
+
+# 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']}
+
+###############################################################################
+# Fonctions
+###############################################################################
+
+###############################################################################
+# Commandes
+###############################################################################
+
+def commandes():
+
+    # Init -> Ouverture
+    while fdc_o() ==False :
+        gyr(True)
+        mot_f(False)
+        mot_o(True)
+    mot_o(False)
+    gyr(False)
+    print ("")
+
+    # Données
+    # daq(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
+    reset_t()
+
+    # 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'])
+    # 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'])
+
+    # plot(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
+    
+    # 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']])
+
+    # Jumelage
+    jumeau(brochage)
+    # jumeau_mode()
+    # jumeau_mode(True,True, False, False)
+    # jumeau_mode(True,True, True, True)
+
+    # jumeau_mode_object ('gyr', False, True)
+    gyr(False)
+    while True :
+
+        jumeau_mode_object ('gyr', False, True)
+        gyr(True)
+        print ('gyr Numérique')
+        tempo(0.5)
+        jumeau_mode_object ('gyr', True, True)
+        gyr(False)
+        tempo(0.1)
+        
+        jumeau_mode_object ('gyr', True, False)
+        gyr(True)
+        print (('gyr Physique'))
+        tempo(0.5)
+        jumeau_mode_object ('gyr', True, True)
+        gyr(False)
+        tempo(0.1)
+                
+        if bp_ext():
+            break
+
+    # Fermeture
+    mot_vitesse (1256)  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+    while fdc_f() ==False :
+        gyr(True)
+        mot_o(False)
+        mot_f(True)
+    mot_f(False)
+    gyr(False)
+
+    tempo(1)
+    jumeau_mode_object ('gyr', True, False)
+    tempo(1)
+
+    # jumeau_mode(True, True, True, True)
+       
+    # Ouverture
+    mot_vitesse ()  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+    mot_vitesse (2000)  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+    while fdc_o() ==False :
+        gyr(True)
+        mot_f(False)
+        mot_o(True)
+    mot_o(False)
+    gyr(False)
+    tempo(1)
+
+    fin() # A garder
+
+###############################################################################
+# En: External call << DONT CHANGE THIS SECTION >>
+# Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+###############################################################################
+
+if __name__=='start':
+    start(commandes)
+if __name__=='stop':
+    stop()

portail_coulissant/porcou_cmd-grove.py

@@ -0,0 +1,113 @@
+from porcou_lib import * # Bibliothèque utilisateur du portail coulissant
+
+###############################################################################
+# porcou_cmd-grove.py
+# @title: Commandes du portail coulissant
+# @title: Script de test pour le jumelage du portail coulissant à des composants Grove
+###############################################################################
+
+###############################################################################
+# Instructions élémentaires pour le portail coulissant
+#
+# Actions (ordre = True ou False) :
+# - Gyrophare : gyr(True | False)
+# - Ouvrir le portail (moteur sens trigo) : mot_o(True | False)
+# - Fermer le portail (moteur sens horaire) : mot_f(True | False)
+# - Définir la vitesse du moteur : mot_vitesse (vitesse) , vitesse en rad / s, si vitesse est omis la valeur par défaut est 125.6 rad /s ( 20 tr / s ))
+# - Emetteur pour le capteur barrage IR  : ir_emet(True | False)
+#
+# Capteurs (valeur retournée = True ou False) :
+# - Capteur fin de course portail ouvert : fdc_o()
+# - Capteur fin de course portail fermé : fdc_f()
+# - Capteur barrage IR  (absence d'obstacle) : ir_recep()
+#
+# Consignes du pupitre (valeur retournée = True ou False) :
+# - Bouton poussoir coté rue : bp_ext()
+# - Bouton poussoir coté cour : bp_int()
+#
+# Gestion du temps :
+# - Temporisation en seconde : tempo(duree)
+# - Réinitialisation de la valeur du temp (t)  : reset_t()
+#
+# Acquisition de données :
+# - Lancer l'enregistrement : daq([variable1, variable2, ... ])
+# - Afficher les graphiques : plot([variable1, variable2, ... ])
+#
+# Jumelage :
+# - Démarrer le jumelage : jumeau({brochage})
+# - Arrêter le jumelage : jumeau_stop({brochage})
+# - Définir les règles d'activation : jumeau_mode({brochage})
+#
+###############################################################################
+
+# Brochage du portail coulissant (Grove)
+brochage={
+    '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
+###############################################################################
+
+###############################################################################
+# Commandes
+###############################################################################
+
+def commandes():
+
+    # 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)
+
+    # Jumelage
+    jumeau(brochage)
+    jumeau_mode(True, True, True, True)
+
+    # Fonctionnement normal
+    print ("Attente")
+    while True :
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+        
+        # Ouverture
+        if bp_int() or bp_ext()  :
+            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
+            mot_o(False)
+
+            print ("Temporisation")
+            tempo(2) # Temporisation
+
+            # Fermeture
+            print ("Fermeture")
+            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")
+
+    fin() # A garder
+
+###############################################################################
+# En: External call << DONT CHANGE THIS SECTION >>
+# Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+###############################################################################
+
+if __name__=='start':
+    start(commandes)
+if __name__=='stop':
+    stop()

portail_coulissant/porcou_cmd-test.py

@@ -0,0 +1,161 @@
+from porcou_lib import * # Bibliothèque utilisateur du portail coulissant
+
+###############################################################################
+# porcou_cmd.py
+# @title: Commandes du portail coulissant
+###############################################################################
+
+###############################################################################
+# Instructions élémentaires pour le portail coulissant
+#
+# Actions (ordre = True ou False) :
+# - Gyrophare : gyr(True | False)
+# - Ouvrir le portail (moteur sens trigo) : mot_o(True | False)
+# - Fermer le portail (moteur sens horaire) : mot_f(True | False)
+# - Définir la vitesse du moteur : mot_vitesse (vitesse) , vitesse en rad / s, si vitesse est omis la valeur par défaut est 125.6 rad /s ( 20 tr / s ))
+# - Emetteur pour le capteur barrage IR  : ir_emet(True | False)
+#
+# Capteurs (valeur retournée = True ou False) :
+# - Capteur fin de course portail ouvert : fdc_o()
+# - Capteur fin de course portail fermé : fdc_f()
+# - Capteur barrage IR  (absence d'obstacle) : ir_recep()
+#
+# Consignes du pupitre (valeur retournée = True ou False) :
+# - Bouton poussoir coté rue : bp_ext()
+# - Bouton poussoir coté cour : bp_int()
+#
+# Gestion du temps :
+# - Temporisation en seconde : tempo(duree)
+# - Réinitialisation de la valeur du temp (t)  : reset_t()
+#
+# Acquisition de données :
+# - Lancer l'enregistrement : daq([variable1, variable2, ... ])
+# - Afficher les graphiques : plot([variable1, variable2, ... ])
+#
+# Jumelage :
+# - Démarrer le jumelage : jumeau({brochage})
+# - Arrêter le jumelage : jumeau_stop({brochage})
+# - Définir les règles d'activation : jumeau_mode({brochage})
+#
+###############################################################################
+
+# Brochage du portail coulissant (Grove)
+# brochage={
+#     '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']}
+
+# 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 vierge
+# brochage={
+#     'bp_ext' : [],'bp_int' : [],
+#     'fdc_o' : [],'fdc_f' : [],
+#     'mot_o' : [],'mot_f' : [],
+#     'gyr' : [],
+#     'ir_emet' : [],'ir_recep' : []}
+
+###############################################################################
+# Fonctions
+###############################################################################
+
+###############################################################################
+# Commandes
+###############################################################################
+
+def commandes():
+
+    # Init -> Ouverture
+    while fdc_o() ==False :
+        gyr(True)
+        mot_f(False)
+        mot_o(True)
+    mot_o(False)
+    gyr(False)
+    print ("")
+
+    # Données
+    # daq(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
+    reset_t()
+
+    # 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'])
+    # 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'])
+
+    # plot(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
+    
+    # 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']])
+
+    # Jumelage
+    # jumeau(brochage)
+    # jumeau_mode()
+    # jumeau_mode(True,True, False, False)
+    # jumeau_mode(True,True, True, True)
+
+    # jumeau_mode_object ('gyr', False, True)
+    gyr(False)
+    while True :
+
+        jumeau_mode_object ('gyr', False, True)
+        gyr(True)
+        print ('gyr Numérique')
+        tempo(0.5)
+        jumeau_mode_object ('gyr', True, True)
+        gyr(False)
+        tempo(0.1)
+        
+        jumeau_mode_object ('gyr', True, False)
+        gyr(True)
+        print (('gyr Physique'))
+        tempo(0.5)
+        jumeau_mode_object ('gyr', True, True)
+        gyr(False)
+        tempo(0.1)
+                
+        if bp_ext():
+            break
+
+    # Fermeture
+    mot_vitesse (1256)  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+    while fdc_f() ==False :
+        gyr(True)
+        mot_o(False)
+        mot_f(True)
+    mot_f(False)
+    gyr(False)
+
+    tempo(1)
+    jumeau_mode_object ('gyr', True, False)
+    tempo(1)
+
+    # jumeau_mode(True, True, True, True)
+       
+    # Ouverture
+    mot_vitesse ()  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+    mot_vitesse (2000)  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+    while fdc_o() ==False :
+        gyr(True)
+        mot_f(False)
+        mot_o(True)
+    mot_o(False)
+    gyr(False)
+    tempo(1)
+
+    fin() # A garder
+
+###############################################################################
+# En: External call << DONT CHANGE THIS SECTION >>
+# Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+###############################################################################
+
+if __name__=='start':
+    start(commandes)
+if __name__=='stop':
+    stop()

portail_coulissant/porcou_cmd.py

@@ -1,8 +1,9 @@
 from porcou_lib import * # Bibliothèque utilisateur du portail coulissant
 
 ###############################################################################
-# porcou_cmd.py
+# porcou_cmd-grove.py
 # @title: Commandes du portail coulissant
+# @title: Script de test pour le jumelage du portail coulissant à des composants Grove
 ###############################################################################
 
 ###############################################################################
@@ -44,24 +45,8 @@ brochage={
     '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'],
+    'gyr' : ['d',4,'o']}
-    'ir_emet' : ['d',2,'o'],'ir_recep' : ['a',3,'i']}
+    # 'ir_emet' : ['d',2,'o'],'ir_recep' : ['a',3,'i']}
-
-# 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 vierge
-# brochage={
-#     'bp_ext' : [],'bp_int' : [],
-#     'fdc_o' : [],'fdc_f' : [],
-#     'mot_o' : [],'mot_f' : [],
-#     'gyr' : [],
-#     'ir_emet' : [],'ir_recep' : []}
 
 ###############################################################################
 # Fonctions
@@ -73,57 +58,9 @@ brochage={
 
 def commandes():
 
-    # Init -> Ouverture
+    # Mise en place : Fermeture
-    while fdc_o() ==False :
+    print ("Version sans sécurité : sans réouverture")
-        gyr(True)
+    print ("Mise en place : Fermeture")
-        mot_f(False)
-        mot_o(True)
-    mot_o(False)
-    gyr(False)
-    print ("")
-
-    # Données
-    # daq(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
-    reset_t()
-
-    # 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'])
-    # 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'])
-
-    # plot(['mot_angle', 'mot_vitesse', 'portail_x', 'portail_vitesse'])
-    
-    # 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']])
-
-    # Jumelage
-    jumeau(brochage)
-    # jumeau_mode()
-    # jumeau_mode(True,True, False, False)
-    # jumeau_mode(True,True, True, True)
-
-    # jumeau_mode_object ('gyr', False, True)
-    gyr(False)
-    while True :
-
-        jumeau_mode_object ('gyr', False, True)
-        gyr(True)
-        print ('gyr Numérique')
-        tempo(0.5)
-        jumeau_mode_object ('gyr', True, True)
-        gyr(False)
-        tempo(0.1)
-        
-        jumeau_mode_object ('gyr', True, False)
-        gyr(True)
-        print (('gyr Physique'))
-        tempo(0.5)
-        jumeau_mode_object ('gyr', True, True)
-        gyr(False)
-        tempo(0.1)
-                
-        if bp_ext():
-            break
-
-    # Fermeture
-    mot_vitesse (1256)  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
     while fdc_f() ==False :
         gyr(True)
         mot_o(False)
@@ -131,22 +68,37 @@ def commandes():
     mot_f(False)
     gyr(False)
 
-    tempo(1)
+    # Jumelage
-    jumeau_mode_object ('gyr', True, False)
+    jumeau(brochage)
-    tempo(1)
+    jumeau_mode(True, True, True, True)
 
-    # jumeau_mode(True, True, True, True)
+    # Fonctionnement normal
-       
+    print ("Attente")
-    # Ouverture
+    while True :
-    mot_vitesse ()  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
-    mot_vitesse (2000)  # Vitesse par défaut 125,6 rad /s ( 20 tr / s )
+        
-    while fdc_o() ==False :
+        # Ouverture
-        gyr(True)
+        if bp_int() or bp_ext()  :
-        mot_f(False)
+            print ("Ouverture")
-        mot_o(True)
+            while fdc_o() ==False:
-    mot_o(False)
+                gyr(True)
-    gyr(False)
+                mot_f(False)
-    tempo(1)
+                mot_o(True)
+                tempo(0.1) # Donne du temps à communication avec le jumeau réel
+            mot_o(False)
+
+            print ("Temporisation")
+            tempo(2) # Temporisation
+
+            # Fermeture
+            print ("Fermeture")
+            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")
 
     fin() # A garder
 

twin.py

@@ -665,7 +665,7 @@ def cycle_click(cont):
 
 
 ##
-# Click sur les éléments comutables  du système (activation numérique)
+# Click sur les éléments commutables  du système (activation numérique)
 ##
 
 def cycle_switch(cont):
@@ -709,10 +709,12 @@ def cycle_switch(cont):
 
 ##
 # Couleurs sur les éléments sensibles du système
+# obj : objet numérique
+# obj_on : objet numérique à l'état activé (si différent)
 ##
 
-def cycle_sensitive_color(obj):
+def cycle_sensitive_color(obj, obj_on=None):
-
+    
     # Mouse over
     if obj['mo'] == True and obj['click'] == False and obj.color !=color_hl:
         obj.color =color_hl
@@ -723,10 +725,14 @@ def cycle_sensitive_color(obj):
             obj.color =color_active
         elif obj['activated_real'] and obj['activated']  and obj.color !=color_activated_dbl:
             obj.color =color_activated_dbl
+            if obj_on is not None:
+                obj_on.color =color_activated_dbl
         elif obj['activated_real'] and obj['activated']==False  and obj.color !=color_activated_real:
             obj.color =color_activated_real
         elif obj['activated_real'] ==False and obj['activated']  and obj.color !=color_activated:
             obj.color =color_activated
+            if obj_on is not None:
+                obj_on.color =color_activated
         elif obj['activated_real'] ==False and obj['activated']==False  and obj.color !=color_activated:
             obj.color =color_active
 
@@ -776,6 +782,7 @@ def cycle_bp(cont):
 
 def cycle_bg(cont):
     obj = cont.owner
+    obj_on=scene.objects[obj.name+"-on"]
 
     # Arduino -> Modele 3D
     if scene.objects['System']['twins'] and obj['prior_real']:
@@ -786,8 +793,26 @@ def cycle_bg(cont):
                 obj['activated_real'] = False
 
         # Couleurs
-        # FIXME à verifier
+        cycle_sensitive_color(obj, obj_on)
-        cycle_sensitive_color(obj)
+
+##
+# Comportement standard des capteurs (analogique)
+##
+
+def cycle_sensor(cont):
+    obj = cont.owner
+
+    # Physique du modèle 3D
+    if scene.objects['System']['run']:
+        if obj['activated'] and obj['value']!=obj['value_click']:
+            obj['value']=obj['value_click']
+        if obj['activated']==False and obj['value']!=obj['value_unclick']:
+            obj['value']=obj['value_unclick']
+
+    # Arduino -> Modele 3D
+    if scene.objects['System']['twins'] and obj['prior_real']:
+        if  obj['pin'] is not None :
+            obj['value_real'] = obj['pin'].read()
 
 ##
 # Comportement standard des voyants

twin_config.xml

@@ -1,7 +1,7 @@
 <data>
     <screen>
-	<width>1590</width>
+	<width>1071</width>
-	<height>895</height>
+	<height>602</height>
 	<quality>1</quality>
     </screen>
     <plot>

twin_serial.py

@@ -93,6 +93,8 @@ def  serial_open():
 
     # Mise en place de la carte
     speed = 57600
+    # speed = 115200
+    # speed = 9600
     [device, board_name] =autoget_port() # Recherche automatique du port
     if device is None:
         scene.objects['System']['twins'] = False

volet_roulant/volrou.py

@@ -50,8 +50,8 @@ public_vars = {
     'bg_auto' : [['Bg auto','activated','d'], ['pin', 'd','i'], []],
     'bg_auto_r' : [['Bg auto','activated_real','d'], [], []],
     'voy_auto' : [['Led auto','activated','d'], ['pin', 'd','o'], []],
-    'lum' : [['Recepteur LDR','activated','a'], ['pin', 'd','i'], []], # FIXME : Basculer en analogique
+    'lum' : [['Recepteur LDR','value','a'], ['pin', 'a','i'], []],
-    'lum_r' : [['Recepteur LDR','activated_real','a'], [], []]}
+    'lum_r' : [['Recepteur LDR','value_real','a'], [], []]}
 
 # Couleurs
 color_passive = (0.800, 0.005, 0.315,1) # bouton non activable :  magenta
@@ -437,10 +437,12 @@ def system_reset ():
     runpy.run_path(scene.objects['System']['script'], run_name='init')
 
     # Entrées à l'état initial
-    objs= ['Bp monter', 'Bp arret', 'Bp descendre', 'Bp auto', 'Bg auto', 'Microrupteur haut','Microrupteur bas', 'Recepteur LDR']
+    objs= ['Bp monter', 'Bp arret', 'Bp descendre', 'Bp auto', 'Bg auto', 'Microrupteur haut','Microrupteur bas']
     for obj in objs:
         scene.objects[obj]['activated']=False
         scene.objects[obj]['activated_real']=False
+    scene.objects['Recepteur LDR']['value']=0
+    scene.objects['Recepteur LDR']['value_real']=0
     scene.objects['Bg auto-on'].setVisible(False,False)
 
     # Voyants aux états initiaux

volet_roulant/volrou_cmd-grove.py

@@ -0,0 +1,151 @@
+from volrou_lib import * # Bibliothèque volet roulant
+
+###############################################################################
+# volrou_cmd-correction-grove.py
+# @title: Script de test pour le jumelage du volet roulant à des composants Grove
+###############################################################################
+
+###############################################################################
+# Instructions élémentaires pour le volet roulant
+#
+# Actions (ordre = True ou False) :
+# - Monter le volet (moteur sens trigo) : mot_m(True | False)
+# - Descendre le volet (moteur sens horaire) : mot_d(True | False)
+#
+# Capteurs (valeur retournée = True ou False) :
+# - Capteur fin de course volet en haut : fdc_h()
+# - Capteur fin de course volet en bas : fdc_b()
+# - Capteur de luminosité (LDR) : lum()
+#
+# Consignes du pupitre (valeur retournée = True ou False) :
+# - Bouton poussoir monter volet : bp_m()
+# - Bouton poussoir arrêt volet : bp_a()
+# - Bouton poussoir descendre volet : bp_d()
+# - Bouton poussoir mode automatique : bg_auto()
+#
+# Retour d'information du pupitre (allumer = True ou False) :
+# - Voyant témoin mode automatique : voy_auto(True | False)
+#
+# Gestion du temps :
+# - Temporisation en seconde : tempo(duree)
+#
+###############################################################################
+
+# Brochage du volet roulant
+brochage={
+    'bp_m' : ['a',1,'i'], 'bp_a' : ['a',0,'i'], 'bp_d' : ['a',2,'i'],
+    'fdc_h' : ['d',8,'i'], 'fdc_b' : ['d',7,'i'],
+    'mot_m' : ['d',5,'o'], 'mot_d' : ['d',6,'o'],
+    # 'bg_auto' : ['d',2,'i'], 'voy_auto' : ['d',4,'o']}
+    'bg_auto' : ['d',2,'i'], 'voy_auto' : ['d',4,'o'], 'lum' : ['a',3,'i']}
+
+###############################################################################
+# Fonctions
+###############################################################################
+
+###############################################################################
+# Commandes
+###############################################################################
+
+def commandes():
+
+    # Mise en place : Monter le volet
+    print ("Volet roulant mode manuel, mode auto avec temporisation")
+    print ("Mise en place : Monter le volet")
+    while fdc_h() ==False :
+        mot_d(False)
+        mot_m(True)
+    mot_m(False)
+
+    # Jumelage
+    carte=jumeau(brochage)
+    # print (carte)
+    # lum_broche = carte.get_pin('a:3:i')
+    # print (lum_broche)
+    
+    # Fonctionnement normal
+    print ("Attente")
+    presence_lum_tempo=0.0 # Temporisation pour la présence de lumière
+    absence_lum_tempo=0.0 # Temporisation pour l'absence de lumière
+
+    while True :
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+        # print ("lum_r, ", lum_broche.read())
+        # print ("lum_r, ", get('lum_r'))
+
+        # Mode manuel
+        if bg_auto()== False:
+            voy_auto(False)
+            absence_lum_tempo=0
+            presence_lum_tempo = 0
+
+            # Monter le volet
+            if bp_m():
+                print ("Mode manu : Monter le volet : mouvement")
+                mot_d(False)
+                mot_m(True)
+
+            # Descendre le volet
+            if bp_d():
+                print ("Mode manu : Descendre le volet : mouvement")
+                mot_m(False)
+                mot_d(True)
+
+            # Arrêt manuel
+            if bp_a():
+                print ("Mode manu : Arrêter le volet !")
+                mot_m(False)
+                mot_d(False)
+
+        else: # Mode automatique
+            voy_auto(True)
+            # print ("lum_r, ", get('lum_r'))
+            print ("lum(), ", lum())
+
+            # Monter le volet : présence de lumière
+            if lum() < 0.5 and fdc_h()==False and absence_lum_tempo < 2:
+                tempo(0.1) # 0,1 s
+                presence_lum_tempo=0
+                absence_lum_tempo=absence_lum_tempo+0.1
+                # print ("Mode auto : Monter le volet : temporisation :", absence_lum_tempo)
+
+            # Monter le volet : mouvement
+            if absence_lum_tempo >= 2: # Temporisation de 2 s
+                # print ("Mode auto : Monter le volet : mouvement")
+                mot_d(False)
+                mot_m(True)
+
+            # Descendre le volet : absence de lumière
+            if lum() > 0.5 and fdc_b()==False and presence_lum_tempo < 2:
+                tempo(0.1) # 0,1 s
+                absence_lum_tempo=0
+                presence_lum_tempo=presence_lum_tempo+0.1
+                # print ("Mode auto : Descendre le volet : temporisation :", presence_lum_tempo)
+
+            # Descendre le volet : mouvement
+            if presence_lum_tempo >= 2: # Temporisation de 2 s
+                # print ("Mode auto : Descendre le volet : mouvement")
+                mot_m(False)
+                mot_d(True)
+
+        # Arrêt du moteur 
+        if fdc_h() :
+            mot_m(False)
+            absence_lum_tempo=0
+        if fdc_b() :
+            mot_d(False)
+            presence_lum_tempo=0
+    
+    fin() # A garder
+
+###############################################################################
+# En: External call << DONT CHANGE THIS SECTION >>
+# Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+###############################################################################
+
+if __name__=='start':
+    start(commandes)
+if __name__=='stop':
+    stop()
+if __name__=='init':
+    variant(2) # Variante 1 de la maquette 3D du volet roulant

volet_roulant/volrou_cmd-test.py

@@ -0,0 +1,115 @@
+from volrou_lib import * # Bibliothèque utilisateur du volet roulant
+
+###############################################################################
+# volrou_cmd.py
+# @title: Commandes du volet roulant
+###############################################################################
+
+###############################################################################
+# Instructions élémentaires pour le volet roulant
+#
+# Actions (ordre = True ou False) :
+# - Monter le volet (moteur sens trigo) : mot_m(True | False)
+# - Descendre le volet (moteur sens horaire) : mot_d(True | False)
+#
+# Capteurs (valeur retournée = True ou False) :
+# - Capteur fin de course volet en haut : fdc_h()
+# - Capteur fin de course volet en bas : fdc_b()
+# - Capteur de luminosité (LDR) : lum()
+#
+# Consignes du pupitre (valeur retournée = True ou False) :
+# - Bouton poussoir monter volet : bp_m()
+# - Bouton poussoir arrêt volet : bp_a()
+# - Bouton poussoir descendre volet : bp_d()
+# - Bouton poussoir mode automatique : bp_auto() (variante 1)
+# - Bouton à glissière mode automatique : bg_auto() (variante 2)
+#
+# Retour d'information du pupitre (allumer = True ou False) :
+# - Voyant témoin mode automatique : voy_auto(True | False)
+#
+# Gestion du temps :
+# - Temporisation en seconde : tempo(duree)
+#
+###############################################################################
+
+###############################################################################
+# Fonctions
+###############################################################################
+
+###############################################################################
+# Commandes
+###############################################################################
+
+def commandes():
+
+    daq(['bg_auto', 'voy_auto'])
+    plot (['bg_auto', 'voy_auto'])
+
+    while True:
+        if bg_auto():
+            voy_auto(True) # Activer le voyant du mode automatique
+        else:
+            voy_auto(False)
+
+    daq(['mot_angle', 'mot_vitesse'])
+    plot (['mot_angle', 'mot_vitesse'])
+    # plot ([['mot_angle', 'mot_vitesse']])
+    # jumeau_mode(True,True, True, False)
+    
+    # Init -> Descendre
+    while fdc_b() ==False :
+        mot_m(False)
+        mot_d(True)
+    mot_d(False)
+    print ("")
+    
+    # Monter
+    # mot_vitesse (500)
+    t0, a0= get('t'), get('mot_angle')
+    print ("Début monter :  mot_angle : " + str(round(a0, 3)))
+    while fdc_h() ==False :
+        mot_d(False)
+        mot_m(True)
+        mot_angle, mot_pas, mot_vitesse = get('mot_angle'),  get('mot_pas'), get('mot_vitesse')
+        # if abs(mot_vitesse)>0:
+        #     print ("Monter : mot_angle : "+ str(round(mot_angle, 3)) + " rad - mot_vitesse : "+ str(round(mot_vitesse, 3)) + " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
+    mot_m(False)
+    t1, a1= get('t'), get('mot_angle')
+    print ("Fin monter :  mot_angle : " + str(round(a1, 3)))
+    print ("")
+    print ("Monter : "+str(round(t1-t0, 3)) +" s - angle : " +str(round(a1-a0, 3)) + " rad - moteur_vitesse : " +str(round(mot_vitesse, 3))+
+           " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
+    print ("")
+
+    # Descendre
+    # mot_vitesse ()  # 20 tr/s 
+    t0, a0= get('t'), get('mot_angle')
+    print ("Début descendre :  mot_angle : " + str(round(a0, 3)))
+    while fdc_b() ==False :
+        mot_m(False)
+        mot_d(True)
+        mot_angle, mot_pas, mot_vitesse = get('mot_angle'),  get('mot_pas'), get('mot_vitesse')
+        # if abs(mot_vitesse)>0:
+        #     print ("Monter : mot_angle : "+ str(round(mot_angle, 3)) + " rad - mot_vitesse : "+ str(round(mot_vitesse, 3)) + " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
+    mot_d(False)
+    t1, a1= get('t'), get('mot_angle')
+    print ("Fin descendre :  mot_angle : " + str(round(a1, 3)))
+    print ("")
+    print ("Descendre : "+str(round(t1-t0, 3)) +" s - angle : " +str(round(a1-a0, 3)) + " rad - moteur_vitesse : " +str(round(mot_vitesse, 3))+
+           " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
+
+
+    fin() # A garder
+
+
+###############################################################################
+# En: External call << DONT CHANGE THIS SECTION >>
+# Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
+###############################################################################
+
+if __name__=='start':
+    start(commandes)
+if __name__=='stop':
+    stop()
+if __name__=='init':
+    variant(2) # Variante 2 de la maquette 3D du volet roulant

volet_roulant/volrou_cmd.py

@@ -1,8 +1,8 @@
-from volrou_lib import * # Bibliothèque utilisateur du volet roulant
+from volrou_lib import * # Bibliothèque volet roulant
 
 ###############################################################################
-# volrou_cmd.py
+# volrou_cmd-correction-grove.py
-# @title: Commandes du volet roulant
+# @title: Script de test pour le jumelage du volet roulant à des composants Grove
 ###############################################################################
 
 ###############################################################################
@@ -21,8 +21,7 @@ from volrou_lib import * # Bibliothèque utilisateur du volet roulant
 # - Bouton poussoir monter volet : bp_m()
 # - Bouton poussoir arrêt volet : bp_a()
 # - Bouton poussoir descendre volet : bp_d()
-# - Bouton poussoir mode automatique : bp_auto() (variante 1)
+# - Bouton poussoir mode automatique : bg_auto()
-# - Bouton à glissière mode automatique : bg_auto() (variante 2)
 #
 # Retour d'information du pupitre (allumer = True ou False) :
 # - Voyant témoin mode automatique : voy_auto(True | False)
@@ -32,6 +31,14 @@ from volrou_lib import * # Bibliothèque utilisateur du volet roulant
 #
 ###############################################################################
 
+# Brochage du volet roulant
+brochage={
+    'bp_m' : ['a',1,'i'], 'bp_a' : ['a',0,'i'], 'bp_d' : ['a',2,'i'],
+    'fdc_h' : ['d',8,'i'], 'fdc_b' : ['d',7,'i'],
+    'mot_m' : ['d',5,'o'], 'mot_d' : ['d',6,'o'],
+    # 'bg_auto' : ['d',2,'i'], 'voy_auto' : ['d',4,'o']}
+    'bg_auto' : ['d',2,'i'], 'voy_auto' : ['d',4,'o'], 'lum' : ['a',3,'i']}
+
 ###############################################################################
 # Fonctions
 ###############################################################################
@@ -42,66 +49,95 @@ from volrou_lib import * # Bibliothèque utilisateur du volet roulant
 
 def commandes():
 
-    daq(['bg_auto', 'voy_auto'])
+    # Mise en place : Monter le volet
-    plot (['bg_auto', 'voy_auto'])
+    print ("Volet roulant mode manuel, mode auto avec temporisation")
-
+    print ("Mise en place : Monter le volet")
-    while True:
-        if bg_auto():
-            voy_auto(True) # Activer le voyant du mode automatique
-        else:
-            voy_auto(False)
-
-    daq(['mot_angle', 'mot_vitesse'])
-    plot (['mot_angle', 'mot_vitesse'])
-    # plot ([['mot_angle', 'mot_vitesse']])
-    # jumeau_mode(True,True, True, False)
-    
-    # Init -> Descendre
-    while fdc_b() ==False :
-        mot_m(False)
-        mot_d(True)
-    mot_d(False)
-    print ("")
-    
-    # Monter
-    # mot_vitesse (500)
-    t0, a0= get('t'), get('mot_angle')
-    print ("Début monter :  mot_angle : " + str(round(a0, 3)))
     while fdc_h() ==False :
         mot_d(False)
         mot_m(True)
-        mot_angle, mot_pas, mot_vitesse = get('mot_angle'),  get('mot_pas'), get('mot_vitesse')
-        # if abs(mot_vitesse)>0:
-        #     print ("Monter : mot_angle : "+ str(round(mot_angle, 3)) + " rad - mot_vitesse : "+ str(round(mot_vitesse, 3)) + " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
     mot_m(False)
-    t1, a1= get('t'), get('mot_angle')
-    print ("Fin monter :  mot_angle : " + str(round(a1, 3)))
-    print ("")
-    print ("Monter : "+str(round(t1-t0, 3)) +" s - angle : " +str(round(a1-a0, 3)) + " rad - moteur_vitesse : " +str(round(mot_vitesse, 3))+
-           " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
-    print ("")
 
-    # Descendre
+    # Jumelage
-    # mot_vitesse ()  # 20 tr/s 
+    carte=jumeau(brochage)
-    t0, a0= get('t'), get('mot_angle')
+    # print (carte)
-    print ("Début descendre :  mot_angle : " + str(round(a0, 3)))
+    # lum_broche = carte.get_pin('a:3:i')
-    while fdc_b() ==False :
+    # print (lum_broche)
-        mot_m(False)
+    
-        mot_d(True)
+    # Fonctionnement normal
-        mot_angle, mot_pas, mot_vitesse = get('mot_angle'),  get('mot_pas'), get('mot_vitesse')
+    print ("Attente")
-        # if abs(mot_vitesse)>0:
+    presence_lum_tempo=0.0 # Temporisation pour la présence de lumière
-        #     print ("Monter : mot_angle : "+ str(round(mot_angle, 3)) + " rad - mot_vitesse : "+ str(round(mot_vitesse, 3)) + " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
+    absence_lum_tempo=0.0 # Temporisation pour l'absence de lumière
-    mot_d(False)
-    t1, a1= get('t'), get('mot_angle')
-    print ("Fin descendre :  mot_angle : " + str(round(a1, 3)))
-    print ("")
-    print ("Descendre : "+str(round(t1-t0, 3)) +" s - angle : " +str(round(a1-a0, 3)) + " rad - moteur_vitesse : " +str(round(mot_vitesse, 3))+
-           " rad/s - moteur_pas : " +str(round(mot_pas, 3))+" rad/impulsion")
 
+    while True :
+        tempo(0.1) # Donne du temps à communication avec le jumeau réel
+        # print ("lum_r, ", lum_broche.read())
+        # print ("lum_r, ", get('lum_r'))
 
+        # Mode manuel
+        if bg_auto()== False:
+            voy_auto(False)
+            absence_lum_tempo=0
+            presence_lum_tempo = 0
+
+            # Monter le volet
+            if bp_m():
+                print ("Mode manu : Monter le volet : mouvement")
+                mot_d(False)
+                mot_m(True)
+
+            # Descendre le volet
+            if bp_d():
+                print ("Mode manu : Descendre le volet : mouvement")
+                mot_m(False)
+                mot_d(True)
+
+            # Arrêt manuel
+            if bp_a():
+                print ("Mode manu : Arrêter le volet !")
+                mot_m(False)
+                mot_d(False)
+
+        else: # Mode automatique
+            voy_auto(True)
+            # print ("lum_r, ", get('lum_r'))
+            print ("lum(), ", lum())
+
+            # Monter le volet : présence de lumière
+            if lum() < 0.5 and fdc_h()==False and absence_lum_tempo < 2:
+                tempo(0.1) # 0,1 s
+                presence_lum_tempo=0
+                absence_lum_tempo=absence_lum_tempo+0.1
+                # print ("Mode auto : Monter le volet : temporisation :", absence_lum_tempo)
+
+            # Monter le volet : mouvement
+            if absence_lum_tempo >= 2: # Temporisation de 2 s
+                # print ("Mode auto : Monter le volet : mouvement")
+                mot_d(False)
+                mot_m(True)
+
+            # Descendre le volet : absence de lumière
+            if lum() > 0.5 and fdc_b()==False and presence_lum_tempo < 2:
+                tempo(0.1) # 0,1 s
+                absence_lum_tempo=0
+                presence_lum_tempo=presence_lum_tempo+0.1
+                # print ("Mode auto : Descendre le volet : temporisation :", presence_lum_tempo)
+
+            # Descendre le volet : mouvement
+            if presence_lum_tempo >= 2: # Temporisation de 2 s
+                # print ("Mode auto : Descendre le volet : mouvement")
+                mot_m(False)
+                mot_d(True)
+
+        # Arrêt du moteur 
+        if fdc_h() :
+            mot_m(False)
+            absence_lum_tempo=0
+        if fdc_b() :
+            mot_d(False)
+            presence_lum_tempo=0
+    
     fin() # A garder
 
-
 ###############################################################################
 # En: External call << DONT CHANGE THIS SECTION >>
 # Fr: Appel externe << NE PAS MODIFIER CETTE SECTION >>
@@ -112,4 +148,4 @@ if __name__=='start':
 if __name__=='stop':
     stop()
 if __name__=='init':
-    variant(2) # Variante 2 de la maquette 3D du volet roulant
+    variant(2) # Variante 1 de la maquette 3D du volet roulant

volet_roulant/volrou_lib.py

@@ -55,6 +55,7 @@ def mot_vitesse (speed=125.6):
 
 ###############################################################################
 # Capteurs
+# Priorité à l'activation (binaire) ou la valeur la plus grande (numérique)
 ###############################################################################
 
 # Compte-rendu du capteur fin de course volet en haut
@@ -70,11 +71,10 @@ def fdc_b():
     return False
 
 # Compte-rendu du capteur de luminosité
-# FIXME : passer d'une valeur boolléenne à une valeur numérique
 def lum():
-    if scene.objects['Recepteur LDR']['activated'] or scene.objects['Recepteur LDR']['activated_real']:
+    if scene.objects['Recepteur LDR']['value'] > scene.objects['Recepteur LDR']['value_real']:
-        return True
+        return (scene.objects['Recepteur LDR']['value'])
-    return False
+    return (scene.objects['Recepteur LDR']['value_real'])
 
 ###############################################################################
 # Boutons poussoirs