[Tutoriel de démarrage du bras robotique ROS]

Tout d'abord, permettez-moi de déclarer que ce projet est basé sur le [Tutoriel d'introduction du bras robotique ROS] du Kazakhstan UP à la station B. Au début, il reproduira [La vision du bras robotisé de la théorie au combat pratique]
. est l'affichage de réalisation par étapes et la technologie de sa carrière de diplômé Partager, toutes les données et le code sont open source. Alors Pengpeng, je le reproduis ici à nouveau. Le matériel que j'utilise est différent de celui-ci. Le maître UP utilise UR5, et mon laboratoire utilise UR3. Les matériaux pertinents UR3CB3.12 sont listés ci-dessous : https : //www.universal
-robots . cn/cb3/
[mise à niveau du système UR3 vers CB3.12 avec URcap1.05]

prise en charge matérielle

numéro de série	nom	Fonction
1	Bras robotisé UR3	exécuteur de toutes les actions
2	D435i	les yeux de l'exécuteur
3	Environnement d'apprentissage en profondeur Ubuntu	cerveau de la pensée exécutive
4	Plate-forme de saisie d'avion	Environnement d'exploitation expérimental
5	Tableau d'étalonnage en damier noir et blanc 6*6	Étalonnage de l'œil de la caméra à l'extérieur de la main
6	Petit cube d'impression 3D 3x3x3cm	acteur d'artefact

Le code prend en charge
le lien version3.0 du didacticiel d'entrée du bras robotique ros :
lien : https://pan.baidu.com/s/1KFLQXVWShG5KfroCd6eM0A=8888
code d'extraction : 8888 [tutoriel d'entrée du bras robotique ROS - petit cinq] lien
PPT : https :/ /pan.baidu.com/s/18ierKnf8OJPPvGn8uOf1hw=8888 Code d'extraction : 8888

1. Vue d'ensemble

[Tutoriel principal Autolabor] Premiers pas avec les robots ROS

Tutoriel de démarrage rapide du système d'exploitation du robot ROS

2. Présentation du ROS

2.1 Présentation du ROS

Site officiel de ROS : http://wiki.ros.org/

adresse autolabor : http://www.autolabor.com.cn/book/ROSTutorials/

API Moveit : https://moveit.ros.org/documentation/source-code-api/

mélodique : http://docs.ros.org/en/melodic/api/moveit_tutorials/html/index.html

2.2 Ensemble de robots ROS

ros-melodic:git clone https://github.com/ros-industrial/universal_robot.git
ros-noetic : https://blog.csdn.net/Dawn_yc/article/details/114791755

3. Modélisation robotique URDF

3.1 Introduction à URDF

URDF est le format de description du modèle de robot dans ROS, y compris la description de l'apparence du corps rigide du robot, des propriétés physiques, des types d'articulations, etc.

3.2 Voir le modèle

$ check_urdf xxx.urdf Vérifier le fichier xxx.urdf et trouver une erreur
$ urdf_to_graphiz xxx.urdf
Générer un fichier pdf à partir du fichier urdf pour la visualisation

$ roslaunch ur_description view_ur5.launch Afficher le modèle ur5

3.3 Configurer et enregistrer Rviz

roslaunch ur_description view_ur5_with_gripper.launch Exposition modèle ur5+robotiq85

roslaunch ur_description view_ur5.launch
rviz

Le chemin de sauvegarde rviz est dansuniversal_robot/ur_description/cfg/2222.rviz

<?xml version="1.0"?>
<launch>
  <include file="$(find ur_description)/launch/ur5_upload.launch"/>

  <node name="joint_state_publisher" pkg="joint_state_publisher" type="joint_state_publisher" >
    <param name="use_gui" value="true"/>
  </node>
  <node name="robot_state_publisher" pkg="robot_state_publisher" type="state_publisher" />
  <node name="rviz" pkg="rviz" type="rviz" args="-d $(find ur_description)/cfg/2222.rviz" required="true" />
</launch>

4. Présentation des fonctions principales de Moveit! et contrôle Rviz

4.1 Présentation de Moveit!

MoveIt! est un ensemble d'outils logiciels liés au bras robotique, qui
intègre diverses fonctions :
Ø Cinématique
Ø Planification du mouvement
Ø Vérification des collisions
Ø Perception 3D
Ø Manipulation

4.2 Architecture du package Robot ROS

rosrun moveit_setup_assistant moveit_setup_assistant
Charger le modèle urdf
pour vérifier s'il y a une collision entre les joints

Sélectionnez le solveur,

sélectionnez la connexion de référence et le solveur de fin,

configurez la position de posture appropriée,

couchez-vous à plat et toutes

les postures à zéro 0,-1.5708,0-1.5708,0,0

Configurer la pince d'extrémité

Remplissez les informations personnelles
et créez enfin le modèle

Importer directement le modèle

4.3 Paramètres de l'ordinateur

Il y a une démo Rviz correspondante après la configuration de moveit

roslaunch ur5_moveit_config demo.launch

Position cible aléatoire, cliquez sur planifier et exécuter, vous pouvez passer à la position correspondante

Ajouter
une démo de préhenseur d'obstacles

roslaunch ur5_gripper_moveit_config demo.launch

5. Gazebo simule ou contrôle un vrai robot

Hyper Terminal

sudo apt install terminator

5.1 Connexion entre Moveit et le contrôleur

Comment utiliser

# gazebo仿真中控制机器人
roslaunch ur_gazebo ur5.launch
roslaunch ur5_moveit_config ur5_moveit_planning_execution.launch sim:=true
roslaunch ur5_moveit_config moveit_rviz.launch config:=true
# 控制真实UR5机器人
一键启动: 
roslaunch ur_planning start_ur5.launch
分开启动:
roslaunch ur_modern_driver ur5_bringup.launch
roslaunch ur5_moveit_config ur5_moveit_planning_execution.launch
roslaunch ur5_moveit_config moveit_rviz.launch config:=true
# rviz 仅作可视化显示
roslaunch ur5_moveit_config demo.launch
rosrun ur_planning moveitServer.py

5.2 Simulation de belvédère

5.3 Contrôler le vrai robot UR5

démarrage à un bouton :

roslaunch ur_planning start_ur5.launch

Commencez séparément :

roslaunch ur_modern_driver ur5_bringup.launch
roslaunch ur5_moveit_config ur5_moveit_planning_execution.launch
roslaunch ur5_moveit_config moveit_rviz.launch config:=true

6. Bases de Moveit (python)

6.1 Examen de Moveit!

6.2 Mouvement spatial conjoint

Installer moveit_commander en Python

sudo apt-get update
sudo apt-get install ros-melodic-moveit-commander

# 关节规划，输入6个关节角度（单位：弧度）
    def move_j(self, joint_configuration=None,a=1,v=1):
        # 设置机械臂的目标位置，使用六轴的位置数据进行描述（单位：弧度）
        if joint_configuration==None:
            joint_configuration = [0, -1.5707, 0, -1.5707, 0, 0]
        self.arm.set_max_acceleration_scaling_factor(a)
        self.arm.set_max_velocity_scaling_factor(v)
        self.arm.set_joint_value_target(joint_configuration)
        rospy.loginfo("move_j:"+str(joint_configuration))
        self.arm.go()
        rospy.sleep(1)

    # 空间规划，输入xyzRPY
    def move_p(self, tool_configuration=None,a=1,v=1):
        if tool_configuration==None:
            tool_configuration = [0.3,0,0.3,0,-np.pi/2,0]
        self.arm.set_max_acceleration_scaling_factor(a)
        self.arm.set_max_velocity_scaling_factor(v)

        target_pose = PoseStamped()
        target_pose.header.frame_id = self.reference_frame
        target_pose.header.stamp = rospy.Time.now()
        target_pose.pose.position.x = tool_configuration[0]
        target_pose.pose.position.y = tool_configuration[1]
        target_pose.pose.position.z = tool_configuration[2]
        q = quaternion_from_euler(tool_configuration[3],tool_configuration[4],tool_configuration[5])
        target_pose.pose.orientation.x = q[0]
        target_pose.pose.orientation.y = q[1]
        target_pose.pose.orientation.z = q[2]
        target_pose.pose.orientation.w = q[3]

        self.arm.set_start_state_to_current_state()
        self.arm.set_pose_target(target_pose, self.end_effector_link)
        rospy.loginfo("move_p:" + str(tool_configuration))
        traj = self.arm.plan()
        self.arm.execute(traj)
        rospy.sleep(1)

6.3 Mouvement spatial cartésien

# 空间直线运动，输入(x,y,z,R,P,Y,x2,y2,z2,R2,...)
    # 默认仅执行一个点位，可以选择传入多个点位
    def move_l(self, tool_configuration,waypoints_number=1,a=0.5,v=0.5):
        if tool_configuration==None:
            tool_configuration = [0.3,0,0.3,0,-np.pi/2,0]
        self.arm.set_max_acceleration_scaling_factor(a)
        self.arm.set_max_velocity_scaling_factor(v)

        # 设置路点
        waypoints = []
        for i in range(waypoints_number):
            target_pose = PoseStamped()
            target_pose.header.frame_id = self.reference_frame
            target_pose.header.stamp = rospy.Time.now()
            target_pose.pose.position.x = tool_configuration[6*i+0]
            target_pose.pose.position.y = tool_configuration[6*i+1]
            target_pose.pose.position.z = tool_configuration[6*i+2]
            q = quaternion_from_euler(tool_configuration[6*i+3],tool_configuration[6*i+4],tool_configuration[6*i+5])
            target_pose.pose.orientation.x = q[0]
            target_pose.pose.orientation.y = q[1]
            target_pose.pose.orientation.z = q[2]
            target_pose.pose.orientation.w = q[3]
            waypoints.append(target_pose.pose)
        rospy.loginfo("move_l:" + str(tool_configuration))
        self.arm.set_start_state_to_current_state()
        fraction = 0.0  # 路径规划覆盖率
        maxtries = 100  # 最大尝试规划次数
        attempts = 0  # 已经尝试规划次数

        # 设置机器臂当前的状态作为运动初始状态
        self.arm.set_start_state_to_current_state()

        # 尝试规划一条笛卡尔空间下的路径，依次通过所有路点
        while fraction < 1.0 and attempts < maxtries:
            (plan, fraction) = self.arm.compute_cartesian_path(
                waypoints,  # waypoint poses，路点列表
                0.001,  # eef_step，终端步进值
                0.00,  # jump_threshold，跳跃阈值
                True)  # avoid_collisions，避障规划
            attempts += 1
        if fraction == 1.0:
            rospy.loginfo("Path computed successfully. Moving the arm.")
            self.arm.execute(plan)
            rospy.loginfo("Path execution complete.")
        else:
            rospy.loginfo(
                "Path planning failed with only " + str(fraction) +
                " success after " + str(maxtries) + " attempts.")
        rospy.sleep(1)

6.4 Interaction avec l'environnement

# 在机械臂下方添加一个table，使得机械臂只能够在上半空间进行规划和运动
    # 避免碰撞到下方的桌子等其他物体
    def set_scene(self):
        ## set table
        self.scene = PlanningSceneInterface()
        self.scene_pub = rospy.Publisher('planning_scene', PlanningScene, queue_size=5)
        self.colors = dict()
        rospy.sleep(1)
        table_id = 'table'
        self.scene.remove_world_object(table_id)
        rospy.sleep(1)
        table_size = [2, 2, 0.01]
        table_pose = PoseStamped()
        table_pose.header.frame_id = self.reference_frame
        table_pose.pose.position.x = 0.0
        table_pose.pose.position.y = 0.0
        table_pose.pose.position.z = -table_size[2]/2 -0.02
        table_pose.pose.orientation.w = 1.0
        self.scene.add_box(table_id, table_pose, table_size)
        self.setColor(table_id, 0.5, 0.5, 0.5, 1.0)
        self.sendColors()

7. Fondation Moveit (C++) pour réaliser une planification de chemin avec des contraintes

8. Motion Planning - Comment choisir l'algorithme de planification dans Moveit ?

8.1 Pourquoi la planification du chemin est nécessaire

Ø Évitement d'obstacles : éviter les collisions avec des objets statiques à proximité du bras robotique tels que des tables ; éviter
les collisions avec des objets dynamiques tels que des personnes (s'approchant soudainement)
Ø La tâche a des exigences sur la trajectoire de mouvement : avec des contraintes cinématiques ou dynamiques, telles que le soudage , Prenez
une tasse remplie d'eau , etc.
n Classification de planification de chemin
Ø Basé sur la recherche, Dijkstra, A*, Anytime A*, ARA*, D*
Ø Basé sur l'échantillonnage, PRM, RRT, RRT-connect, RRT*, Kinodynamic-
RRT* (Conforming to dynamics), Anytime RRT*, Informed RRT*
Ø Algorithmes intelligents tels que l'algorithme génétique, l'algorithme de colonie de fourmis
Algorithme de planification de chemin basé sur l'échantillonnage
Ø Connaissances de base : introduction complète : la solution sera trouvée lorsque le temps sera infini ;
Ø PRM : 1. Premier échantillonnage aléatoire de n points pour former Figure 2. Recherche basée sur des graphes
Ø RRT : recherche rapide d'arbres aléatoires, de solutions non optimales ; l'interrogation de proximité peut utiliser kdtree et d'autres structures de données pour
trouver rapidement le nœud le plus proche dans le arbre
Ø RRT-connect : RRT bidirectionnel étendu, s'étendre à partir du début et de l'objectif en même temps, et la vitesse de recherche est relativement
rapide. L'algorithme par défaut de ros-moveit
Ø RRT* : deux améliorations ont été apportées, l'une consiste à modifier le règles pour connecter de nouveaux nœuds à l'arborescence, et l'autre consiste à "élaguer" l'opération d'arborescence
de recherche pour la rendre plus proche du chemin optimal réel

8.2 Comment choisir un algorithme de planification de trajectoire

1. Rviz
   
2. Moveit_setup_assistant
   
   
3. dans le programme

9. Évitement d'obstacle visuel

9.1 Présentation

9.2 Démo officielle

Ø Une seule entrée de nuage de points/carte de profondeur est nécessaire pour générer une carte raster ;

$ roslaunch moveit_tutorials obstacle_avoidance_demo.launch

Ø Les obstacles cylindriques peuvent être générés à partir de la carte quadrillée

$ roslaunch moveit_tutorials detect_and_add_cylinder_collision_object_demo.launch

(Remarque : lors de l'exécution de cette instruction, vous devez fermer la commande précédente)
Package de fonctions :

https://github.com/ros-planning/moveit_tutorials
https://github.com/ros-planning/panda_moveit_config

9.3 Combat réel

roslaunch ur5_moveit_config demo_with_obstacle_avoidance.launch

Principales étapes
Ø 1. Démarrer le programme camera ros

$ sudo apt-get install ros-melodic-realsense2-camera
$ sudo apt-get install ros-melodic-realsense2-description
$ roslaunch realsense2_camera demo_pointcloud.launch

Ø 2. Modifier le fichier de configuration de moveit
(1) Modifier le point_cloud_topic de xxx_moveit_config/config/sensors_kinect_pointcloud.yaml pour être
le sujet publié par votre nuage de points de caméra
(2) ou modifier le image_topic de xxx_moveit_config/config/sensors_kinect_depthmap.yaml
pour être le sujet publié par votre propre carte de profondeur de caméra
Ø 3 (Facultatif) Modifier les paramètres d'évitement d'obstacles visuels, tels que la résolution de la grille octomap_resolution, etc.
Ø 4 (Facultatif) Modifier les paramètres de la caméra, tels que la résolution, la fréquence de mise à jour, etc.
Ø 5. Publier le position de la caméra par rapport aux coordonnées de base du manipulateur

<node pkg="tf2_ros" type="static_transform_publisher"
name="camera_to_robot" args="0.72032458 -0.21936176 0.90925255
0.98422218 0.0969083 -0.04779138 0.14011233 camera_color_optical_frame
world" />

roslaunch ur5_moveit_config demo_with_obstacle_avoidance.launch

Référence https://blog.csdn.net/ssw_1990/article/details/104053041
Référence https://blog.csdn.net/ssw_1990/article/details/104053041

10. ROS et apprentissage en profondeur

10.1 Présentation

ROS-Moveit !

ROS-melodic以及之前版本Moveit!默认使用python2.7
ROS-noetic以及ROS2支持python3

Deep learning
Le deep learning utilise python3, et le deep learning a généralement besoin de configurer l'environnement dans un environnement virtuel
Comment intégrer le deep learning dans ROS ?

10. 2 Combat réel

n Coexistence de ROS et Anaconda
Ø 1. Installation de ROS en un clic

$ wget http://fishros.com/install -O fishros && bash fishros

Ø 2. Installer anaconda
https://blog.csdn.net/KIK9973/article/details/118772450
Baidu recherche le tutoriel d'installation anaconda correspondant à la version ubuntu
Ø 3. Créer un environnement virtuel dans anaconda

conda create -n YOUR_ENV_NAME
pyhton=3.7

Ø 4. Installer la bibliothèque ros dans l'environnement virtuel

$ conda activate
$ pip install rospkg/rospy

Remarque : qu'il s'agisse d'un environnement virtuel ou non, tant que rospkg est installé, vous pourrez trouver des packages ros tels que rospy,
std_msgs, etc., afin que la communication de sujet et la communication de service puissent être effectuées
. Encapsuler la fonction moveit dans un serveur (Cours 6 - Communication du service Moveit Basic-python/ros)

$ rosrun ur_planning moveitServer.py

Ø 6. Écrivez un client dans le script dans l'environnement et connectez-vous à la fonction moveit via la communication de service

11. Réalisez une capture visuelle 6-DOF basée sur ROS-Moveit

11.1 Saisie visuelle

1. Capture de plan
   Ø Jeu de données Cornell : 1035 images RGBD, 8019 étiquettes
   Ø Jeu de données Jacquard : 54K images RGBD, 1,1 million d'étiquettes
   Ø Algorithme de capture de plan classique : GGCNN[1], GRCNN[2],
   Swin-Transformer[3] ]
2. Six degrés de liberté pour saisir
   l'ensemble de données GraspNet-1Billion

11. Conception du cadre du système

n Planification de mouvement
Ø Fonction : Arriver à
la position et à l'attitude spécifiées par l'algorithme
Ø Planification de trajectoire : Planifier une trajectoire sans collision de la
position actuelle à la position attendue n Étalonnage œil-main Ø Fonction : Obtenir la relation entre le système de coordonnées du robot et le système de coordonnées de la caméra Ø Effet : Actuellement disponible Atteindre une erreur de ± 5 mm

11. 3 Expérience de ramper

n préhension[6] Expérience de préhension d'objet unique
Liste des objets saisis :
11 objets au total : 1. Pomme 2. Banane 3. Lampe de poche 4. Baseball 5. Brosse à chaussures 6.
Boîte de badminton 7. Radio 8. Nettoyant pour doudoune
9. Petit nettoyeur de chaussures blanc 10. Disque U 11. Télécommande

11.3 Expérience d'exploration

n Graspness[6] expérience de préhension continue de scène complexe
Ø Conclusion : par rapport à d'autres algorithmes, les résultats de prédiction de pose de préhension de préhension[6] sont plus précis ;
la préhension peut également être détectée pour la plupart des petits objets et des objets de la même couleur que l'arrière-plan Attitude , la robustesse est plus forte.
Ø Problèmes existants :
l Les objets trop "plats" et de faible hauteur rendent difficile la détection de la posture de préhension
l Pendant le processus de préhension, des collisions avec d'autres objets peuvent se produire