IMA3/IMA4 2021/2023 P9

De Wiki de Projets IMA

Sommaire

1 - Semestre 7 :

  I- Objectifs du semestre 7 
II- Robot Nyrio NED1
III- Traitement d'image et Aphelion
IV- Etat d'avancement
V- Perspectives pour le Semestre 8

2 - Semestre 8 :

  I- Contexte et objectifs du semestre 8 
II- Notes opérationnelles
III- Etat des lieux
IV- Rapport d'avancement
V- Présentation des résultats (vidéo)


SEMESTRE 7

Objectifs du semestre 7

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
      
      • Dans la ligne 2 on utilise la bibliothèque PIL sauvegarder l’image sur son ordinateur
      • Dans la ligne 9 on met à jour les outils connectés au robot pour pouvoir utiliser le camera.
      • Dans la ligne 12 on obtient l’image du flux vidéo dans un format compressé pour éviter de saturer le réseau.
      • Dans la ligne 13 on décompresse l’image compressé.
      • Après on affiche l’image et la sauvegarde sur l’ordinateur.


      Traitement d'image et Aphelion

      Aphelion, un logiciel pour le traitement d’image

      Depuis plus de 25 ans, ADCIS fournit des produits logiciels de traitement et d’analyse d’images qui sont reconnus et appréciés. Aphelion Dev est le logiciel de choix pour les personnes qui développent des applications avancées en imagerie. Il bénéficie de l’expertise de l’équipe de développement d’ADCIS et des partenariats stratégiques avec des laboratoires de recherche internationaux. De plus, l’équipe d’ADCIS est reconnue pour l’efficacité et le professionnalisme du support technique fourni à ses clients.
      L’interface utilisateur d’Aphelion Dev exploite les plus récents outils de Windows®, tels les composants .Net® et les outils de développement associés. Cette interface guide le nouvel utilisateur depuis l’acquisition d’images, en passant par l’analyse et le traitement, jusqu’à la génération d’un rapport d’analyse prêt à l’emploi. Dev fournit aux utilisateurs les plus expérimentés des outils pour développer des traitements avancés et automatisés qui deviennent rapidement des applications prêtes à être déployées. Plusieurs langages de macro-commandes sont disponibles afin d’automatiser une application d’imagerie.

      Le traitement d’image, qu’est ce que c’est?

      Trois grandes étapes résumées:
      - Acquisition : de la scène physique à une forme numérique (capteur + système de numérisation)
      - Pré-traitement : amélioration de la qualité de l’image (Restauration d’images, compression d’images, amélioration d’images)
      - Analyse : extraction de l'information essentielle dans l’image (Segmentation, Représentation et Description structurelle, Reconnaissance des formes)
      - Interprétation : description sémantique de l’image (Passage à la description sémantique en regard à certains objectifs, Mesure de paramètres sur des formes, Description du contenu de la scène en termes de concepts non mathématiques, Modèles de connaissance pour estimer et prendre des décisions, Gestion de la base de connaissances, Système d’interrogation, Evaluation de la pertinence des réponses, Prise de décision)


      Deux niveaux de traitement des images : Haut Niveau et Bas Niveau

      Notre démarche s’inscrit dans le traitement d’image de bas niveau où les différentes étapes sont:
      - Acquisition, numérisation
      - Transmission, compression
      - Rehaussement, restauration, amélioration, filtrage (prétraitements)
      - Segmentation (contours, régions, texture)
      - Reconnaissance des formes
      - Compréhension de l’image
      - Aide au diagnostic
      - Commande d’automatismes

      Le Haut Niveau de traitement d’image n’est pas nécessaire dans notre cas de figure, il est surtout utile pour des tâches plus complexes et sert à réaliser une interprétation d'images utilisant des connaissances expertes.

      Domaines d’application du traitement d’images


      -Imagerie aérienne et spatiale (Ressources naturelles et humaines, surveillance, météorologie,..)
      -Industrie (Contrôle, Inspection et mesures automatiques, Vision robotique)
      -Médecine (Cytologie, Tomographie, Echographie)
      -Sciences (Interventions en milieu confiné, Astronomie, Robotique mobile,
      -Biologie, Microscopie électronique)
      -Art et communication (Télévision et vidéo, Transport information visuelle, Photographie, Edition, Archivage)
      -Domaine militaire (Surveillance, Guidage automatique et poursuite d'engins, Topographie) Dans notre cas de figure, il est question d’application dans l’industrie, ou on retrouve des projets qui s’apparentent au nôtre.

      Prétraitement : amélioration de la qualité de l’image (Amélioration et Restauration d’images)

      Amélioration de l’image:

      Nous allons d’abord nous pencher sur l’amélioration d’image avant de passer à la restauration. Les techniques de prétraitement visant à l’amélioration de la qualité visuelle de l’image sont :


      - Modification de l’histogramme
      - Recadrage de la dynamique (Linéarisation)
      - Egalisation

      Modification d’histogramme par recadrage de la dynamique (Linéarisation)

      L'intérêt des histogrammes réside dans l’évaluation de la qualité de la numérisation (amélioration) et l’adaptation de la dynamique des densités à la dynamique des niveaux de quantification Le redressement permet d'aligner horizontalement une image numérisée pour compenser l'inclinaison. Cette option permet de régler le contraste et la luminosité des images en couleur ou en niveaux de gris. Convertit les images en couleur en images à niveaux de gris.

      Modification par égalisation

      En traitement d'images, l'égalisation d'histogramme est une méthode d'ajustement du contraste d'une image numérique qui utilise l'histogramme. Elle consiste à appliquer une transformation sur chaque pixel de l'image, et donc d'obtenir une nouvelle image à partir d'une opération indépendante sur chacun des pixels.

      Restauration de l’image:

      A présent nous allons nous concentrer sur la restauration de l’image. L’objectif de la restauration est d’éliminer au maximum les distorsions du système d’acquisition afin d’obtenir une image la plus proche possible de l’image idéale. Ces distorsions peuvent êtres d’origines différentes. En effet, le “bruit” peut être lié au contexte de l’acquisition (mouvement, modification ponctuelle des conditions d’éclairage le rendant impossible à corriger sans l’opérateur humain), au capteur (distorsion des niveaux de gris ou à une mauvaise mise au point), à l’échantillonnage (effet « poivre et sel » au niveau de la discrétisation spatiale, mais peut être également lié à la nature de la scène Les techniques de prétraitement visant à la restauration de l’image après dégradations se décomposent en deux partie qui sont le lissage linéaire et le lissage non linéaire.

      L’hypothèse fondamentale derrière le filtrage linéaire est que la moyenne de plusieurs échantillons devrait réduire le bruit (i.e. l’écart-type du signal résultat du moyennage de N échantillons devrait être plus faible que celui de la distribution de laquelle proviennent ceux-ci. Il se caractérise par une invariance à la position (le résultat du filtrage ne dépend que du voisinage d’un pixel et non de la position absolue du pixel dans l’image, et respecte les principes de mise à l’échelle et de superposition Le filtrage non linéaire quant à lui permet de réduire le bruit impulsionnel (multiplicatif), ce que le filtre moyenneur (ou même gaussien) n’arrive pas à faire, préserve mieux les discontinuités (sans les adoucir), est généralement plus coûteux en temps de calcul que le filtre linéaire moyenneur, et ne respecte pas les propriétés de commutativité et d’associativité du filtre linéaire


      Analyse : extraction de l'information essentielle dans l’image (Segmentation)

      On appelle segmentation d'une image l'opération consistant à identifier les structures d'intérêt dans cette image. On distingue deux types d'approches pour la segmentation : contour ou région. Dans l'approche contour, on cherche à isoler le ou les contours des objets d'intérêt. Le résultat se présente en général sous la forme d'un ensemble de chaînes de pixels, et des traitements additionnels sont souvent nécessaires pour associer les contours aux objets d'intérêt. L'autre approche cherche à identifier des régions de pixels homogènes au sein de l'image. Le critère d'homogénéité peut être l'intensité, la couleur, ou même la texture locale. Le résultat se présente soit sous la forme d'une image binaire, soit d'une image étiquetée, chaque étiquette ou label correspondant à une région.

      Seuillage:

      Il existe plusieurs méthodes pour détecter de manière automatique la valeur du seuil à appliquer. L'une des plus répandues est la méthode d'Otsu. Elle consiste à faire l'hypothèse que l'image contient deux classes, décrites chacune par une partie de l'histogramme de l'image. La qualité du seuillage est quantifiée en mesurant la variance des niveaux de gris de chaque classe. On cherche ensuite la valeur de seuil qui minimise les variances des deux classes, et on utilise cette valeur pour binariser l'image

      Segm.PNG

      Le but est d’affecter chaque pixel d’une image en niveaux de gris à une classe. Les classes correspondent aux intervalles de niveaux de gris. Le principe consiste à extraire des seuils à partir de l’histogramme (image/région), avant de passer à la classification d’un pixel p par comparaison de I(p) aux seuils

      Segme.PNG

      Seuils.PNG

      Seuillage1.PNG

      Seuillage.PNG

      Contour.jpg


      Etat d'avancement du SEMESTRE 7

      Séance du 10.10.2022

      Ayant débuté notre projet au semestre 7 et non au semestre 6, nous avons fait les premières recherches sur notre sujet. Pour préciser on fait des recherches sur le robot Bra Niryo Ned 1. L'objectif du projet sera de réaliser le traitement d’image avec un capteur de vision (caméra), cela signifie prendre l’image avec la caméra et la transmettre à un logiciel de traitement d’image (Aphelion) pour enfin envoyer l’image traitée à un robot bras et exécuter l’instruction.

      Date: 21.10.2022

      Aujourd’hui on a essayé de mettre en place une communication avec le robot bras Niryo Ned 1. On a essayé d’abord de se connecter avec le raspberry Pi, qui est le système d’exploitation du Niryo. On a essayé de mettre en place une communication visuelle avec VNC Viewer, mais on a rencontré plusieurs problèmes avec cette méthode. Par exemple, il n’était pas possible de mettre à jour notre programme en vue de corriger les erreurs. Mais on a réussi à se connecter avec le robot via le programme Niryo Studio, mais également à réaliser la communication avec le robot directement via remote sur notre computer, à savoir avec Pyniryo, qui est un TCP API fait avec python. Aussi, on s’est familiarisé avec le code fourni dans la documentation PyNiryo, bien que nous ayons eu des difficultés à coder le contrôle des pinces du robot.

      Date: 28.10.2022

      Aujourd’hui, on a essayé de fixer le problème de la pince, mais on n’a pas réussi. Puis, on a avancé sur la communication d'une caméra avec le robot bras. L’image prise par le robot est de meilleure qualité si on connecte la caméra au USB Port 3.0 que 2.0.

      Date: 18.11.2022

      Aujourd’hui, on a consulté différentes sources sur internet afin d’essayer de fixer le problème de la pince. On a également échangé avec l’autre groupe qui travaille sur le Niryo Ned 1. Malheureusement, pas de succès. On a décidé d'abandonner le problème de pince compte-tenu du fait que la priorité est le traitement d’image.

      Date: 21.11.2022

      Aujourd’hui, on a mis en place la communication avec la pince via une bibliothèque différente, à savoir la bibliothèque Python Ros Wrapper mais il était plus compliqué de commander le Niryo. Nous avons également contacté le bureau d’Aphelion afin d’obtenir la clé d’activation en vue d’obtenir la licence pour une période d’essai d’un mois.

      Date: 25.11.2022

      Aujourd’hui, on a écrit le code pour obtenir l’image d’une caméra et on a commencé à se familiariser avec le logiciel Aphelion. On a relevé la nécessité d’une documentation plus approfondie pour mieux comprendre le logiciel. On a demandé au professeur quelques documents/ TP concernant Aphelion.

      Date: 28.11.2022

      Aujourd’hui on a travaillé avec le logiciel aphelion pour le comprendre mieux. On a appris ce que la signification de l’histogramme. L’abscisse donne l’information concernant la couleur, du gris et ses différentes nuances au RGB (rouge, bleu et vert). On a cherché à comprendre le fonctionnement du traitement d' image, à savoir la convolution de chaque pixel de l’image par une matrice symétrique. En fonction de la valeur de la matrice on peut obtenir différents résultats via le traitement d'image. Après plusieurs tentatives pour contrôler le robot à travers Aphelion qui se sont soldées par des échecs. Finalement, la seule solution pour atteindre cet objectif aurait été d’ajouter la bibliothèque PyNyrio au logiciel Aphelion, ce qui n’est pas possible comme ce dernier n’est pas OPENSOURCE.

      Date: 08.12.2022

      On a échangé avec Matéo Pourrier, futur membre de notre groupe de projet, qui nous rejoindra au prochain semestre. On a pris le temps de parler de l’état d’avancement du projet, de ce qui a été réalisé jusqu’à maintenant (code de contrôle du robot Niryo, traitement d’image via Aphelion), mais également des perspectives futures que nous prévoyons par la suite. Cet échange nous a permis de faire le point sur la soutenance du 06/01.

      Date: 15.12.2022

      Aujourd’hui, on a fait le bilan avec M.Lakhal pour faire le point sur l’avancement de notre projet, sur la soutenance et sur les perspectives futures que nous avons pour le prochain semestre.

      Perspectives

      Création d’une interface Format : Page web

      Fonctionnalités  : Capturer des images à distance

      Effectuer le traitement de l’image

      Transmettre les données obtenues au robot et le Commander


      Planning du S8

      Gantt.png


      SEMESTRE 8

      Contexte et objectifs du semestre 8

      Notes opérationnelles

      1- Définition des conteneurs

      Ce bout de code va nous permettre de définir l’interface d'accueil ,après cette étape là ,on a passé à définir les boutons pour accéder à chaque interface de travail. Pour chaque interface on a défini une fonction qui va permettre de créer et de détailler le fonctionnement de chaque interface.

      On prend comme exemple l’interface de traitement d’image P9S8im4.png

      Ce bout de code représente juste une partie de la définition de la fonction de cette interface.Après la définition de l’interface et de ses caractéristiques qui diffèrent pour chaque interface, on passe à l’étape de déclaration des Composants.


      2- Déclaration des composants

      Après avoir créé nos fenêtres et déclaré leur géométrie et caractéristiques nous avons dû ajouter à notre interface des composants tels que des boutons, des labels servant à accueillir du texte, ou encore des canvas, composants servant à accueillir des images ou des flux vidéos.

      Exemple de déclaration d’un bouton : P9S8im14.png

      Déclaration d’un label : P9S8im12.png

      Ces lignes de codes permettent d’instancier un composant, c'est-à-dire de créer en mémoire un objet qui garde en mémoire les informations et caractéristiques du composant.

      3- Le placement des composants

      Pour que les différents composants dont nous avions besoin pour accomplir nos objectifs apparaissent dans les interfaces que nous avons programmé, il faut désormais les placer dans la géométrie des différentes fenêtres.

      On utilise pour cela des outils appelés gestionnaires de placements, ou Layout Managers en anglais. Tkinter l’outil de programmation d’interface que nous utilisons permet l’utilisation de différentes méthodes de gestion de placement des composants.

      Dans notre projet nous avons utilisé les méthodes .place(), .pack() et .grid()

      La stratégie de positionnement pack : P9S8im5.png

      Elle divise le conteneur (dans notre projet les conteneurs sont les fenêtres créées pour les différentes interfaces) en cinq parties, le centre et les quatre côtés. Elle permet de disposer les composants de différentes manières autour de cette division du conteneur via ces différentes options.

      Le placement des composants de l’interface d'accueil ont été réalisés à l’aide de cette stratégie de positionnement : P9S8im2.png


      La stratégie de positionnement place :

      Cette stratégie est celle à utiliser lorsque l’on souhaite placer les composants de manière précise dans un conteneur. En effet, elle effectue le placement d’un composant aux coordonnées (x,y) passées en paramètre.

      Le placement des composants de l’interface de traitement d’image ont été réalisés à l’aide de la stratégie de positionnement place : P9S8im25.png

      La stratégie de positionnement grid :

      Cette dernière stratégie de positionnement permet de découper le conteneur en une grille contenant plusieurs cellules, chaque cellule étant désignée par sa ligne et sa colonne dans la grille. On place alors les composants dans la ou les cellules qui nous intéressent. Les options de la méthode rowspan et columnspan permettent d’assigner à un composant plusieurs cellules en largeur ou en hauteur.

      Le placement des composants de l’interface de contrôle du robot ont été réalisés à l’aide de la stratégie de positionnement grid (exemple sur les boutons attraper et relâcher) : P9S8im22.png


      Finalement, les trois membres du groupe ayant participé activement au code du projet et ayant des sensibilités différentes au niveau du placement des composants, nous nous sommes retrouvés à utiliser les trois stratégies de placement proposées par tkinter et nous avons ainsi pu comprendre certains des avantages et inconvénients de chacune de ces méthodes.













      4- Les fonctions de commande

      Maintenant que nous avions réussi à construire nos fenêtres (conteneurs) et les différents boutons et label dont nous avions besoin pour atteindre nos objectifs et garder une esthétique cohérente, il fallait désormais s'intéresser au code fonctionnel, aux fonctions que nous allions associer aux boutons en tant que “command”.

      Exemple pour le bouton Homepose :


      On définit tout d’abord la fonction de commande. On intègre ensuite à la fonction de commande l’entièreté du code que l’on souhaite exécuter lorsque l’utilisateur appuie sur le bouton.

      Ici pour le bouton Homepose on se sert simplement d’une fonction venant de la librairie PyNiryo qui permet de remettre les axes du robot en position initiale : .move_to_home_pose()

      Enfin lors de la déclaration du bouton, on le lie à sa fonction de commande via l’option de déclaration “command=home_pose”.

      Ces deux étapes, construction de la fonction de commande, et liaison avec le composant qui doit la déclencher, suffisent à obtenir un composant au comportement fonctionnel. Nous avons par la suite répété l’opération en créant une fonction de commande pour chacune des actions proposées par nos interfaces, toujours en nous basant sur la librairie de commande du robot PyNiryo et sur les possibilités qu’elle nous offrait.


      5- La phase de test

      Après avoir réalisé une partie fonctionnelle du code que nous trouvions satisfaisante, nous sommes passés à la phase de tests. A l’aide du robot Niryo Ned 1 de polytech nous avons testé toutes les fonctionnalités de notre interface. Nous nous sommes ainsi rendu compte de nombreuses erreurs dans le code que nous avons pu corriger. Nous avons également pu nous assurer que toutes les possibilités offertes par l’interface étaient fonctionnelles. Toutefois, certains paramètres non contrôlables par l’interface elle-même (tel que la connexion wifi de la machine exécutant l’interface avec le robot utilisé) impliquent que certains cas d’erreurs subsistent. La prochaine étape de notre projet a été de trouver une parade à ces cas d’erreur.


      6- La gestion des cas d’erreurs : Les exceptions

      Dans un souci de simplicité pour l’utilisateur nous avons cherché à minimiser au maximum les cas d’utilisation de l’interface menant à des erreurs. Heureusement les langages orientés objets permettent pour cela de s’appuyer sur un élément très intéressant : les exceptions.

      En langage objet une exception est un objet qui représente une erreur, décuplant les possibilités de gérer cette erreur. Une fonction attrapant une exception pourra ainsi ignorer l’erreur ou la transmettre à la fin de son exécution. Une des erreurs les plus fréquentes de notre interface est une erreur de connexion lors de la connexion au robot, ou lors de la création d’une instance ROS servant à accéder à la caméra du robot. En effet si on essaye d’effectuer une de ses actions sans être connecté au wifi du robot, on obtiendra forcément une erreur et on arrêtera le fonctionnement de cette partie de l’interface, ce qui n’est pas acceptable.

      L’intégration de blocs try catch servant à intercepter l’exception causée par cette erreur nous permet d’isoler cette erreur de l'exécution du reste du code, et ainsi de ne pas causer d’erreur au niveau du fonctionnement de l’interface, tout en renvoyant un message d’erreur pour avertir l’utilisateur du problème.

      Exemple du cas d’erreur explicité précédemment :

      Dans la fonction de commande associée à “Connexion” on a placé un bloc try catch, ainsi qu’un appel à la messagebox de tkinter pour renvoyer un message informatif en cas d’erreur comme ceci :


      Ainsi si on est pas connecté au wifi d’un robot et que l’on essaye d’appuyer sur connection on obtient ce message d’erreur :


      Nous avons appliqué ce principe de gestion des erreurs pour certains cas identifiés comme entravant le fonctionnement de l’interface et ainsi limiter les problèmes lors de l’utilisation de celle-ci.

      7- La recherche d’ergonomie

      Finalement, nous avons consacré nos derniers efforts à la recherche d’ergonomie. En effet, pour améliorer notre travail et faciliter l’utilisation de l’interface, nous avons mis en place plusieurs démarches :

      Le visuel de l’interface :

      Pour simplifier l’expérience utilisateur nous avons choisi de garder l’interface sobre et la plus compréhensible possible. Au niveau de l’interface de traitement d’image, nous avons choisi d’expliciter les actions en proposant des boutons dont le design est basé sur des images représentant leur fonctionnalité. Pour le panneau de contrôle nous avons organisé cela de manière logique en proposant des groupes de composants qui ont des points communs au niveau de leur fonctionnalité.

      L’information transmise à l’utilisateur :

      Lors du développement de ces interfaces il nous a plusieurs fois semblé nécessaire pour la bonne utilisation de celles-ci de transmettre des informations supplémentaires sur son fonctionnement à l’utilisateur.

      Dans cet objectif nous avons décidé d’utiliser une technique assez répandue dans le développement logiciel et d’interface utilisateur, les info-bulles (tooltips en anglais). Les info-bulles ou bulles d’aide sont des messages qui apparaissent lorsque l’utilisateur passe sa souris au-dessus d’un composant de l’interface. Elles permettent donc de transmettre de manière ergonomique et efficace de l’information à l’utilisateur sur la fonction logique associée au composant survolé.

      Pour cela nous avons utilisé la librairie PMW (PythonMegaWidgets) qui contient de nouvelles classes de composants pour le développement d’interface via tkinter. Cette librairie nous permet d’utiliser une classe construite spécifiquement pour réaliser des info-bulles, la classe Baloon. De cette manière nous avons pu équiper nos composants d’informations supplémentaires et en simplifier l’utilisation :


      Exemple de résultat obtenu pour les info-bulles :


      Etat des lieux

      Rapport d'avancement

      =
      Présentation des résultats
      =