Interface RobotService
Cette section présente les interfaces Adapter liées à RobotService, comme indiqué ci-dessous.
Simuler le service RobotServer
« Simuler le service RobotServer » est généralement utilisé dans des scénarios où le système de vision pilote le robot en maître, mais où le robot ne peut pas être contrôlé directement via RobotServer (jouant le rôle d’appareil maître de la communication maître-contrôle). Dans ce cas, l’interface RobotService peut être utilisée pour simuler un RobotServer et ainsi piloter le robot en maître. Après l’enregistrement de RobotService dans Mech-Viz, Mech-Viz interagira avec RobotService comme avec un robot réel.
« Simuler le service RobotServer » peut être utilisé pour :
-
Obtenir les JPs du robot pour les calculs dans Mech-Vision (dans le scénario caméra embarquée);
-
Obtenir la pose du robot réel et l’envoyer au service RobotService.
Exemple
L’objet RobotService dans une classe dérivée d’Adapter est appelé comme suit.
def _register_service(self):
"""
register_service
:return:
"""
if self.robot_service:
return
self.robot_service = RobotService(self)
other_info = {'robot_type': self.robot_service.service_name}
self.server, _ = register_service(self.hub_caller, self.robot_service, other_info)
self.robot_service.setJ([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])La classe RobotService est présentée ci-dessous.
class RobotService(JsonService):
service_type = "robot"
service_name = "robot"
jps = [0, 0, 0, 0, 0, 0]
pose = [0, 0, 0, 1, 0, 0, 0]
def getJ(self, *_):
return {"joint_positions": self.jps}
def setJ(self, jps):
logging.info("setJ:{}".format(jps))
self.jps = jps
def getL(self, *_):
return {"tcp_pose": self.pose}
def getFL(self, *_):
return {"flange_pose": self.pose}
def setL(self, pose):
logging.info("setL:{}".format(pose))
self.pose = pose
def moveXs(self, params, _):
pass
def stop(self, *_):
pass
def setTcp(self, *_):
pass
def setDigitalOut(self, params, _):
pass
def getDigitalIn(self, *_):
pass
def switchPauseContinue(self, *_):
passgetJ
La fonction getJ() est utilisée pour obtenir les JPs actuelles pour Mech-Viz et Mech-Vision, comme indiqué ci-dessous. En général, les JPs actuelles sont d’abord définies via la fonction setJ(), puis getJ() est appelée.
Exemple
def getJ(self, *_):
pose = {"joint_positions": self._jps}
return pose-
Dans le scénario caméra embarquée : écrire les JPs envoyées par le robot dans setJ().
def setJ(self, jps): assert len(jps) = 6 for i in range(6): jps[i] = deg2rad(float(jps[i])) self._jps = jps logging.info("SetJ:{}".format(self._jps))Dans cet exemple, “jps” correspond aux JPs envoyées par le robot, et sa valeur sera affectée à self._jps, qui sera utilisée par la fonction getJ(). Comme la fonction getJ() exige des données en radians, veuillez noter qu’une conversion d’unités est nécessaire ici.
-
Dans le scénario caméra fixe : Il n’est pas nécessaire de définir les JPs actuelles en fonction de la pose du robot réel. Cependant, il faut définir une position Home qui n’entraîne pas de collision comme pose initiale pour simuler le robot réel ; sinon, la valeur sera attribuée aléatoirement et une erreur peut survenir.
def getJ(self, *_): return {"joint_positions": [1.246689,-0.525868,-0.789761,-1.330814, 0.922581, 4.364021]}
getFL
La fonction getFL() est utilisée pour fournir la pose de la bride du robot lors de la capture d’images. Comme, dans le scénario caméra embarquée, la relation positionnelle calibrée est entre la bride et la caméra, mais les données finalement utilisées sont exprimées dans le repère de base du robot, la pose de la bride au moment de la capture d’image est nécessaire.
def getFL(self, *_):
return {"flange_pose": self.pose}Veuillez noter les points suivants lorsque des points de vision sont fournis dans le scénario caméra embarquée :
-
Si le robot renvoie une pose de capture d’image en JPs, vous pouvez appeler directement setJ() dans RobotService (l’unité est le radian) et la fonction renverra [].
-
Si le robot renvoie une pose de capture d’image en pose de bride, procédez comme suit:
-
Assurez-vous que “is_eye_in_hand” est défini sur true dans le fichier de paramètres extrinsèques “extri_param.json” du projet Mech-Vision ;
-
Appelez setFL() de RobotService (la pose est représentée par des quaternions et l’unité est le mètre).
-
moveXs
Le service RobotService créé via Adapter utilise la fonction moveXs() pour recevoir les points de passage du trajet planifié par Mech-Viz, comme indiqué ci-dessous.
Définition de fonction
def moveXs(self, params, _):
with self.lock:
for move in params["moves"]:
self.targets.append(move)
return {"finished": True}“params” transmet tous les paramètres du projet Mech-Viz. Toutes les poses cibles, y compris celles issues de Vision Move, Relative Move, etc., peuvent être obtenues via params[“moves”]. Les poses renvoyées sont par défaut en JPs et seront placées dans “self.targets” pour des appels ultérieurs.
Exemple
En général, cette fonction est utilisée conjointement avec la fonction “notify()”. Lorsque Adapter reçoit un message de notification, il transmet “self.targets” à la fonction pour conversion et empaquetage, puis l’envoie au robot, comme ci-dessous.
def notify(self, request, _):
msg = request["notify_message"]
logging.info("{} notify message:{}".format(self.service_name, msg))
if msg = "started":
with self.lock:
self.move_targets.clear()
elif msg = "finished":
with self.lock:
targets = self.move_targets[:]
self.move_targets.clear()
self.send_moves(targets)Lorsque le message de notification “started” est reçu, les cibles de la liste seront vidées, afin d’éviter des cibles dupliquées causées par une déconnexion imprévue et un redémarrage de Mech-Viz. Lorsque le message de notification “finished” est reçu, la liste de cibles sera transmise à la fonction “pack_move”, qui agrégera les données puis les enverra.
def pack_move(self, move_param):
move_list = []
for i, move in enumerate(move_param):
target = move["target"]
move_list.append(target)
logging.info("move list num:{}".format(len(move_list)))
logging.info("move list:{}".format(*move_list))
motion_cmd = pack('>24f', *move_list)
self.send(motion_cmd)Selon les besoins réels sur site, vous pouvez choisir d’envoyer toutes les cibles planifiées par Mech-Viz ou sélectionner plusieurs cibles à envoyer depuis la liste par index. La fonction pack_move() agrège généralement les données selon le format spécifique requis par différentes marques de robots, et le format de données requis est généralement spécifié dans la solution de communication.