IMA3/IMA4 2021/2023 P9

De Wiki de Projets IMA
Révision datée du 5 janvier 2023 à 20:49 par Hzhu (discussion | contributions) (Logiciel)

Sommaire

I- Objectifs du semestre

II- Robot Nyrio NED1

III- Traitement d'image et Aphelion

IV- Perspectives

Objectifs

Se familiariser avec le Robot NED 1 et sa bibliothèque PyNiryo en testant plusieurs applications.

Utilisation de la caméra et l'obtention de plusieurs images qui vont nous servir pour le traitement d'image.

Expérimenter le traitement d’image avec le logiciel Aphelion.

Tenter de contrôler le robot à travers le logiciel Aphelion.




NIRYO NED 1 AVEC PYNIRYO 1

Niryo ned presentation.png

Le Robot

Ned est un bras robot collaboratif 6 axes conçu pour l’éducation et la recherche. Ned est conçu pour reproduire tous les mouvements requis dans les utilisations les plus avancées de l’industrie 4.0, avec une précision et une répétabilité de 0.5mm. La structure en aluminium de Ned lui confère une robustesse exemplaire, lui permettant d’accomplir avec fluidité les mouvements nécessaires à vos projets de robotique. Ce robot tire pleinement profit des capacités de la Raspberry Pi 4, avec un processeur 64-bit ARM V8 haute performance, 2Go de RAM, et une connectivité améliorée. Ned est un robot basé sur Ubuntu 18.04 et ROS (Robot Operating System) Melodic, une solution open-source complète conçue pour la robotique. Avec ROS, Ned dispose d’un ensemble de librairies permettant de concevoir des programmes les plus simples aux plus complexes pour répondre à vos besoins de manière flexible.


Les spécifications techniques des outils de Ned

Avec le système Easy Connect, changer d’outil n’a jamais été aussi simple. Il vous suffit de brancher votre outil, de connecter son câble et il est prêt à être utilisé. Ned est fourni avec un Gripper Custom. Ses mors standards peuvent manipuler de petits objets, et si vous possédez une imprimante 3D, vous pouvez créer vos propres mors.

Overview gripper.png

Ned peut également être utilisé avec :

  • Le Gripper Large qui a la capacité de saisir des objets plus gros tout en gardant la possibilité de se fermer entièrement.
  • Le Gripper Adaptatif qui permet au robot de saisir des objets non standards avec des formes complexes (ex. un œuf).
  • La Pompe à vide pour saisir des objets avec des surfaces planes et non poreuses. L’Électroaimant utile pour manipuler de un à plusieurs objets métalliques (ex. vis, boulons…).
  • L’écosystème de Ned est conçu pour vous permettre de reproduire des cas d’utilisation avancés de l’industrie 4.0
    • Standard gripper schema.png

      Les spécifications techniques du Gripper Custom

      Specifications techniques gripper.png

      Spécifications techniques de Ned

      Ned skelette.png

      Parametres techniques 1.png

      Parametres techniques 2.png

      Interface mécanique


      Ned est un bras robot 6 axes collaboratif. Il se compose de six articulations robotisées en aluminium recouvertes de plastique. Ned comprend 7 parties :

      Interface meca 7 composants.png

      Schema meca.png

      Espace de travail - Ned

      Espace de travail 1.png

      Espace de travail 2.png

      Logiciel

      Ned est un robot basé sur Raspberry, Arduino & ROS. Il utilise ROS afin de créer une interface entre le matériel et les liaisons de haut niveau. Voici sur le schéma suivant un aperçu global du logiciel de Ned afin de comprendre où sont placées chaque partie du logiciel.

      Ros stack global overview.png

      PyNiryo est une API TCP créée avec Python, qui permet aux développeurs de créer des programmes robotiques et de contrôler les robots en communiquant à distance par le biais de leurs ordinateurs. Contrairement au Wrapper ROS Python, l’utilisateur ne nécessitera pas d’être connecté au robot par le biais d’un terminal.

      Avant de programmer avec la bibliothèque PyNiryo 1, il faut avoir installé le langage de programmation Python sur son ordinateur. La version doit être égale ou supérieure:

      • 2.7 si vous utilisez Python 2
      • 3.6 si vous utilisez Python 3

      Après, on vous montre quelque exemple du code avec PyNiryo 1:


      Premier code pour tester le fonction de base

      
      from pyniryo import*
      
      #l'adresse 'robot_ip_address' depend de son connection
      #avec le robot
      
      #si Connexion ethernet directe: 169.254.200.200
      #si Mode Hotspot: 10.10.10.10
      #si Simulation ou directement sur le robot: 127.0.0.1
      #si l'Ordinateur et robot sont connectés au même routeur: il faut trouver
      #l'addresse IP du robot dans le VLAN
      
      robot_ip_address = "10.10.10.10"
      
      #connecter avec le robot et calibrer le
      robot = NiryoRobot(robot_ip_address)
      robot.calibrate_auto()
      
      #bouger les axes
      robot.move_joints(0.2, -0.3, 0.1, 0.0, 0.5, -0.8)
      
      #allumer le mode learning
      robot.arm.set_learning_mode(True)
      
      #arrêter le connection TCP
      robot.close_connection()
      
      
      • Dans la ligne 1 on importe toutes les fonctions de la bibliothèque ‘pyniryo’.
      • Dans la ligne 12 on définit l’adresse du robot, qui dépend de notre connexion avec Ned.
      • Dans la ligne 15 on crée une instance de la classe NiryoRobot avec l’adresse IP correspondante pour avoir l’accès à toutes les fonctions du robot.
      • Dans la ligne 16 on démarre une calibration automatique des moteurs si les moteurs n’ont pas encore été calibrés.
      • Dans la ligne 19 on bouge les 6 axes du robot en donnant la position des 6 axes en radians (6 floats)

      Max rotation.png


      Il a y aussi le possibilité de bouger les robots avec:

      'NiryoRobot.move_pose(x, y, z, roulis, tangage, lacet)’

      x,y,z (floats) sont exprimés en mètres et roulis, tangage, lacet (floats) sont exprimés en radians

      Roulis tangage lacet.png

      • Dans la ligne 22 on allume ‘learning mode’, qui nous permet de bouger Niryo au main et récupère la position
      • Dans la ligne 25 on arrête la connexion avec Niryo

      Code pour utiliser le gripper

      from pyniryo import*
      
      robot_ip_address = "x.x.x.x" # Robot address
      
      # The pick pose
      pick_pose = PoseObject(
      x=0.25, y=0., z=0.15, roll=-0.0, pitch=1.57, yaw=0.0)
      
      # The Place pose
      place_pose = PoseObject(
      x=0.0, y=-0.25, z=0.1,
      roll=0.0, pitch=1.57, yaw=-1.57)
      
      def pick_n_place_version_2(robot):
      
          height_offset = 0.05  # Offset according to Z-Axis to go over pick & place poses
          gripper_speed = 400
      
          pick_pose_high = pick_pose.copy_with_offsets(z_offset=height_offset)
          place_pose_high = place_pose.copy_with_offsets(z_offset=height_offset)
      
          # Going Over Object
          robot.move_pose(pick_pose_high)
          # Opening Gripper
          robot.open_gripper(gripper_speed)
          # Going to picking place
          robot.move_pose(pick_pose)
          # Closing gripper
          robot.close_gripper(gripper_speed)
          # Raising
          robot.move_pose(pick_pose_high)
          # Going Over Place pose
          robot.move_pose(place_pose_high)
          # Going to Place pose
          robot.move_pose(place_pose)
          # Opening Gripper
          robot.open_gripper(gripper_speed)
          # Raising
          robot.move_pose(place_pose_high)
      
      if __name__ == '__main__':
          # Connect to robot
          client = NiryoRobot(robot_ip_address)
          # Calibrate robot if robot needs calibration
          client.calibrate_auto()
          # Changing tool
          client.update_tool()
          # Commence du fonction pick_n_place
          pick_n_place_version_2(client)
          # Releasing connection
          client.close_connection()
      
      • Dans les lignes 5-12 on définit les positions de saisir et déposer
      • Dans ligne 17 il faut définir la vitesse du mouvement du gripper
      • Dans les lignes 19-20 on définit les positions un peu dessus des positions de saisir et déposer
      • Dans les lignes 22-35 on fait le process de se rendre jusqu'à la position de prélèvement avec move_pose, d’avant saisir un objet avec close_gripper, on ouvre le gripper avec open_gripper. Après on se rend à la position de placement et on y place l’objet.
      • Dans ligne 47 update_tool() est pour équiper un nouvel outil. Cette fonction scannera les connexions au moteur et ajoutera le nouvel outil
      • Dans ligne 51 on déconnecte alors le robot.

      Code pour utiliser l’autre outil

      from pyniryo import*
      
      robot = NiryoRobot("10.10.10.10")
      
      robot.calibrate_auto()
      robot.update_tool()
      # Pour relâcher un objet avec n’importe quel outil, vous pouvez utiliser la fonction
      robot.release_with_tool()
      robot.move_pose(0.2, -0.1, 0.25, 0.0, 1.57, 0.0)
      # Afin d’attraper des objets avec n’importe quel outil, vous pouvez utiliser la fonction
      robot.grasp_with_tool()
      robot.move_pose(0.2, 0.1, 0.25, 0.0, 1.57, 0.0)
      robot.release_with_tool()
      robot.close_connection()
      

      Dans ligne 9 pour relâcher un objet avec n’importe quel outil, on peut utiliser la fonction release_with_tool()

      • Open gripper pour les grippers
      • Push Air pour la Pompe à Vide
      • Deactivate pour l’Électroaimant

      Dans ligne 13 Afin d’attraper des objets avec n’importe quel outil, on peut utiliser la fonction grasp_with_tool()

      • Close gripper pour les grippers
      • Pull Air pour la Pompe à vide
      • Activate pour l’Électroaimant

      Code pour utiliser le gripper

      from pyniryo import*
      from PIL import Image  # PIL = Pillow Library
      
      #source website https://note.nkmk.me/en/python-numpy-image-processing/
      #another source https://www.pluralsight.com/guides/importing-image-data into-numpy-arrays
      
      robot = NiryoRobot("10.10.10.10") #hotspot mode
      robot.calibrate_auto()
      robot.update_tool()
      
      #getting image
      img_compressed = robot.get_img_compressed()
      img_array = uncompress_image(img_compressed)
      
      #displaying
      show_img_and_wait_close("img_stream", img_array)
      
      #transfers image_array into image file and saves it in the designated path
      im_jpg = Image.fromarray(img_array)
      img_array.save('~/Desktop/image_niryo.jpg') # ~ = user’s home directory