mirror of
https://forge.apps.education.fr/blender-edutech/jumeaux-numeriques.git
synced 2024-01-27 06:56:18 +01:00
Ajout des scripts de test jumelage Grove et ajout des capteurs analogiques
This commit is contained in:
parent
f85393bd28
commit
77ddc843f9
@ -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_r' : [['Microrupteur niveau 0','activated','d'], ['pin', 'd','i'], []],
|
||||
'pc_0' : [['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'], []],
|
||||
|
||||
108
monte_charge/montchg_cmd-grove.py
Normal file
108
monte_charge/montchg_cmd-grove.py
Normal file
@ -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()
|
||||
115
monte_charge/montchg_cmd-test.py
Normal file
115
monte_charge/montchg_cmd-test.py
Normal file
@ -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()
|
||||
@ -1,8 +1,8 @@
|
||||
from montchg_lib import * # Bibliothèque utilisateur du monte-charge
|
||||
|
||||
###############################################################################
|
||||
# montchg_cmd.py
|
||||
# @title: Commandes du monte-charge
|
||||
# montchg_cmd-grove.py
|
||||
# @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)
|
||||
# Init -> Descendre
|
||||
# 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:
|
||||
voy_0(True)
|
||||
mot_m(False)
|
||||
mot_d(True)
|
||||
tempo(0.1)
|
||||
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)
|
||||
mot_d(False)
|
||||
tempo(2) # Temporisation 2s
|
||||
voy_0(False)
|
||||
print ("")
|
||||
print ("Déplacement pour le niveau 0 : Ok")
|
||||
print ("Attente")
|
||||
|
||||
# daq(['mot_angle', 'mot_vitesse', 'cabine_z', 'cabine_vitesse'])
|
||||
# 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)
|
||||
mot_m(False)
|
||||
tempo(2) # Temporisation 2s
|
||||
voy_1(False)
|
||||
print ("Déplacement pour le niveau 1 : Ok")
|
||||
print ("Attente")
|
||||
|
||||
# # 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 ("")
|
||||
tempo(0.1)
|
||||
|
||||
# # 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")
|
||||
|
||||
# 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
|
||||
|
||||
###############################################################################
|
||||
|
||||
Binary file not shown.
145
portail_coulissant/porcou_cmd-autoprog.py
Normal file
145
portail_coulissant/porcou_cmd-autoprog.py
Normal file
@ -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()
|
||||
113
portail_coulissant/porcou_cmd-grove.py
Normal file
113
portail_coulissant/porcou_cmd-grove.py
Normal file
@ -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()
|
||||
161
portail_coulissant/porcou_cmd-test.py
Normal file
161
portail_coulissant/porcou_cmd-test.py
Normal file
@ -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()
|
||||
@ -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'],
|
||||
'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' : []}
|
||||
'gyr' : ['d',4,'o']}
|
||||
# 'ir_emet' : ['d',2,'o'],'ir_recep' : ['a',3,'i']}
|
||||
|
||||
###############################################################################
|
||||
# Fonctions
|
||||
@ -73,57 +58,9 @@ brochage={
|
||||
|
||||
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 )
|
||||
# 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)
|
||||
@ -131,22 +68,37 @@ def commandes():
|
||||
mot_f(False)
|
||||
gyr(False)
|
||||
|
||||
tempo(1)
|
||||
jumeau_mode_object ('gyr', True, False)
|
||||
tempo(1)
|
||||
# Jumelage
|
||||
jumeau(brochage)
|
||||
jumeau_mode(True, True, True, True)
|
||||
|
||||
# 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
|
||||
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 )
|
||||
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)
|
||||
tempo(1)
|
||||
mot_f(False)
|
||||
print ("Attente")
|
||||
|
||||
fin() # A garder
|
||||
|
||||
|
||||
Binary file not shown.
33
twin.py
33
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,9 +709,11 @@ 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:
|
||||
@ -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)
|
||||
cycle_sensitive_color(obj, obj_on)
|
||||
|
||||
##
|
||||
# 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
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
<data>
|
||||
<screen>
|
||||
<width>1590</width>
|
||||
<height>895</height>
|
||||
<width>1071</width>
|
||||
<height>602</height>
|
||||
<quality>1</quality>
|
||||
</screen>
|
||||
<plot>
|
||||
|
||||
@ -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
|
||||
|
||||
Binary file not shown.
@ -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_r' : [['Recepteur LDR','activated_real','a'], [], []]}
|
||||
'lum' : [['Recepteur LDR','value','a'], ['pin', 'a','i'], []],
|
||||
'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
|
||||
|
||||
151
volet_roulant/volrou_cmd-grove.py
Normal file
151
volet_roulant/volrou_cmd-grove.py
Normal file
@ -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
|
||||
115
volet_roulant/volrou_cmd-test.py
Normal file
115
volet_roulant/volrou_cmd-test.py
Normal file
@ -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
|
||||
@ -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
|
||||
# @title: Commandes du volet roulant
|
||||
# volrou_cmd-correction-grove.py
|
||||
# @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 à glissière mode automatique : bg_auto() (variante 2)
|
||||
# - Bouton poussoir mode automatique : bg_auto()
|
||||
#
|
||||
# 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'])
|
||||
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)))
|
||||
# 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_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 :
|
||||
# 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)
|
||||
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")
|
||||
|
||||
# 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
|
||||
|
||||
@ -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']:
|
||||
return True
|
||||
return False
|
||||
if scene.objects['Recepteur LDR']['value'] > scene.objects['Recepteur LDR']['value_real']:
|
||||
return (scene.objects['Recepteur LDR']['value'])
|
||||
return (scene.objects['Recepteur LDR']['value_real'])
|
||||
|
||||
###############################################################################
|
||||
# Boutons poussoirs
|
||||
|
||||
Loading…
Reference in New Issue
Block a user