lien grille pour évaluation: https://docs.google.com/spreadsheets/d/1-GFa5u3AicSfcBG0TzpTJewggLuV82Io9rb1VjS_SO4/edit#gid=0 Pour que l'emulateur CS9 libère le serveur modbus TCP, il faut cliquer sur le pendant sur VAL3, application STOP lien vers page de développement: [[staublimodbus]] lien vers page recette pour compilation QT vers windows:[[deployqt]] =====Planning===== Partie BVDP: 4h CM 4h TP 2h TD codage MAE 4h TP {{https://bvdp.inetdoc.net/files/iut/staubliiut/images/8h.jpeg}} =====Organisation des TP et rôles des PC===== ===Remarque=== Par rapport au cours, dans le TP, les étapes 3 et 4 ne sont pas réalisées l'une après l'autre mais vous commencerai par réaliser un programme simple sans faire appel au parallélisme pour en voir les limites. Puis dans un second temps, nous réaliserons deux programmes séparés comme montré dans les étapes 3 et 4 afin d'illustrer l'intérêt du parallélisme. ===Travail en binôme=== Vous travaillerez en binômes sur deux PC voisins, en vous loguant sur le même compte sur chacun des postes afin de pouvoir partager aisément les fichiers. Vous utiliserez les mêmes PC au cours des différentes séances. Un PC jouera le rôle d'hôte pour les serveurs TCP et le second PC servira aux clients. Vous relèverez l'adresse IP de l'interface sur le VLAN rouge (IP commençant en 172.16.8...) du PC utilisé en tant que serveur. ===Évaluation=== Vous serez évalués en binôme et la note dépendra de votre participation au TP, du travail validé en séance et du projet rendu à la fin des TP sous forme d'une archive ZIP de votre dossier de projet. =====Liens utiles et Documentations===== Lien vers le cours d'intégration robotique BUT3 AII: https://bvdp.inetdoc.net/files/iut/staubliiut/cours_integration_ROBOTIQUE_BVDP_2024.pdf Lien vers le cours de robotique BUT2 AII: https://bvdp.inetdoc.net/files/iut/staubliiut/cours_ROBOTIQUE_BVDP_2023.pdf documentation langage VAL3: https://bvdp.inetdoc.net/files/iut/staubliiut/robot_srs_et_controleur/Manuel%20de%20ref%20VAL3.PDF lien vers le sujet de SAE robotique 2: [[saerobotique]] Schémas électrique du CS9: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/D28093901K.PDF dont documentation connecteurs ethernet: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/D28093901K.PDF#page=44 dont documentation connecteurs Fast I/Os: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/D28093901K.PDF#page=49 doc détaillée du CS9: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/D28094001G.PDF Multitâche et séquencement: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/Real%20Time%20Val3-Fieldbus%20Synchronization%20TSS00001404A.pdf doc modbus: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/Modbus%20Configuration%20CS8C-CS9_TSS00001604A.pdf doc sur les sockets: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/Socket%20TCP-IP_TSS000000904A.pdf ===Doc pour prof uniquement=== https://bvdp.inetdoc.net/files/iut/staubliiut/doc/CS9%20external%2024%20volt_TSS000000604C.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/CS9_external_axis_TSS00000204C.pdf doc OPCUA: https://bvdp.inetdoc.net/files/iut/staubliiut/doc/Using%20OPC%20UA%20with%20CS9%20Controller_TSS000000704E.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/DocPlayer.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/EtherCat%20IO%20Modules%20TSS00001304B.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/Instruction%20Manual%20VALtrack_s8.2.0.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/optimizeLab_howTO_allUser.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/staubli%20secu.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/Sycon.net_scanning_functions_TSS000000304A.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/TwinCAT3_basic_use_TSS000000504A.pdf https://bvdp.inetdoc.net/files/iut/staubliiut/doc/UnivalDrive%20with%20CS9%20-%20twinCat%20over%20EtherCAT_TSS000001804B.pdf =====Récupérations des fichiers===== ====Programmes pour la communication Modbus TCP==== Récupérer et dezipper sur R:\s5aii\s5aii"X"\"nom_prenom"\robotiqueintegration\ : https://bvdp.inetdoc.net/files/iut/staubliiut/modbus/EasyModbusClient%20%28.NET%20Version%29.zip et https://bvdp.inetdoc.net/files/iut/staubliiut/modbus/EasyModbus%20Server%20Simulator%20%28.NET%20Version%29.zip ===Wireshark=== Récupérer et installer sur R:\s5aii\s5aii"X"\"nom_prenom"\robotiqueintegration\ : https://bvdp.inetdoc.net/files/iut/staubliiut/modbus/wireshark-portable-3-5-0.exe ===Simulateurs Festo=== Récupérer et dezipper AVEC 7ZIP R:\s5aii\s5aii"X"\"nom_prenom"\robotiqueintegration\ : https://bvdp.inetdoc.net/files/iut/staubliiut/modbus/tcp_server_windows.zip et https://bvdp.inetdoc.net/files/iut/staubliiut/modbus/tcp_server_simulator_windows.zip ====Projet de départ SRS et CAO==== Télécharger et décompresser le fichier suivant afin que le dossier CELL_IUT0 soit dans le dossier R:\s5aii\s5aii"X"\"nom_prenom"\robotiqueintegration\staubli : https://bvdp.inetdoc.net/files/iut/staubli/projets_SRS/Cellule_depart_staubli_vide.zip Récupérer le modèle STL de la pince Schunk et du préhenseur de cylindre FESTO: https://bvdp.inetdoc.net/files/iut/staubli/stl/adaptateur_pince_festo_iut2023_open.stl Récupérer le modèle STL de la station de tri FESTO: https://bvdp.inetdoc.net/files/iut/staubli/stl/station_tri_simple.stl Récupérer le modèle STL de cylindre: https://bvdp.inetdoc.net/files/iut/staubli/stl/cylindre_festo_LR.stl =====Communication Modbus TCP===== ===Analyse des trames Modbus=== Lancer EasyModbusClient sur un PC, EasyModbusServer sur le PC voisin et Wireshark sur l'un des deux postes au choix (En ignorant les éventuelles mises à jour proposées). Nous allons générer des codes fonctions 4 et 6 afin de lire et d'écrire vers la case mémoire 1 de l'unit ID 1 différentes valeurs d'octets (que nous appellerons $V$). Vous devrez relever les différents octets échangés entre les deux applications dans les segments TCP modbus et faire apparaitre chacun des champs dans les requettes et réponses. Vérifier que le champ de donnée varie bien en fonction de $V$. Pour cela: * Régler l'adresse IP du serveur dans l'application client. * Cliquer sur connect * Sur le serveur dans l'onglet Input Registers, régler Value à 45 en face de Address 1 * Sur le client cliquer sur Read Input Registers FC4 (avec Starting Address=1 et Number of Values=1) et vérifier que la valeur 45 apparaît bien à droite * Sur le client, relever les indices et les valeurs des octets des requêtes et réponses et retrouver la valeur 45 telle qu'elle est codée. * Retrouver dans Wirshark les 2 paquets Modbus correspondants. * Répeter la même procédure pour la valeur 400 et retrouver où elle est codée dans le paquet et sous quel format (notamment l'ordre des octets dans le mot) * Sur le client, dans Prepare register, saisir 141 et cliquer sur la flèche à gauche, puis sur FC6 (avec Starting Address=1) * Sur le serveur dans l'onglet Holding Registers, vérifier que Value est bien passé à 141 en face de Address 1 * Sur le client, relever les indices et les valeurs des octets des requêtes et réponses et retrouver la valeur 141 telle qu'elle est codée. * Retrouver dans Wirshark les 2 paquets Modbus correspondants. Grâce à l'affichage dans l'application Client, Wireshark peut sembler inutile pour l'échange entre les EasyModbus mais sera très utile lorsque l'on codera en VAL3 le client Modbus pour vérifier si les paquets sont corrects. De plus Wireshark permet d'afficher les paquets TCP de Synchronisation (SYNC) et d’acquittement (ACK). capture pour FC4 de 45= 2*16+D: ind: 0 1 2 3 4 5 6 7 8 9 10 11 Tx: 00 05 00 00 00 06 01 04 00 00 00 01 Rx: 00 05 00 00 00 05 01 04 02 00 2D capture pour FC6 de 141= 8*16*D: Tx: 00 06 00 00 00 06 01 06 00 00 00 8D Rx: 00 06 00 00 00 06 01 06 00 00 00 8D Fermer l'application EasyModbusServer et lancer tcp_server.exe dans le dossier tcp_server_windows. Refaire Connect dans EasyModbusClient et vérifier l'échange des données entre EasyModbusClient et tcp_server. Vous allez maintenant pouvoir remplacer EasyModbusClient par votre propre application VAL3. =====Création de l'application VAL3 pour le développement de la communication===== Contrairement au projet de la SAE du BUT2, nous allons dans un premier temps ne pas configurer la CAO de la cellule et nous concentrer sur la communication et la commande simple de la station de tri FESTO. Le contrôleur du robot est configuré dans le projet fourni, il faut maintenant créer une nouvelle application, pour cela: - Choisir l'onglet Cellule dans la fenêtre de droite - Cliquer sur la flèche à gauche du nom de la cellule pour faire apparaitre "Controller1 [s9...]" - Cliquer droit sur "Controller1 [s9...]" puis cliquer gauche sur "Nouvelle application" - Saisir un nom: "Integration" suivi sans espace d'un numéro sur 2 chiffres (complété à gauche avec des 0 si nécessaire) qui vous sera attribué en début de séance et que vous conserverez durant toutes les séances. Par exemple, le groupe numéro 3 devra utiliser "Integration03" et le groupe 16 devra utiliser "Integration16" . Il est important que vous ayez chacun un nom de projet différent pour pouvoir identifier votre programme une fois chargé sur le contrôleur du robot! - Cliquer sur Ok ===Ajout d'un sous programme d'affichage bien pratique=== Dans la fenêtre cellule->Controller1->Integration...-> * clic droit et "Ajouter nouveau programme" * Nom: logMsgBlock Copier coller le code suivant: begin //attend que le robot arrive à la position souhaitée si demandé if x_bBool==true waitEndMove() endIf //assure l'affichage du message while logMsg(x_sString)==false delay(0) endWhile end DANS L'ORDRE: * Cliquer droit sur x_sString et faire ajouter nouveau paramètre * Cliquer droit sur x_bBool et faire ajouter nouveau paramètre ===Création des variables nécessaires=== Créer une Donnée de type sio appelée siSocketTCP de taille 1 pour gérer les échanges via socket TCP. Double cliquer sur la variable siSocketTCP[0] puis dans la fenêtre Données sur Socket\siSocketTCP pour faire apparaitre la fenêtre d'association IO/variable. Faire en sorte que Données VAL3 : siSocketTCP[0] soit associée à Lien physique Socket\siSocketTCP Créer une Donnée de type num appelée nTID de taille 1 pour le comptage des transaction modbus. Créer une Donnée de type tool appelée tTool de taille 1 et initialisée avec tout les champs à 0 sauf Gripper à régler à FastIO\fOut1 et OTime et CTime à régler à 0.5secondes. Créer des Données de type bool appelées b_e_present, b_e_metal, b_e_non_noir, b_e_plein, b_s_moteur, b_s_switch1, b_s_switch2, b_s_stoppeur_retracte et b_HAL_socket ===Programme pour initialiser la HAL=== Le programme d'initialisation est fourni. Dans l'onglet Cellule, clic droit sur Integration.. puis nouveau programme. Saisir HALinit, et copier coller ce code: begin if b_HAL_socket //MODBUS via connecteur J205 avec les sockets sioLink(siSocketTCP, siSocketTCP) clearBuffer(siSocketTCP) if(sioCtrl(siSocketTCP, "target",x_sIPServerModbus)!=0) call logMsgBlock("probleme: sioCtrl(siSocketTCP, target, "+x_sIPServerModbus+")",true) else call logMsgBlock("ok: sioCtrl(siSocketTCP, target, "+x_sIPServerModbus+")",true) endIf //"endOfString" num (Pour ligne série, client et serveur TCP) Code ASCII pour le caractère de fin de chaîne à utiliser avec les opérateurs '=' (dans la plage [0, 255]) if(sioCtrl(siSocketTCP, "endOfString", 13)!=0) call logMsgBlock("probleme sioCtrl(siSocketTCP, endOfString, 13)",true) endIf if(sioCtrl(siSocketTCP, "port", 502)!=0) call logMsgBlock("probleme sioCtrl(siSocketTCP, port, 502)",true) endIf //0 pour configurer les lectures sur socket bloquantes, //une autre valeur en seconde sinon if(sioCtrl(siSocketTCP, "timeout",1)!=0 ) call logMsgBlock("probleme sioCtrl(siSocketTCP, timeout,1)",true) endIf // initialisation du compteur de transactions nTID=0 else //accès via connecteur dédié J207 endIf end * Cliquer droit sur x_sIPServerModbus et faire Ajouter->nouveau paramètre et sélectionner type String. Dans le programme start.pgx, mettre la variable b_HAL_socket à true puis appeler le programme HALInit en lui passant en paramètre une chaine de caractères correspondant à l'adresse IP de l'hôte sur lequel est exécuté le serveur modbus TCP. ===Programme pour lire les entrées=== Créer un programme HALlireEntrees sans paramètres. Créer 3 variables locales: * l_nValEntrees . * l_nWord de 2 cases pour les conversion de 16 bits vers 2 octets et inversement. * l_nOctets de 100 cases pour stocker les octets de la requêtes et de la réponse Modbus TCP. Votre programme HALlireEntrees doit dans l'ordre: - Incrémenter la variable nTID sur 16 bits - Remplir les octets de l_nOctets[] codant nTID avec le résultat de la conversion de 16 bits vers 2 octets via l_nWord (indice: utiliser toBinary(....) ) - Remplir les octets fixes de l_nOctets[] - Envoyer le bon nombre d'octets du tableau l_nOctets[] vers siSocketTCP avec la fonction sioSet - Récupérer la réponse dans le tableau l_nOctets[] - Reconstruire la valeur de donnée reçue sur 16 bits dans l_nValEntrees à partir des deux octets du tableau l_nOctets[] - Mettre à jour les variables booléennes b_e_present, b_e_metal, b_e_non_noir, b_e_plein en fonction des bits de l_nValEntrees en utilisant la fonction bAnd pour masquer les bits et l'opérateur == pour tester l'égalité. Pour rappel les entrées sont actives à 0, et le booléen doit être mis à 1 si l'entrée est active. Vous pourrez, pour debugger, afficher la valeur de l_nValEntrees en faisant: call logMsgBlock("l_nValEntrees:"+toString(".3",l_nValEntrees),false) ===Test de la communication pour les entrées=== Tester votre programme en ajoutant dans start.pgx une boucle sans fin qui appelle chaque seconde HALlireEntrees et affiche dans la fenêtre de log la valeur des différentes variables en vous inspirant de: if b_e_present call logMsgBlock("b_e_present",false) endIf .... Jouer sur les boutons d'entrée de l'application tcp_serveur et vérifier l'affichage dans SRS. Au besoin, utiliser Wireshark pour debugguer la communication entre votre programme et tcp_server. ===Programme pour écrire les sorties=== Créer un programme HALecrireSorties sans paramètres. Créer 3 variables locales: * l_nValSorties . * l_nWord de 2 cases pour les conversion de 16 bits vers 2 octets et inversement. * l_nOctets de 100 cases pour stocker les octets de la requête et de la réponse Modbus TCP. Votre programme HALecrireSorties doit dans l'ordre: - Incrémenter la variable nTID sur 16 bits - Remplir les octets de l_nOctets[] codant nTID avec le résultat de la conversion de 16 bits vers 2 octets via l_nWord - Reconstruire la valeur d'octet l_nValSorties à partir des variables booléennes b_s_moteur, b_s_switch1, b_s_switch2, b_s_stoppeur_retracte. Pour rappel les sorties sont actives à 1, et chaque bit dans l_nValSorties doit donc être mis à 1 si la sortie correspondante est active. Vous pourrez utiliser la fonction bOr pour mettre à 1 sélectivement les bits de l_nValSorties en fonction des variables booléennes. - Reconstruire la valeur de donnée à envoyer sur 16 bits dans l_nWord à partir de l_nValSorties - Remplir les octets de l_nOctets[] codant la donnée à envoyer sur 16 bits. - Remplir les octets fixes de l_nOctets[] - Envoyer le bon nombre d'octets du tableau l_nOctets[] vers siSocketTCP avec la fonction sioSet - Récupérer la réponse dans le tableau l_nOctets[] et ne rien en faire ===Test de la communication pour les sorties=== modifier start.pgx pour faire en sorte que les entrées lues par HALlireEntrees soient aiguillées chacune vers une sortie différente en vous inspirant de: if b_e_present call logMsgBlock("b_e_present",false) endIf //bit 0 d'entrée envoyé sur le bit 2 de sortie b_s_switch2=b_e_present ... Jouer sur les boutons d'entrée de l'application tcp_serveur et vérifier l'affichage dans SRS ainsi que la commande des sorties dans tcp_server. Au besoin, utiliser Wireshark pour debugguer la communication entre votre programme et tcp_server. =====Programme simpliste pour le robot et la commande de la station FESTO===== Nous allons maintenant écrire une application simple qui va séquentiellement permettre au robot de saisir une pièce, la déposer sur le tapis qui l'amène jusqu'à glissière 2 puis la récupérer pour la déposer à nouveau sur la position de saisie. L'application ici ne fait pas usage du parallélisme des tâches de commande du robot et de la station FESTO, ce qui se traduit par le fait que le robot attend sans bouger pendant que la station de tri achemine la pièce. ====Définitions de poses articulaires et cartésiennes==== Définir et initialiser les variables suivantes dans l'onglet Données (pour pouvoir faire "aller à" dans la vue 3D) jBrasBaisseSaisie={0,0,50,0,75,0} jBrasBaisseTapis={-90,0,50,0,75,0} pSaisie={{436.94,154.76,7.70,0,180,0},{ssame,esame,wsame}} //position de flange dans world pour saisie dépose de pièces pStoppeur={{-145.43,-256.05,126.88,0,-180,0},{ssame,esame,wsame}} pDebutTapis={{-145.43,-192.73,126.88,0,-180,0},{ssame,esame,wsame}} pGlissiere[0]={{141.49,-324.43,24.81,0,-159.22,87.36},{ssame,esame,wsame}} pGlissiere[1]={{141.49,-400.95,24.81,0,-159.22,87.36},{ssame,esame,wsame}} pGlissiere[2]={{141.49,-479.76,24.81,0,-159.22,87.36},{ssame,esame,wsame}} //position de flange dans world pour dépose de pièces dans la boite (même zone que Tapis) pVide={{339.081697,-392.926577,85.875444,-0.440943,-179.996914,51.413801},{ssame,esame,wsame}} ====Configuration de l'outil==== Il faut maintenant configurer l'outil du robot, pour cela: - Choisir l'onglet Géométrie dans la fenêtre de droite - Cliquer sur la flèche à gauche du nom de la cellule pour faire apparaitre "Controller1 [s9...]" puis faire de même pour votre Projet - Cliquer droit sur "Flange" (qui signifie Bride en français, soit l'emplacement où fixer l'outil) puis cliquer gauche sur "Nouvelle donnée" - Saisir un nom pour l'outil, ou laisser le nom par défaut (tTool) puis cliquer sur Ok - Vérifier que tTool apparait maintenant en cliquant sur la flèche à coté de "flange[0]" ====Configuration de la cellule==== ===Import du modèle 3D de la cellule=== Récupérer le modèle: https://bvdp.inetdoc.net/files/iut/staubli/stl/cellule_simplifiee.wrl - Importer le modèle dans le projet - Onglet Modeleur->Ajouter un modèle CAO - Chercher le fichier cellule_simplifiee.wrl à l'aide du bouton ... - Régler la résolution sur Standard et cocher l'option "Copier et insérer le fichier" et "importer comme un assemblage" - Dans la vue 3D, dans Scène->Géométrie->cellule_simplifiee_1.wrl, clic droit puis "éditer la position" Éditer la position absolue suivante: 63.3 -68.2 550.45 0 0 -90 ===Import du modèle de pince=== Récupérer le modèle STL de la pince Schunk et du préhenseur de bouchon: https://bvdp.inetdoc.net/files/iut/staubli/stl/adaptateur_pince_festo_iut2023_open.stl Le modèle téléchargé est déjà référencé correctement pour faciliter le positionnement du Handler (point saisisseur) et du Handle (base: point de saisie). La bride du robot (Flange) est un Handler en Val3, et nous allons connecter ce Handler au Handle de l'outil pince. Il est important de respecter scrupuleusement les étapes suivantes sinon l'outil ne sera pas correctement ajouté au robot! L'image suivante montre le repère du handler du robot c'est à dire sa bride (Flange en anglais):{{https://bvdp.inetdoc.net/files/iut/staubliiut/images/SRS_handler_robot.PNG}} Pour ajouter la pince au robot: - Si un outils est déjà attaché au handler du robot: Scene->Robot->Controleur->Base->Controleur click droit et Détacher - masquer le robot-> cliquer droit sur l'arborescence de scène sur Controller et décocher "Afficher le robot" - Onglet Modeleur->Ajouter un modèle CAO - choisir Copier et insérer le fichier - l'objet apparaît dans l'arbre en tant que Géométrie, cliquer droit dessus et faire "nouvel outils" - NE PAS déplacer l'outils (car il est normalement bien positionné) - choisir dans l'arbre l'outils et son handle - cliquer sur "Edition" sous la barre de menu - cliquer droit sur handle et "Editer la position" - Régler tout à 0 dans la position absolue - cliquer droit sur handler et "Editer la position" - Régler tout à 0 dans la position absolue, même Z - Sortir du mode Edition - Cliquer droit sur Tool1 dans l'arborescence, attacher à et choisir le handler du robot - réactiver l'affichage du robot Ensuite il faut associer l'outils à la variable tTool, pour cela: - Sélectionner le Tool1 dans l'arborescence puis faire CTRL+C - pour utiliser un outils de la géométrie graphique vers une variable val3, il faut clic gauche sur le handler de l'outils, CTRL+C et coller dans la ligne de la variable tTool[0] dans l'onglet données. Vous devriez obtenir un vecteur dont toutes les composantes sont à 0. Ensuite, cliquer droit sur le handler de l'outils puis définir comme TCP (Tool Center Point= Centre De l'Outils) pour pouvoir déplacer l'outils. ===Ajout des éléments dans la cellule=== Pour ajouter un objet dans l'espace de travail du robot: - Onglet Modeleur->Ajouter un modèle CAO - Télécharger le fichier et aller le chercher dans l'arborescence avec le bouton "..." - Choisir Copier et insérer le fichier - L'objet apparait dans l'arbre en tant que Géométrie Insérer dans l'espace de travail du robot: - la station FESTO: https://bvdp.inetdoc.net/files/iut/staubli/stl/station_tri_simple.stl - le cylindre: https://bvdp.inetdoc.net/files/iut/staubli/stl/cylindre_festo_LR.stl Vous devez positionner les éléments pour obtenir une configuration proche de celle du robot réel (vous adapterez les positions plus tard en relevant avec le pendant la configuration cartésienne du robot lorsqu'il est en position de saisie et de dépose du bouchon). Vous devez obtenir un espace de travail tel que celui visible sur la figure suivante: {{https://bvdp.inetdoc.net/files/iut/staubliiut/images/cellule_avec_festo.png}} Ensuite vous devrez positionner finement le modèle CAO de la station FESTO en exploitant les différents points visibles sur la figure suivante, en sélectionnant chacun des points dans l'onglet Données et en faisant "Aller à" afin que la pince se trouve en face du point correspondant: {{https://bvdp.inetdoc.net/files/iut/staubliiut/images/points_festo.png}} ===Configuration de l'outils=== Dans le données, sélectionner la variable tTool de type tool, et double cliquer pour l'éditer. Vérifiez que vous avez bien comme changement de repère {0,0,0,0,0,0}, et que le gripper est bien réglé à FastIO\fOut1 . Saisir 1 pour les 2 champs suivants qui permettent de régler les durées de délais en seconde(s) pour que la pince s'ouvre et se ferme après que la commande lui soit envoyée. ====Programme à réaliser==== Dans le programme start, ajouter après les initialisations (en respectant les consignes données en cours concernant les mouvements à faire en articulaire et en cartésien): dans une boucle sans fin b_s_moteur=true b_s_stoppeur_retracte=true le robot va chercher la pièce en pSaisie et la dépose en pDebutTapis dans une boucle tant que b_e_plein est faux b_s_switch1=b_e_non_noir b_s_switch2=b_e_metal dans une boucle tant que b_e_plein est vrai attendre le robot va chercher la pièce dans la glissière 2 (dans pGlissiere[2]) et la dépose en pSaisie Tester le programme en simulation dans SRS, d'abord à l'aide de tcp_server puis à l'aide de tcp_server_simulator. =====Programme avec gestion du parallélisme===== ====Tâche de manipulation du robot==== Créer 2 programmes en utilisant le code déjà fait aux exercices précédents: - un programme appelé **amenePieceSurTapis()** qui va saisir la pièce en **pSaisie** pour la déposer en **pDebutTapis** et affiche ""amenePieceSurTapis()"" sur le pendant au début du programme. - un programme **videGlissiere(...)** avec un paramètre de type num **x_nGlissiereAVider** qui va saisir la pièce dans la glissière numéro **x_nGlissiereAVider** et la dépose en **pVide** que vous créerez dans la zone de la station de tri pour mettre les pièce dans une boite. Le programme doit afficher ""videGlissiere(n)"" sur le pendant au début du programme avec la bonne valeur pour **n**. Modifier votre programme précédent pour qu'il utilise les deux nouveaux programmes ainsi que du code supplémentaire pour gérer les changements de zone. La seule différence de fonctionnement est que le robot dépose maintenant la pièce en **pVide** dans la zone de la station de tri plutôt qu'en **pSaisie** de la zone de saisie. ====Implémentation de la commande de la station de tri==== Créer un nouveau programme appelé **mae** et coder la machine à états vue en TD (en gérant le comptage des pièces dans les trois glissières à l'aide d'une variable globale de type **num** à 3 cases **nCptGlissiere[3]**). L'incrémentation ou la lecture d'une case du tableau de compteur doit se faire en "protégeant" la donnée partagée. Pour cela: - Déclarer une variable globale de type bool appelée **b_verrouCptGlissiere** initialisée à **false** - Précéder l’accès (en écriture pendant l'incrémentation ou en lecture pendant l'utilisation de la variable) par setMutex(b_verrouCptGlissiere) - Faire suivre l’accès (en écriture pendant l'incrémentation ou en lecture pendant l'utilisation de la variable) par b_verrouCptGlissiere=false Dans le programme **start**, faire uniquement l’initialisation du bras (mouvement de connexion vers jBrasBaisseSaisie), de la pince (ouvrir), et de la HAL puis appeler avec l'instruction **call** le programme **mae** pour le tester en simulation, d'abord avec l'application tcp_server puis avec tcp_server_simulator. Conserver tout le code que vous avez fait à l'exercice précédent après le **call**, il ne sera pas utilisé dans cet exercice mais dans les suivants. ====Préparation de la tâche de commande de station de tri pour le parallélisme==== Remplacer l'appel du programme **mae** par la programmation d'une tâche synchrone en faisant: //programmation de la tache périodique //mae est un programme créé, et exécuté à une périodicité de 0.012s taskCreateSync "mae",.012,bOverRun,mae() call logMsgBlock("Tache periodique mae lancee",true) //blocage du programme appelant while(true) delay(0.008) endWhile Tester et comprendre ce que fait le programme **start**. ====Commande en parallèle du bras et de la station de tri==== Mélanger les programmes déjà réalisés pour que le robot: - vide complètement une glissière dès qu'elle comporte trois pièces ou plus vers le point pVide dans la zone du Tapis. - dépose des pièces sur la station de tri tant qu'aucune glissière ne comporte plus de trois pièces Ajouter une tache périodique de période 1seconde pour afficher le nombre de pièces dans chacune des glissières sur le pendant: begin while true setMutex(b_verrouCptGlissiere) l_n_cpt_glissiere_affichage[2]=nCptGlissiere[2] l_n_cpt_glissiere_affichage[1]=nCptGlissiere[1] l_n_cpt_glissiere_affichage[0]=nCptGlissiere[0] b_verrouCptGlissiere=false call logMsgBlock("cptG: "+toString("1",l_n_cpt_glissiere_affichage[0])+ " "+toString("1",l_n_cpt_glissiere_affichage[1])+ " "+toString("1",l_n_cpt_glissiere_affichage[2]),false) delay(1) endWhile end Tester votre programme avec SRS en simulation avec tcp_server_simulator puis sur le robot réel en simulant la station de tri avec tcp_server_simulator puis finalement avec la vrai station de tri en utilisant l'adresse IP fournie pour accéder au serveur modbus de la maquette: 172.16.6.60 =====Repos bien mérité===== BRAVO, vous êtes arrivé au bout! ====Machine à états==== {{https://bvdp.inetdoc.net/files/iut/staubliiut/images/iutfesto1_sans_actions.gif}} {{https://bvdp.inetdoc.net/files/iut/staubliiut/images/iutfesto1_avec_actions.gif}}