jumeaux-numeriques/monte_charge/montchg_doc.py

153 lines
8.7 KiB
Python

###############################################################################
# montchg_doc.py
# @title: Documentation du monte-charge
# @project: Blender-EduTech
# @lang: fr
# @authors: Philippe Roy <philippe.roy@ac-grenoble.fr>
# @copyright: Copyright (C) 2022-2023 Philippe Roy
# @license: GNU GPL
###############################################################################
################################################################################
# Documentation du système
################################################################################
system_card=["twins-card", "pin-card", "data-card", "daq-card", "movement-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 = { 'ba_0':['d',2,'i'] }.\n
Les objets numériques sont : 'ba_0', 'ba_1', \n 'pc_0', 'pc_1', 'voy_0' et 'voy_1'.
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 = { 'ba_0':['d',2,'i'] }.\n
Les objets numériques sont : 'ba_0', 'ba_1', \n 'pc_0', 'pc_1', 'voy_0' et 'voy_1'.
Pour le moteur (maquette AutoProg) : \n 'mot_m' et 'mot_d'."""
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_grove=""" get(variable) \n -> Retourne la valeur de la variable à \n l'instant t. Par exemple : val = get('ba_0').\n
Entrées/sorties : 'ba_0', 'ba_1', 'pc_0', 'pc_1', \n 'mot_m', 'mot_d', 'voy_0' et 'voy_1'.\n
Variables réels (si il y a jumelage) : 'ba_0_r', \n 'ba_1_r', 'pc_0_r', 'pc_1_r', 'mot_v', 'mot_s' \n et 'mot_vitesse_r'.\n
Autres variables : 't' (temps), 'mot_angle', \n 'mot_vitesse', 'cabine_z'."""
card_data_text_autoprog=""" get(variable) \n -> Retourne la valeur de la variable à \n l'instant t. Par exemple : val = get('ba_0').\n
Entrées/sorties : 'ba_0', 'ba_1', 'pc_0', 'pc_1', \n 'mot_m', 'mot_d', 'voy_0' et 'voy_1'.\n
Variables réels (si il y a jumelage) : 'ba_0_r', \n 'ba_1_r', 'pc_0_r', 'pc_1_r'.\n
Autres variables : 't' (temps), 'mot_angle', \n 'mot_vitesse', 'cabine_z'."""
card_data_url=[]
system_card_description.update({"data-card" : [card_data_title, [card_data_text_grove, card_data_text_autoprog], card_data_url]}) # Deux descriptions
# 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(['ba_0', 'cabine_z']).\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="Monter et descendre"
card_movement_text_grove=""" mot_m(True | False) -> Monter la cabine.
mot_d(True | False) -> Descendre la cabine. \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 (0-255).
Si 'vitesse' est ommis, elle sera réinitialisée.\n
pc_0() -> Capteur présence cabine niveau 0.\n Retourne True si la cabine est au niveau 0.
pc_1() -> Capteur présence cabine niveau 1.\n Retourne True si la cabine est au niveau 1."""
card_movement_text_autoprog=""" mot_m(True | False) -> Monter la cabine.
mot_d(True | False) -> Descendre la cabine. \n
mot_vitesse(vitesse) -> Change la vitesse \n du moteur numérique en rad/s.
Si 'vitesse' est ommis, elle sera réinitialisée.\n
pc_0() -> Capteur présence cabine niveau 0.\n Retourne True si la cabine est au niveau 0.
pc_1() -> Capteur présence cabine niveau 1.\n Retourne True si la cabine est au niveau 1."""
card_movement_url=[]
system_card_description.update({"movement-card" : [card_movement_title, [card_movement_text_grove, card_movement_text_autoprog], card_movement_url]})
# Pupitre
card_board_title="Pupitre"
card_board_text= """ ba_0() \n -> Bouton poussoir d'appel niveau 0.\n Retourne True si le bouton est pressé.\n
ba_1() \n -> Bouton poussoir d'appel niveau 1.\n Retourne True si le bouton est pressé.\n
voy_0(True | False) \n -> Activer le voyant d'étage niveau 0.\n
voy_1(True | False) \n -> Activer le voyant d'étage niveau 1."""
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. \n
Les documents techniques et \n pédagogiques signés A4 Technologie \n sont diffusés librement sous licence \n 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=[["A4 Technologie","https://www.a4.fr"],
["Maquette A4 Technologie","https://www.a4.fr/wiki/index.php?title=Monte_charge_(BE-MCHA)"]]
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