import bge # Bibliothèque Blender Game Engine (UPBGE) import runpy # Exécution de script Python légère (sans import) ############################################################################### # porcou_doc.py # @title: Documentation du portail coulissant # @project: Blender-EduTech # @lang: fr # @authors: Philippe Roy # @copyright: Copyright (C) 2020-2024 Philippe Roy # @license: GNU GPL ############################################################################### # UPBGE scene scene = bge.logic.getCurrentScene() # Texte en X : 426.474 m ################################################################################ # Documentation du système ################################################################################ system_card=["twins-card", "pin-card", "data-card", "daq-card", "movement-card", "sensor-card", "gyro-card", "board-card", "model-card", "firmata-card", "arduino-card"] system_card_description ={} # Jumeau numérique card_twins_title="Jumeau numérique" card_twins_text=""" jumeau(brochage) -> Démarrer le jumelage.\n "brochage" permet de faire le lien entre les \n deux jumeaux (voir la page "Brochage").\n jumeau_stop() -> Arrêter le jumelage.\n jumeau_mode(entrées réelles, entrées \n numériques, sorties réelles, sorties \n numériques) -> Définit les modes d'activation des entrées/sorties : \n - True pour activer (par défaut), \n - False pour désactiver.""" # Avec "carte=jumeau(brochage)", on peut \n utiliser l'objet 'carte' pour communiquer \n directement avec le protocole Firmata. # jumeau_config(port, vitesse) \n -> Définit la configuration de la liaison \n série.\n # Si le port n'est pas spécifié, il sera \n recherché automatiquement (carte \n Arduino Uno ou Mega). \n # La vitesse par défaut est 115200 baud.""" card_twins_url=[] system_card_description.update({"twins-card" : [card_twins_title, card_twins_text, card_twins_url]}) # Brochage card_pin_title="Brochage" card_pin_text_grove=""" Le brochage est un dictionnaire d'association \n des objets numériques aux broches réelles. brochage = { nom:[type, broche, mode] } : - nom : nom de l'objet 3D, - type : a (analogique) ou d (binaire), - broche : numéro de la broche de carte, - mode : i (entrée), o (sortie) ou p (pwm). Par exemple : brochage = { 'gyr':['d',3,'o'] }.\n Les objets numériques sont : 'gyr', 'bp_ext', \n 'bp_int', 'fdc_o', 'fdc_f', 'ir_emet' et 'ir_recep'. Pour le moteur (maquette Grove) : 'mot_s' \n (sens, 0 ou 1) et 'mot_v' (vitesse, 0 à 255).""" card_pin_text_autoprog=""" Le brochage est un dictionnaire d'association \n des objets numériques aux broches réelles. brochage = { nom:[type, broche, mode] } : - nom : nom de l'objet 3D, - type : a (analogique) ou d (binaire), - broche : numéro de la broche de carte, - mode : i (entrée), o (sortie) ou p (pwm). Par exemple : brochage = { 'gyr':['d',3,'o'] }.\n Les objets numériques sont : 'gyr', 'bp_ext', \n 'bp_int', 'fdc_o', 'fdc_f', 'ir_emet' et 'ir_recep'. Pour le moteur (maquette AutoProg) : \n 'mot_o' (ouvrir) et 'mot_f' (fermer) """ card_pin_url=[] system_card_description.update({"pin-card" : [card_pin_title, [card_pin_text_grove, card_pin_text_autoprog] , card_pin_url]}) # Deux descriptions # Données card_data_title="Accès aux données" card_data_text=""" get(variable) \n -> Retourne la valeur de la variable à \n l'instant t. Par exemple : val = get('bp_ext').\n Entrées/sorties : 'bp_ext', 'bp_int', 'fdc_o', \n 'fdc_f', 'mot_o', 'mot_f', 'gyr', 'ir_emet' et 'ir_recep'. Maquette Grove (en +) : 'mot_s' \n (sens, 0 ou 1) et 'mot_v' (vitesse, 0-255). \n Entrées réels (si il y a jumelage) : 'bp_ext_r', \n 'bp_int_r', 'fdc_o_r', 'fdc_f_r', 'ir_recep_r'. Autres variables : 't' (temps), 'mot_angle', \n 'mot_vitesse', 'portail_x', 'portail_vitesse'.""" card_data_url=[] system_card_description.update({"data-card" : [card_data_title, card_data_text, card_data_url]}) # Monitoring card_daq_title="Acquisition de données" # card_daq_text="aaa"+"\u2192"+"ddd" card_daq_text=""" daq([variables]) \n -> Déclenche l'acquisition de données afin \n de générer un fichier de données CSV à \n l'arrêt du cycle. Par exemple : daq(['bp_ext', 'portail_x']).\n plot([variables]) \n -> Affiche le chronogramme à l'arrêt du cycle. Le chronogramme interactif est en \n cours d'implémentation.\n Les variables pouvant être suivies sont les \n mêmes que celles de la page "Données".""" # Blender étant cadencé à 60 fps, la fréquence \n d'acquisition est 16 ms.""" card_daq_url=[["Wikipedia Français : fichier CSV","https://fr.wikipedia.org/wiki/Comma-separated_values"], ["Bibliothèque Matplotlib","https://matplotlib.org/"]] system_card_description.update({"daq-card" : [card_daq_title, card_daq_text, card_daq_url]}) # Ouvrir et fermer card_movement_title="Ouvrir et fermer" card_movement_text=""" mot_o(True | False) -> Ouvrir le portail. mot_f(True | False) -> Fermer le portail.\n fdc_o() \n -> Capteur fin de course portail ouvert. fdc_f() \n -> Capteur fin de course portail fermé.\n mot_vitesse(vitesse) -> Change la vitesse \n du moteur numérique en rad/s. mot_vitesse_r(vitesse) -> Change la vitesse \n du moteur réel en rad/s (maquette Grove). Si 'vitesse' est ommis, elle sera réinitialisée.""" # fdc_o() \n -> Capteur fin de course portail ouvert.\n Retourne True si le portail est ouvert. \n # fdc_f() \n -> Capteur fin de course portail fermé.\n Retourne True si le portail est fermé.\n card_movement_url=[] system_card_description.update({"movement-card" : [card_movement_title, card_movement_text, card_movement_url]}) # Capteurs card_sensor_title="Capteur" card_sensor_text=""" ir_emet(True | False) \n -> Activer l'émetteur infrarouge (IR).\n ir_recep() \n -> Récepteur barrage infrarouge (IR).\n Retourne True s'il n'y a pas d'obstacle.""" card_sensor_url=[] system_card_description.update({"sensor-card" : [card_sensor_title, card_sensor_text, card_sensor_url]}) # Gyrophare card_gyro_title="Gyrophare" card_gyro_text=""" gyr(True | False) \n -> Activer le gyrophare.""" card_gyro_url=[] system_card_description.update({"gyro-card" : [card_gyro_title, card_gyro_text, card_gyro_url]}) # Pupitre card_board_title="Pupitre" card_board_text= """ bp_ext() \n -> Bouton poussoir coté rue.\n Retourne True si le bouton est pressé.\n bp_int() \n -> Bouton poussoir coté cour.\n Retourne True si le bouton est pressé.""" card_board_url=[] system_card_description.update({"board-card" : [card_board_title, card_board_text, card_board_url]}) # Maquette card_model_title="Maquette" card_model_text=""" Le modèle 3D est basé sur la maquette \n développée par l'entreprise A4 \n Technologie. Il existe aussi une maquette \n auto-construite à partir de modules Grove. \n Tous deux sont diffusées librement sous \n licence Creative Commons BY-NC-SA. \n Le pilotage de la maquette se fait par une \n carte Arduino (Uno ou Mega) reliée à \n l'ordinateur via la liaison série (USB) et le \n protocole Firmata.""" card_model_url=[["Maquette A4 Technologie","https://www.a4.fr/wiki/index.php?title=Portail_coulissant_(BE-APORT-COUL)"], ["Maquette auto-construite","https://forge.aeif.fr/blender-edutech/blender-edutech-modeles3d/-/tree/main/portail_coulissant"], ["Système Grove","https://wiki.seeedstudio.com/Grove_System/"]] system_card_description.update({"model-card" : [card_model_title, card_model_text, card_model_url]}) # Firmata card_firmata_title="Protocole Firmata" card_firmata_text=""" Firmata est le protocole de communication \n entre les deux jumeaux via la liaison série. Lors du jumelage, il faut récupérer l'objet \n "carte" avec carte = jumeau(brochage). \n broche = carte.get_pin('type:numéro:mode') \n -> Créer une entrée/sortie (broche) : \n - type : a (analogique) ou d (numérique), \n - mode : i (entrée) , o (sortie) ou p (pwm). \n valeur = broche.read() -> Lit la broche.\n broche.write(valeur) -> Écrire sur la broche.""" card_firmata_url=[["Protocole Firmata : pyFirmata","https://github.com/tino/pyFirmata"]] system_card_description.update({"firmata-card" : [card_firmata_title, card_firmata_text, card_firmata_url]}) # Arduino card_arduino_title="Arduino" card_arduino_text=""" Arduino une plateforme open-source de \n développement électronique basée sur le \n microcontrôleur de la famille ATmega. Elle est utilisée pour la création d'objets \n électroniques interactifs et connectés : \n IoT, domotique, robotique, ... Le langage de programmation est le C. Par \n la bibliothèque Arduino l'accès aux entrées \n et sorties de la carte est particulièrement aisé. Les platines permettent l'ajout \n d'extensions : relais, Grove, RFID, GPS, ... """ card_arduino_url=[["Plateforme Arduino","https://www.arduino.cc/"]] system_card_description.update({"arduino-card" : [card_arduino_title, card_arduino_text, card_arduino_url]}) ## # Envoi des données ## def get_system_card(): return system_card def get_system_card_description(): return system_card_description # # Mise en place de la variante # print ("aa") # print (scene.objects['System']['script']) # print ("bb") # # runpy.run_path(scene.objects['System']['script'], run_name='init') # # if scene.objects['System']['variant'] ==2: # # system_card_description.update({"pin-card" : [card_pin_title, card_pin_text_autoprog, card_pin_url]}) # # else: # # system_card_description.update({"pin-card" : [card_pin_title, card_pin_text_grove, card_pin_url]}) # return system_card_description