WIKI de Bertrand VANDEPORTAELE

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.

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.

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.

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

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

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

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

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

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 ). 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 . 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).

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.

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:

1. Choisir l'onglet Cellule dans la fenêtre de droite
2. Cliquer sur la flèche à gauche du nom de la cellule pour faire apparaitre “Controller1 [s9…]”
3. Cliquer droit sur “Controller1 [s9…]” puis cliquer gauche sur “Nouvelle application”
4. 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!
5. Cliquer sur Ok

Dans la fenêtre cellule→Controller1→Integration…→

• clic droit et “Ajouter nouveau programme”
• Nom: logMsgBlock

Copier coller le code suivant:

logMsgBlock.pgx

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é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

Le programme d'initialisation est fourni. Dans l'onglet Cellule, clic droit sur Integration.. puis nouveau programme. Saisir HALinit, et copier coller ce code:

HALinit.pgx

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.

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:

1. Incrémenter la variable nTID sur 16 bits
2. 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(….) )
3. Remplir les octets fixes de l_nOctets[]
4. Envoyer le bon nombre d'octets du tableau l_nOctets[] vers siSocketTCP avec la fonction sioSet
5. Récupérer la réponse dans le tableau l_nOctets[]
6. Reconstruire la valeur de donnée reçue sur 16 bits dans l_nValEntrees à partir des deux octets du tableau l_nOctets[]
7. 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)

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.

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:

1. Incrémenter la variable nTID sur 16 bits
2. Remplir les octets de l_nOctets[] codant nTID avec le résultat de la conversion de 16 bits vers 2 octets via l_nWord
3. 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.
4. Reconstruire la valeur de donnée à envoyer sur 16 bits dans l_nWord à partir de l_nValSorties
5. Remplir les octets de l_nOctets[] codant la donnée à envoyer sur 16 bits.
6. Remplir les octets fixes de l_nOctets[]
7. Envoyer le bon nombre d'octets du tableau l_nOctets[] vers siSocketTCP avec la fonction sioSet
8. Récupérer la réponse dans le tableau l_nOctets[] et ne rien en faire

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.

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é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}}

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]"

Récupérer le modèle: https://bvdp.inetdoc.net/files/iut/staubli/stl/cellule_simplifiee.wrl

1. Importer le modèle dans le projet
2. Onglet Modeleur→Ajouter un modèle CAO
3. Chercher le fichier cellule_simplifiee.wrl à l'aide du bouton …
4. Régler la résolution sur Standard et cocher l'option “Copier et insérer le fichier” et “importer comme un assemblage”
5. 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

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):

Pour ajouter la pince au robot:

1. Si un outils est déjà attaché au handler du robot: Scene→Robot→Controleur→Base→Controleur click droit et Détacher
2. masquer le robot→ cliquer droit sur l'arborescence de scène sur Controller et décocher “Afficher le robot”
3. Onglet Modeleur→Ajouter un modèle CAO
4. choisir Copier et insérer le fichier
5. l'objet apparaît dans l'arbre en tant que Géométrie, cliquer droit dessus et faire “nouvel outils”
6. NE PAS déplacer l'outils (car il est normalement bien positionné)
7. choisir dans l'arbre l'outils et son handle
8. cliquer sur “Edition” sous la barre de menu
9. cliquer droit sur handle et “Editer la position”
10. Régler tout à 0 dans la position absolue
11. cliquer droit sur handler et “Editer la position”
12. Régler tout à 0 dans la position absolue, même Z
13. Sortir du mode Edition
14. Cliquer droit sur Tool1 dans l'arborescence, attacher à et choisir le handler du robot
15. réactiver l'affichage du robot

Ensuite il faut associer l'outils à la variable tTool, pour cela:

1. Sélectionner le Tool1 dans l'arborescence puis faire CTRL+C
2. 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.

Pour ajouter un objet dans l'espace de travail du robot:

1. Onglet Modeleur→Ajouter un modèle CAO
2. Télécharger le fichier et aller le chercher dans l'arborescence avec le bouton “…”
3. Choisir Copier et insérer le fichier
4. L'objet apparait dans l'arbre en tant que Géométrie

Insérer dans l'espace de travail du robot:

1. la station FESTO: https://bvdp.inetdoc.net/files/iut/staubli/stl/station_tri_simple.stl
2. 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:

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:

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.

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.

Créer 2 programmes en utilisant le code déjà fait aux exercices précédents:

1. 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.
2. 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.

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:

1. Déclarer une variable globale de type bool appelée b_verrouCptGlissiere initialisée à false
2. 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)
3. 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.

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.

Mélanger les programmes déjà réalisés pour que le robot:

1. 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.
2. 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:

affichePiece.pgx

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

BRAVO, vous êtes arrivé au bout!