Mech-Vision Interface

Vous consultez actuellement la documentation pour la dernière version (2.1.2). Pour accéder à une autre version, cliquez sur le bouton "Changer de version" situé dans le coin supérieur droit de la page.

■ Si vous n’êtes pas sûr de la version du produit que vous utilisez, veuillez contacter le support technique Mech-Mind pour obtenir de l’aide.

Cette section présente les interfaces de l’Adapter liées à Mech-Vision, comme indiqué ci-dessous.

Obtenir des cible(s) de vision

Le résultat de vision provenant de Mech-Vision peut être obtenu en appelant la fonction “find_vision_pose()” dans adapter.py.

def find_vision_pose(self, project_name=None, timeout=default_vision_timeout):
    vision_result = self.call_vision("findPoses", project_name=project_name, timeout=timeout)
    logging.info("Find vision result: {}".format(vision_result))
    return vision_result

Les points de vision dans le résultat produit par Mech-Vision sont généralement des poses d’objet (obj_pose) exprimées en quaternions. Si vous avez besoin des points de vision en TCP, veuillez effectuer la transformation dans le projet Mech-Vision.

Exemple

Il faut créer une fonction dans l’Adapter pour convertir les poses d’objet en TCP (tcp_pose), convertir les quaternions en angles d’Euler et les radians en degrés (si requis côté robot), puis encapsuler les données converties et les envoyer au robot. Le format et les unités des données doivent être cohérents avec ceux utilisés côté robot. Par ailleurs, l’Adapter peut vérifier les points de vision renvoyés par Mech-Vision, comme montré ci-dessous:

def check_vision_result(self, vision_result):
    if vision_result["noCloudInRoi"]:                      # Determine whether it is an empty bin
    logging.info("Layer has no objects")
    self.send(pack('>2B6i', CODE_NO_CLOUD, vision_num, *EMPTY_PLACEHOLDER))
    return
    poses = vision_result.get("poses", [])                 # Get pose
    if len(poses) = 0:                                  # Determine whether there is a vision point
        logging.warning("No pose from vision")
        self.send(pack('>2B6i', CODE_NO_POSE, vision_num, *EMPTY_PLACEHOLDER))
        return
    self.send(pack_pose(poses[0], vision_num))       # Send after format conversion

Dans l’exemple ci-dessus, “vision_result” est obtenu à partir de “find_vision_pose()”, et l’instruction est montrée ci-dessous.

self.check_vision_result(json.loads(self.find_vision_pose().decode()))

Après que “vision_result” a été transmis à la fonction “check_vision_result”, pour les projets disposant d’une ROI définie, la fonction déterminera d’abord s’il s’agit d’un bac vide, puis obtiendra les points de vision. Si les points de vision sont valides, ils seront transmis à la fonction “pack_pose()” et envoyés.

Définir les paramètres de Step

Pour définir dynamiquement les paramètres d’un Step dans Mech-Vision, il suffit généralement d’appeler la fonction “set_step_property()” dans adapter.py.

def set_step_property(self, msg, project_name=None, timeout=None):
    return self.call_vision("setStepProperties", msg, project_name, timeout)

Dans l’instruction ci-dessus, “msg” détermine le nom du Step spécifique et le paramètre à définir.

Exemple

Vous pouvez créer une fonction comme ci-dessous pour définir “msg” lorsque le fichier de modèle d’appariement de nuage de points du projet Mech-Vision doit être défini dynamiquement en fonction de différents types de pièces.

def _step_matching_model_cell(step_name, model_type):
    msg = {"name": step_name,
            "values":
           {"modelFile": model_type["ply"],
         "pickPointFilePath": model_type["json"]}}
    return msg

Dans l’exemple ci-dessus, “step_name” est le nom du Step Mech-Vision à configurer ; “model_type” indique le répertoire du fichier de modèle d’appariement de nuage de points et du fichier de point de prise pour la pièce correspondante. En définissant “ply” et “json” dans “model_type”, on obtient le répertoire du fichier de modèle d’appariement au format .ply ainsi que le répertoire du fichier de points de prise au format .json, qui seront affectés aux paramètres du Step Mech-Vision correspondant.

Si “step_name” est “Local Matching”, alors l’instruction est la suivante.

msg = _step_matching_model_cell("Local Matching", model_type)
self.set_step_property(msg)

Lire les paramètres de Step

Vous pouvez obtenir les paramètres d’un Step Mech-Vision en appelant la fonction “read_step_property()” dans adapter.py.

def read_step_property(self, msg):
     result = self.call_vision("readStepProperties", msg)
     logging.info("Property result: {}".format(result))
     return result

Dans la fonction ci-dessus, “msg” détermine le nom du Step et les paramètres à obtenir. Vous pouvez créer une fonction pour construire le “msg”.

Exemple

Un exemple pour obtenir l’adresse IP de la caméra est présenté ci-dessous.

def read_camera_property(self):
     msg = {"type": "Camera",
            "properties": ["MechEye"]}
     property_results = json.loads(self.read_step_property(msg).decode())
     camera_ip = property_results["MechEye"]["NetCamIp"]

Si une seule caméra est utilisée dans le projet Mech-Vision, le Step peut être trouvé en fonction du champ “type”. S’il y a plusieurs Steps du même type dans le projet Mech-Vision et que vous souhaitez obtenir ou configurer les paramètres d’un Step donné, le champ “name” peut être utilisé pour le trouver. Tous les paramètres de la caméra peuvent être obtenus et convertis au format JSON en appelant la fonction “read_step_property()”, comme illustré ci-dessous:

Property result:
{
  "MechEye": {
    "NetCamIp": "127.0.0.1",
    "TimeOut": "10",
    "configGroup": "",
  }
}

Dans cet exemple, l’adresse IP de la caméra (127.0.0.1) est obtenue à partir des champs de paramètres spécifiques “MechEye” et “NetCamIp”.

Basculer la recette de paramètres

Lors de l’utilisation de Mech-Vision, vous pouvez basculer la recette de paramètres d’un projet en appelant la fonction select_parameter_group() dans adapter.py dans les scénarios où plusieurs recettes sont utilisées pour distinguer les réglages de paramètres d’un même flux de travail pour différentes pièces.

def select_parameter_group(self, project_name, group_index, timeout=None):
    msg = {"parameter_group_idx": group_index}
    result = self.call_vision("selectParameterGroup", msg, project_name, timeout)
    logging.info("selectParameterGroup result: {}".format(result))
    return result

Dans la fonction ci-dessus, “project_name” est le nom du projet Mech-Vision, et “group_index” est l’ID de la recette de paramètres.

Exemple

Lorsque la recette de paramètres doit être changée dans un projet, vous pouvez appeler la fonction “select_parameter_group()” comme ci-dessous et l’utiliser pour la gestion des erreurs.

try:
   result = self.select_parameter_group(self.vision_project_name, model_code-1)
   if result:
      result = result.decode()
      if result.startswith("CV-E0401"):
            return -1
      elif result.startswith("CV-E0403"):
            return -1
      raise RuntimeError(result)
   except Exception as e:
      logging.exception('Exception when switch model: {}'.format(e))
      return -1
   return 0

Dans cet exemple, “self.vision_project_name” transmet le nom du projet Mech-Vision, et “model_code moins 1” transmet l’ID de la recette.

Cette page est-elle utile ?

Veuillez nous indiquer comment améliorer :

Nous accordons de l’importance à votre vie privée

Nous utilisons des cookies pour vous offrir la meilleure expérience possible sur notre site web. En continuant à utiliser le site, vous reconnaissez accepter l’utilisation des cookies. Si vous refusez, un cookie unique sera utilisé pour garantir que vous ne soyez pas suivi ou reconnu lors de votre visite sur ce site.

  • Préférence
  • J’accepte
  • Je n’accepte pas