Contrôle d un palettiseur

Contrôle d un palettiseur Marie-Sophie REDON Grégory SURACI

Table des matières Présentation du système 1 Cahier des charges 1 Actionneurs 1 Capteurs 1 Modules 2 Gestion de la palette 2 Convoyeur pour cartons 2 Barrière 2 Plateau 3 Poussoirs à tige 3 Monte-charge 3 Vue d ensemble du système 4 Mise en œuvre 5 Installation 5 Synthèse du contrôleur 5 Correction du modèle 5 Conclusion 6 Annexes 7 Modèle RdP 7 Code source du contrôleur 8

Présentation du système Cahier des charges Le but de ce projet est de réaliser la commande d un palettiseur automatisé industriel réalisant des assemblages de 3x2 cartons. Nous avons réalisé une décomposition par modules. Autrement dit, pour chaque composant du système, nous avons étudié son comportement, sachant que chaque «bloc» doit «communiquer» tout en évitant le parallélisme d action (mais pas de fonctionnement). Notre système est un assemblage de six modules indépendants, connectés par de nombreux signaux de synchronisation. Le nombre de sous-système aurait pu être moindre, mais il nous a paru important de conserver une certaine modularité, afin de rendre les modifications du système plus aisées. Nous voulions, de plus, un système borné, vivant et réversible. Actionneurs A0 : Ascenseur (cartons). A1 : Avance de l éjecteur. A2 : Libérer cartons (fin du convoyeur). A3 : Avancer plateau. A4 : Sortir les pousseurs. A5 : Monter le monte-charge (palette). A6 : Descendre le monte-charge (palette). A7 : Convoyeur des palettes. Capteurs S0 : Capteur de sortie de l'ascenseur des cartons. S1 : Fin de course d'avance de l éjecteur. S2 : Capteur du stock tampon du convoyeur. S3 : Plateau sorti. S4 : Plateau rentré. S5 : Tiges des poussoirs sorties. S6 : Monte-charge en position basse. S7 : Monte-charge en position pour le premier niveau de cartons. S8 : Monte-charge en position pour le deuxième niveau de cartons. S9 : Monte-charge en position pour le troisième niveau de cartons. S10 : Présence palette sur le monte-charge. Marie-Sophie REDON / Grégory SURACI 1/11

Modules Gestion de la palette Il est question ici de gérer uniquement l avancée de la palette. C est-à-dire qu elle sera acheminée jusqu à l'élévateur au démarrage puis évacuée en fin de cycle. Nous avons utilisé une structure à anneau mémoire pour permettre un fonctionnement correct à chaque cycle, et non uniquement le premier (état initial : aucune palette sur l'élévateur). Convoyeur pour cartons Ce bloc est centré sur l approvisionnement en cartons. Grâce à l utilisation d un compteur par deux, ce module permet ainsi de fournir une vague de deux cartons sur le convoyeur si le système le demande. Il ne se préoccupe pas de savoir le nombre de cartons déjà empilés sur la palette. Cette problématique est gérée par un autre sous-système. Barrière Ce bloc, très simpliste, contrôle uniquement l ouverture et la fermeture de la barrière. De plus, la fermeture de celle-ci demande deux nouveaux cartons pour exploiter au mieux le parallélisme de fonctionnement. Marie-Sophie REDON / Grégory SURACI 2/11

Plateau Ce module dispose de nombreuses contraintes : - Ouverture simultanée de la barrière et du plateau si deux cartons sont en bout de convoyeur - Commande de la fermeture de la barrière et des poussoirs à tige - Maintien du plateau tant que les cartons ne sont pas maintenus par les poussoirs à tige Poussoirs à tige Ces poussoirs permettent de tenir les cartons au-dessus du monte-charge. Ils sont commandés essentiellement par le plateau qui fournit les signaux de synchronisation et informent le monte-charge lorsque les cartons sont posés sur la palette. Monte-charge Après qu une palette soit acheminée sur le monte-charge, l élévateur va se mettre en condition pour récupérer son premier «étage» de deux cartons. Il pourra continuer à descendre après chaque ajout jusqu à que les trois «étages» demandés soient en place. L utilisation de l anneau mémoire à trois positions permet de connaître l avancement du cycle global. Une fois les six cartons empilés, le monte-charge indique au module «palette» la fin du cycle pour en démarrer un nouveau. Marie-Sophie REDON / Grégory SURACI 3/11

Vue d ensemble du système Marie-Sophie REDON / Grégory SURACI 4/11

Mise en œuvre Installation On va dans cette seconde phase, implémenter notre réseau de pétri sur une machine monoprocesseur (d où la nécessité d éviter le parallélisme d action). On dispose pour cela d un module E/S reliant le contrôleur et le simulateur. Contrôleur Capteurs Simulateur I O USB I/O S E Actionneurs Synthèse du contrôleur Chaque module peut être synthétisé par une machine à états finis, où les places correspondes à des états. Nous avons pour cela utilisé un langage séquentiel : le C. Cela implique la mise en place d un cycle de gestion des entrées et des sorties. Initialisation du système Lecture des entrées Évolution du modèle (MEF) Gestion des sorties Toutes nos variables ont été représentées par des caractères non signés, ce qui permet de minimiser l espace mémoire utilisé, et ce quel que soit le compilateur (ici Cygwin). Les entrées (capteurs) et sorties (actionneurs) étant fournies par des bus de 8 bits, elles ont été lues ou écrites grâce a l utilisation de masques binaires. Correction du modèle Lors de cette phase nous avons pu relever des erreurs de modélisation qui n avaient pas pu être détectées (gestion de temporisation). Pour y remédier nous avons adapté notre modèle au niveau du monte-charge, de l ouverture de la barrière et du fournisseur de cartons. En effet, la nuance est qu il faut qu il y ait deux cartons en bout de tapis et non sur le tapis (Il faut donc comptabiliser un carton que lorsqu il est en bout de convoyeur, et non lorsqu il est jeté sur celui-ci). Marie-Sophie REDON / Grégory SURACI 5/11

Conclusion Ce projet nous a permis de cerner toutes les subtilités de la modélisation d un système. En effet, toutes les étapes du contrôle ont été abordées, de la rédaction d un cahier des charge à l implémentation en passant par la modélisation d un RdP. Les plus grosses difficultés ont été rencontrées lors de la synthèse. La gestion des variables de synchronisation doit être parfaite sous peine de mettre le système en erreur et il faut correctement lire/écrire sur les ports d entrée/sortie du module fourni. De plus, tout le codage est basé sur l hypothèse d un modèle correct, mais dans la pratique, il est nécessaire de réajuster certaines conditions pour rendre le modèle fonctionnel. Malgré tout, notre choix de pousser la décomposition au maximum nous a permis de régler ces détails grâce à la simulation, et d obtenir un contrôleur totalement fonctionnel sur n cycles. Avec quelques heures de plus, il aurait été possible d implémenter une gestion des blocages avec notamment un arrêt d urgence, ainsi qu un mécanisme de surveillance, pour s assurer du parfait fonctionnement du palettiseur. Marie-Sophie REDON / Grégory SURACI 6/11

Annexes Modèle RdP Marie-Sophie REDON / Grégory SURACI 7/11

Code source du contrôleur #include "libusbio.h" //Mapping des capteurs #define S0 1 #define S1 2 #define S2 4 #define S3 8 #define S4 16 #define S5 32 #define S6 64 #define S7 128 #define S8 1 #define S9 2 #define S10 4 //Mapping des actionneurs #define A0 128 #define A1 64 #define A2 32 #define A3 16 #define A4 8 #define A5 4 #define A6 2 #define A7 1 //Port COM #define PORT_COM 5 /*Déclaration des MEFs*/ enum etats_me_palette {P00,P01 me_palette ; //0 enum etats_me_cartons {P10,P11,P12,P13 me_cartons; //1 enum etats_me_elevateur {P20,P21,P22,P23 me_elevateur; //2 enum etats_me_pince {P30,P31,P32 me_pince;//3 enum etats_me_barriere {P40,P41 me_barriere; //4 enum etats_me_plateau {P50,P51,P52,P53,P54 me_plateau;//5 /*Mémoires*/ enum etats_me_anneau {P230,P231,P232 me_anneau; unsigned char anneaux2; unsigned char compteurx2; /*Déclaration des variables de synchronisation*/ unsigned char palette_prete; unsigned char cycle_fini; unsigned char besoin_cartons; unsigned char cartons_prets; unsigned char cartons_jetes; unsigned char pret_pour_pince; unsigned char plateau_rentre; unsigned char ouvrir_barriere; unsigned char fermer_barriere; unsigned char pince_ok; unsigned char nouveaux_cartons; /*Actions et capteurs*/ unsigned char s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10; unsigned char a0,a1,a2,a3,a4,a5,a6,a7; unsigned char capteursb,capteursc; unsigned char fin; unsigned char actions; //Configurations unsigned char Config_in = 0xff; unsigned char Config_out = 0x00; main () { // Ouverture du port de communication n 4 (si COM 4), associé à lusb IO. OpenUSBIO(PORT_COM); // Configuration des ports if(!( ConfigureUSBIO (PORTA,&Config_out) && ConfigureUSBIO (PORTB,&Config_in) && ConfigureUSBIO (PORTC,&Config_in))){ return; //Etats initiaux des MEFS me_palette = P00; me_cartons = P10; me_elevateur = P20; me_pince = P30; me_barriere = P40; me_plateau = P50; //Etat initial des compteurs / anneaux compteurx2 me_anneau = 0; = P230; anneaux2 = 0; //Fin de cycle fin = 0; //initialisation des places, des sorties, des événements, etc. do { if(!(readusbio(portb,&capteursb) && ReadUSBIO(PORTC,&capteursC))){ // lecture du PORT USB IO d'entrée //Pas bon.. return; Marie-Sophie REDON / Grégory SURACI 8/11

//Capteurs s0 = (capteursb & S0) == S0; s1 = (capteursb & S1) == S1; s2 = (capteursb & S2) == S2; s3 = (capteursb & S3) == S3; s4 = (capteursb & S4) == S4; s5 = (capteursb & S5) == S5; s6 = (capteursb & S6) == S6; s7 = (capteursb & S7) == S7; s8 = (capteursc & S8) == S8; s9 = (capteursc & S9) == S9; s10 = (capteursc & S10) == S10; /* Bloc 0 : Palette */ switch(me_palette){ case P00: if(anneaux2 == 0){ if(s10){ palette_prete = 1; anneaux2 = 1; me_palette = P01; else{ if(!s10){ anneaux2 = 0; me_palette = P00; case P01: if(cycle_fini){ cycle_fini = 0; anneaux2 = 1; me_palette = P00; default: /* Bloc 1 : Cartons */ switch(me_cartons){ case P10: if(s0){ me_cartons = P11; case P11: if(s1){ me_cartons = P12; case P12: if(s2){ compteurx2++; if(compteurx2 == 2){ cartons_prets = 1; compteurx2 = 0; me_cartons = P13; else{ me_cartons = P10; case P13: if(nouveaux_cartons){ //besoin_cartons = 0; nouveaux_cartons = 0; me_cartons = P10; default: /* Bloc 4 : Barriere */ switch(me_barriere){ case P40: if(ouvrir_barriere){ nouveaux_cartons= 1; ouvrir_barriere = 0; me_barriere = P41; case P41: if(fermer_barriere){ fermer_barriere = 0; me_barriere = P40; default: Marie-Sophie REDON / Grégory SURACI 9/11

/* Bloc 5 : Plateau */ switch(me_plateau){ case P50: if(besoin_cartons && cartons_prets){ cartons_prets = 0; besoin_cartons = 0; me_plateau = P51; case P51: if(!s3){ouvrir_barriere = 1; me_plateau = P52; case P52: if(s4){ fermer_barriere = 1; pret_pour_pince = 1; me_plateau = P53; case P53: if(pince_ok){ pince_ok = 0; me_plateau = P54; case P54: if(s3){ plateau_rentre = 1; me_plateau = P50; default: /* Bloc 2 : Elevateur */ switch(me_elevateur){ case P20: if(palette_prete){ palette_prete = 0; me_elevateur = P21; case P21: if(s7){ besoin_cartons = 1; me_elevateur = P22; case P22: if(cartons_jetes){ cartons_jetes = 0; me_elevateur = P23; case P23: if(me_anneau == P230){ if(s8){ besoin_cartons = 1; me_anneau = P231; me_elevateur = P22; else if(me_anneau == P231){ if(s9){ besoin_cartons = 1; me_anneau = P232; me_elevateur = P22; else{ if(s6){ cycle_fini = 1; me_anneau = P230; me_elevateur = P20; default: Marie-Sophie REDON / Grégory SURACI 10/11

/* Bloc 3 : Pince */ switch(me_pince){ case P30: if(pret_pour_pince){ pret_pour_pince = 0; me_pince = P31; case P31: if(s5){ pince_ok = 1; me_pince = P32; case P32: if(plateau_rentre){ cartons_jetes = 1; plateau_rentre = 0; me_pince = P30; default: /* Bloc Génération des sorties vers la carte d'e/s */ a0 = (me_cartons a1 = (me_cartons == P10); == P11); a2 = (me_barriere == P41); a3 = (me_plateau == P51) (me_plateau == P52) (me_plateau a4 = (me_pince == P31) (me_pince == P32); == P53); a5 = (me_elevateur a6 = (me_elevateur == P21); == P23) (me_elevateur == P20); a7 = (me_palette == P00); actions = a0*a0 + a1*a1 + a2*a2 + a3*a3 + a4*a4 + a5*a5 + a6*a6 + a7*a7; if(!(writeusbio(porta,&actions))){ //pas bon.. return; while (!fin); CloseUSBIO(); // Fermeture du port Marie-Sophie REDON / Grégory SURACI 11/11