Mech-Viz Interface
Cette section présente les interfaces de l’Adapter liées à Mech-Viz, comme indiqué ci-dessous.
Démarrer le projet Mech-Viz
Une fonction pour démarrer le projet Mech-Viz a été définie dans la classe Adapter du fichier adapter.py ; vous pouvez donc appeler directement la fonction « start_viz() ». En outre, vous pouvez réécrire « self.before_start_viz() » et « self.after_start_viz() » selon les besoins réels du projet pour définir le traitement à effectuer avant et après le démarrage du projet Mech-Viz.
Définition de la fonction
def start_viz(self, in_new_thread=True, timeout=None):
if not self.is_viz_registered():
logging.error("{} has not registered in {}.".format(jk.mech_viz, jk.mech_center))
self.code_signal.emit(ERROR, VIZ_NOT_REGISTERED)
self.viz_finished_signal.emit(True)
self.viz_not_registerd()
return False
if self.is_viz_in_running():
logging.info("{} is already running.".format(jk.mech_viz))
self.code_signal.emit(WARNING, VIZ_IS_RUNNING)
self.viz_finished_signal.emit(False)
self.viz_is_running()
return False
self._read_viz_settings()
if not self.viz_project_dir:
self.msg_signal.emit(ERROR, _translate("messages", "The project of {0} is not registered. Please make sure Autoload Project is selected in {0}.").format(jk.mech_viz))
self.viz_finished_signal.emit(True)
return False
msg = {"simulate": self.is_simulate, "project_dir": self.viz_project_dir}
if self.is_keep_viz_state:
msg["keep_exec_state"] = self.is_keep_viz_state
if self.is_save_executor_data:
msg["save_executor_data"] = self.is_save_executor_data
self.before_start_viz()
self.viz_finished_signal.emit(False)
if in_new_thread:
threading.Thread(target=self.wait_viz_result, args=(msg, timeout)).start()
else:
self.wait_viz_result(msg, timeout)
self.after_start_viz()
return TruePar défaut, « start_viz() » attendra dans un nouveau thread la fin de l’exécution du projet Mech-Viz, ce qui évite d’affecter d’autres opérations que le démarrage du projet Mech-Viz.
L’exemple ci-dessous montre comment définir dynamiquement les paramètres d’étape en appelant la fonction « self.before_start_viz() ».
def before_start_viz(self):
self.set_move_offset(x, y, z)Avant de démarrer le projet Mech-Viz, les décalages sur les axes X, Y et Z d’une cible seront définis selon les données lues.
Arrêter le projet Mech-Viz
Une fonction pour arrêter le projet Mech-Viz a été définie dans la classe Adapter du fichier adapter.py ; vous pouvez donc appeler directement la fonction « stop_viz() ».
Définition de la fonction
def stop_viz(self, timeout=None):
if not self.is_viz_registered():
self.code_signal.emit(WARNING, VIZ_NOT_REGISTERED)
return False
self.call_viz("stop", timeout=timeout)
self.code_signal.emit(INFO, VIZ_STOP_OK)
return TrueMettre en pause et reprendre le projet Mech-Viz
Une fonction pour mettre en pause et reprendre le projet Mech-Viz a été définie dans la classe Adapter du fichier adapter.py. La fonction « pause_viz » correspond au bouton Pause/Continue dans Mech-Viz et ne peut être utilisée qu’en simulation.
Définition de la fonction
def pause_viz(self, msg, timeout=None):
if not self.is_viz_registered():
self.code_signal.emit(WARNING, ADAPTER_CANCEL_PAUSE)
return
self.call_viz("switchPauseContinue", msg, timeout)
self.code_signal.emit(INFO, ADAPTER_PAUSE_VIZ if msg.get(
"to_pause") else ADAPTER_CONTINUE_VIZ)Définir les paramètres d’étape
En général, vous pouvez appeler directement la fonction « set_task_property() » dans la classe Adapter pour définir dynamiquement les paramètres d’étape dans Mech-Viz.
Définition de la fonction
def set_task_property(self, msg, timeout=None):
return self.call_viz("setTaskProperties", msg, timeout)Dans la fonction ci-dessus, « msg » détermine les paramètres d’étape à définir.
Déplacement à point fixe
Parfois, vous devez ajuster finement les décalages des axes X, Y et Z dans l’étape Déplacement à point fixe lors de l’exécution d’un projet Mech-Viz, ce qui peut être réalisé en ajoutant la fonction ci-dessous dans le programme principal de contrôle du projet Mech-Viz.
Exemple
def set_move_offset(self, name, x_offset, y_offset, z_offset):
msg = {"name": name,
"values": {"xOffset": x_offset / UNIT_PER_METER,
"yOffset": y_offset / UNIT_PER_METER,
"zOffset": z_offset / UNIT_PER_METER}}
self.set_task_property(msg)Dans l’exemple ci-dessus, « name » est le nom de l’étape « Fixed-Point Move » et « UNIT_PER_METER » vaut 1000. Étant donné que l’unité de x_offset, y_offset et z_offset est généralement le millimètre, alors que l’unité des données utilisées dans Mech-Viz est le mètre, vous devez utiliser « UNIT_PER_METER » pour convertir l’unité.
Si la fonction « set_move_offset() » suivante est appelée, les décalages des axes X, Y et Z dans l’étape « move_1 » du projet Mech-Viz seront modifiés en conséquence.
self.set_move_offset("move_1", 100, 200, 300)Déplacement par liste/Déplacement par grille
Les étapes « Move by List » et « Move by Grid » doivent généralement être configurées à l’avance dans Mech-Viz, puis l’Adapter modifiera l’indice de départ selon la logique. La méthode de création et d’appel de la fonction est identique à celles des fonctions d’interface Déplacement à point fixe et Palettisation.
Déplacement externe
L’étape « External Move » peut être utilisée lorsque plusieurs cibles provenant de services externes sont envoyées à Mech-Viz pour la planification de trajectoire. Vous pouvez définir les JPs, le TCP et la pose de l’objet dans l’étape « External Move », comme illustré ci-dessous.
Exemple
class CustomOuterMoveService(OuterMoveService):
def gather_targets(self, di, jps, flange_pose):
self.add_target(self.move_target_type, [0.189430,-0.455540,0.529460,-0.079367,0.294292,-0.952178,0.021236])La classe CustomOuterMoveService est développée sur la base de la classe OuterMoveService. self.move_target_type indique le type de cible. Valeurs valides : 0, 1 et 2. Une valeur de 0 indique le type JP, une valeur de 1 indique le type TCP et une valeur de 2 indique le type pose d’objet. Mech-Viz appelle getMoveTargets() lors de l’exécution d’une étape External Move. Différentes étapes External Move peuvent être distinguées par leurs noms de service.
def _register_service(self):
self.outer_move_service = CustomOuterMoveService()
self._outer_move_server, port = register_service(outer_move_service, port)| Si self.move_target_type est défini sur 2, vous devez placer une étape qui définit la préhension avant l’étape External Move. Sinon, le message d’erreur suivant s’affichera : - La posture de l’objet est invalide lorsque l’objet n’est pas saisi !. |
Palettisation
Lors de l’exécution d’un projet Mech-Viz, vous devez parfois définir des paramètres pour différentes étapes de type palette. L’étape spécifique à configurer peut être trouvée selon le nom de l’étape de type palettisation. Tous les paramètres affichés dans le panneau Paramètres de l’étape de Mech-Viz en sélectionnant l’étape dans l’espace de travail de programmation graphique peuvent être modifiés.
Exemple
Par exemple, les paramètres « Indice de départ » et « Chemin du fichier de motif » (Chemin du fichier de motif n’est disponible que lorsque Chargement dynamique est sélectionné) pour l’étape « Custom Pallet Pattern » doivent généralement être modifiés ; vous pouvez ajouter une fonction comme ci-dessous dans le programme principal.
def set_stack_pallet(self, name, startIndex, fileName):
msg = {
"name": name,
"values": {
"startIndex": startIndex,
"fileName": fileName,
}
}
self.set_task_property(msg)Dans l’exemple ci-dessus, « startIndex » correspond au paramètre « Indice de départ », et « fileName » correspond au paramètre « Chemin du fichier de motif » dans le panneau Paramètres de l’étape de Mech-Viz.
L’instruction ci-dessous est utilisée pour appeler la fonction « set_stack_pallet() ».
self.set_stack_pallet("common_pallet_1", 2, "re.json")Pour l’étape « Predefined Pallet Pattern », les valeurs des paramètres Indice de départ, Type de palette, Longueur du carton, * Largeur du carton*, Hauteur du carton, Lignes, Colonnes et Nombre de couches doivent généralement être modifiées. Vous pouvez ajouter une fonction comme ci-dessous au programme principal.
def set_stack_pallet(self, name, startIndex, stack_type):
pallet_info = self.box_data_info[stack_type]
"""
pallet_info: Length(mm),Width(mm),Height(mm),pallet type,rows,columns,layers
"""
msg = {
"function": "setTaskProperties",
"name": name,
"values": {
"startIndex": startIndex,
"palletType": pallet_info[3],
"cartonLength": pallet_info[0] / UNIT_PER_METER,
"cartonWidth": pallet_info[1] / UNIT_PER_METER,
"cartonHeight": pallet_info[2] / UNIT_PER_METER,
"cylinderRows": pallet_info[4],
"cylinderCols": pallet_info[5],
"layerNum": pallet_info[6]
}
}
self.set_task_property(msg)Comme plusieurs paramètres doivent être définis, dans la plupart des cas, vous pouvez d’abord écrire les paramètres dans un fichier Excel. Ensuite, les données du fichier peuvent être lues par le programme et enregistrées dans « self.box_data_info ». La valeur de « stack_type » peut être utilisée pour obtenir certaines valeurs de paramètres de l’étape. Les noms tels que « startIndex », « PalletType » et « cartonLength » sont des noms fixes dans Mech-Viz.
En comparant les valeurs de « msg » dans les classes Custom Pallet Pattern et Predefined Pallet Pattern, vous pouvez constater que la plus grande différence réside dans « values ». Si vous devez définir les paramètres d’une étape spécifique, vous pouvez ajouter les noms et valeurs de paramètres correspondants dans « values ». Vous pouvez vous référer aux exemples ci-dessus pour définir les paramètres d’autres étapes de type palettisation.
Branchement par message
Lorsque le projet Mech-Viz exécute l’étape « Branch by Msg », il attendra un signal externe envoyé par l’Adapter pour spécifier un port de sortie à emprunter. Vous pouvez utiliser la fonction suivante pour contrôler l’étape « Branch by Msg ».
Exemple
def set_branch(self, name, area):
time.sleep(1) # The delay of 1s here is to wait for the {product-viz} executor to fully start
try:
info = {"out_port": area, "other_info": []}
msg = {"name": name,
"values": {"info": json.dumps(info)}}
self.set_task_property(msg)
except Exception as e:
logging.exception(e)Dans l’exemple ci-dessus, « name » est le nom de l’étape « Branch by Msg », « area » spécifie le port de sortie. Le numéro de série du port de sortie commence à 0, et sera incrémenté de un si un port est ajouté. Si l’étape doit emprunter le premier port à gauche, alors area=0. Si la fonction « set_branch » est appelée avant de démarrer un projet Mech-Viz, un message d’erreur « aucun actionneur » sera renvoyé par Mech-Viz.
Compteur
Lorsque vous utilisez l’étape « Counter », vous devez définir les paramètres « Count » et « Current Count ». La fonction utilisée pour définir les paramètres dans cette étape est présentée ci-dessous.
Exemple
def set_counter_property(self, name, count, curCount):
msg = {"name": name,
"values": {"count": count, "currentCount": curCount}}
self.set_task_property(msg)L’instruction pour appeler la fonction est présentée ci-dessous.
self.set_counter_property("counter_1", 5, self.success_stack_num)Dans cet exemple, « self.success_stack_num » est le nombre de cartons palettisés avec succès. Si le carton tombe pendant la palettisation et que Mech-Viz est arrêté par intervention humaine, la valeur de « currentCount » ne sera pas enregistrée dans l’étape « Counter_1 ». Après le redémarrage du projet Mech-Viz, le comptage actuel de l’étape « Counter » peut être défini en utilisant « self.success_stack_num ».
Lire les paramètres d’étape
Si vous devez lire les paramètres d’une étape spécifique pendant l’exécution du projet Mech-Viz, vous pouvez ajouter une fonction comme ci-dessous dans le programme principal.
Exemple
def read_move_pallet(self, name):
msg = {"name": name,
"properties": ["xOffset","yOffset","zOffset", ]}
return read_task_property(msg)Dans l’exemple ci-dessus, « name » est utilisé pour localiser l’étape dont il faut lire les paramètres. Les paramètres après « properties » peuvent être modifiés selon les besoins réels. Dans cet exemple, il faut lire les valeurs des paramètres « xOffset », « yOffset » et « zOffset ». L’instruction pour appeler la fonction est montrée ci-dessous.
self.read_move_pallet("move_3")Le résultat de l’appel est présenté ci-dessous.
{'zOffset': -0.23, 'xOffset': -0.12, 'yOffset': -0.15}De plus, veuillez noter que les valeurs de paramètres obtenues à partir d’une étape Mech-Viz peuvent être des valeurs planifiées, et non les valeurs d’exécution réelle. L’avancement planifié est généralement en avance sur le processus d’exécution réel (Mech-Viz planifie les mouvements futurs dès que possible). L’exemple suivant utilise « curIndex » (indice actuel) des étapes de type palettisation. Vous pouvez ajouter la fonction ci-dessous dans le programme principal.
def read_pallet_current_index(self, name):
msg = {"name": name,
"properties": ["curIndex"]}
return read_task_property(msg)L’instruction pour appeler la fonction afin d’obtenir la valeur « curIndex » est présentée ci-dessous.
self.read_pallet_current_index("common_pallet_1")Le résultat de l’appel est présenté ci-dessous.
{'curIndex': 5}Dans l’exemple ci-dessus, « 5 » indique que cinq cycles de planification sont terminés. Par exemple, pour un projet de palettisation de cartons, « 5 » indique que cinq cartons ont été palettisés dans l’avancement planifié. Cependant, le nombre de cartons réellement palettisés par le robot peut être inférieur à 5. Par conséquent, les valeurs de paramètres telles que « curIndex » indiquent des valeurs planifiées, et non les valeurs d’exécution réelle.
Définir le TCP
Pour définir le TCP, vous devez simplement spécifier l’indice correspondant de l’outil d’extrémité dans la liste des outils de Mech-Viz. Les indices des outils dans la liste des outils d’extrémité de Mech-Viz sont des entiers commençant à 0. La fonction pour définir le TCP est présentée ci-dessous.
Exemple
def set_tcp(self, index):
msg = {"function": "setTcp", "index": index}
self.call("executor", msg)Définir globalement la vitesse pendant l’exécution du projet
Pour ajuster dynamiquement la vitesse du robot pendant l’exécution du projet Mech-Viz, vous pouvez ajouter une fonction comme ci-dessous dans le programme principal.
Exemple
def set_vel(self, vel_scale):
msg = {"function": "setConfig",
"velScale": vel_scale / 100, "accScale": vel_scale / 100}
self.call("executor", msg)Si la vitesse doit être réglée à 80 %, la fonction peut être appelée comme ci-dessous.
self.set_vel(80)| Cette fonction doit être appelée après le démarrage du projet Mech-Viz, sinon une erreur peut survenir. La condition préalable de cette fonction est identique à celle de « set_branch() ». Par conséquent, la fonction « set_vel() » est généralement appelée dans la fonction « set_branch() » plutôt que dans un nouveau thread. Un exemple est présenté ci-dessous. |
def set_branch(self, name, area):
time.sleep(1)
if self.box_data_info[int(self.pallet_info)][7] <= 10:
self.set_vel(100)
else:
self.set_vel(80)
try:
info = {"out_port": area, "other_info": []}
msg = {"function": "setTaskProperties",
"name": name,
"values": {"info": json.dumps(info)}}
self.set_task("executor", msg)
except Exception as e:
logging.exception(e)Définir les paramètres de collision du nuage de points
La fonction d’interface setConfig() correspond aux paramètres liés à la détection de collision dans Mech-Viz. La méthode pour définir l’interface des paramètres de collision sur nuage de points est identique à celle de la définition de la vitesse, et la principale différence réside dans la valeur de msg. Un exemple est présenté ci-dessous.
Exemple
msg = {}
msg["function"] = "setConfig"
msg["check_pcl_collision"] = True
msg["collided_point_thre"] = 5000
msg["collide_area_thre"] = 20
msg["pcl_resolution_mm"] = 2
self.call("executor", msg)Valeur de retour de Mech-Viz
Le tableau suivant décrit les valeurs de retour de Mech-Viz.
| Valeur de retour | Description |
|---|---|
Terminé |
L’exécution s’est terminée correctement. Veuillez noter que lorsque l’étape « Vision Move » emprunte le port de sortie de droite (Autres échecs) dans le projet Mech-Viz, Mech-Viz renverra également cette valeur. |
Arrêt par commande |
Le bouton Stop a été cliqué ou la fonction « stop_viz() » a été appelée. |
Aucune cible |
Aucun point de vision n’a été renvoyé par Mech-Vision. |
Aucune pose de vision appropriée |
Le point de vision était inaccessible car le robot ne pouvait pas se déplacer vers ce point ou entrerait en collision avec d’autres éléments. |
PlanFail |
Mech-Viz n’a pas réussi à planifier le trajet. |
SceneCollision |
Une collision a été détectée. |
Selon la valeur renvoyée par Mech-Viz, des fonctions d’interface correspondantes sont fournies dans la classe de base de l’Adapter.