Un automate programmable industriel à PIC16F84

Un automate programmable industriel à PIC16F84



(Le programmateur , l'automate 1: 32e,8s et une piéce de 5F)


Table des matières

  1. Introduction
  2. Synoptique
  3. Etude de la partie électronique
  4. Réalisation
  5. Graphcet
  6. Particularité du graphcet utilisé
  7. Programmes
  8. Epilogue


A. Présentation

Un automate programmable industriel ou API est un appareil électronique capable de piloter un systeme . Les automates sont les maitres de l' automatique , en effet on les trouve partout dans l'industrie .
La plupart du temps on les programme en graphcet qui est une representation graphique de la commande . Cet outil est très puissant et simple d'utilisation .
Je propose de realiser un tel API le plus simplement possible (sans pour autant nuire aux performances) , ainsi tout le monde pourra le réaliser . Vous pourrez l'utiliser en modelisme , domotique , automatisme (porte de garage , portail ...) et dans les systèmes embarqués (voitures ...) .
Vous verrez , vous ne pourrez plus vous en passer !


B. Synoptique

Le principe est le suivant , on construit le graphcet de commande sur le PC , puis on le transfére dans l'automate qui l'execute . Donc cette réalisation comprend 3 grandes parties qui sont :

  1. la partie électronique
  2. La partie informatique au niveau du PC
  3. La partie informatique au niveau du uC de l'automate

 

 

B.1 La partie électronique


Du point de vue électronique l'automate se decompose en 5 sous-ensembles :

  • Le microcontroleur coeur du montage qui grace à un programme éxécute le graphcet qui est dans sa mémoire .
  • Le programmateur permettant de "rentrer" le graphcet dans l'automate et de programmer le uC .
  • L'alimentation
  • Le systeme d'interfacage d'entrée (ici 32 ou 24 entrées)
  • Le systeme d'interfacage de sortie (ici 8 ou 16 sorties)

 

 

B.2 La partie informatique au niveau du PC


Du point de vue informatique du cote du PC , un programme se charge de tout :
L'éditeur/traducteur de graphcet graphique et programmateur permet de :

  • créer un graphcet graphique et de le transformmer en graphcet littéral qui est une représentation textuelle du graph .
  • charger un graphcet littéral si vous boudez le graphique .
  • programmer le uC avec le le grapcet littéral plus l'interpréteur .

 

 

B.3 La partie informatique au niveau du uC


Du point de vue informatique du cote du uC , c'est un programme appellé interpréteur de graphcet qui gère l'automate en éxécutant le graphcet littéral et en mettant à jour les entrées , sorties , variables internes et temporisations .


    C. Etude de la partie électronique

    Mon but est de rendre la partie électronique simple à réaliser , elle n'en est pas moins interessante pour autant . je propose de réaliser soit un automate avec 32 entrées et 8 sorties , soit 24 entrées et 16 sorties . La premiere solution étant plus petite et donc plus simple à réaliser .

    Cette partie se decompose en :

    1. Choix du uC
    2. Etude de l'interfacage des entrées
    3. Etude de l'interfacage des sorties
    4. Etude de l'alimentation
    5. Etude du programmateur

     

     

    Schema électrique de la partie automate

    Version 32 entrées et 8 sorties

    version 24 entrées et 16 sorties

     

    IC1      : PIC16F84                        (microcontroleur)
    IC2,IC6  : 74LS574 ou 74HC574 ou 74HCT574  (latch)
    IC3,IC7  : ULN2803                         (amplification de puissance (darlington))
    IC4      : Regulateur 5 volts 7805 
    R1       : 33 k
    R2       : 10 M (facultatif)
    R3       : 470
    R4       : 47 k
    C1       : 30 p
    C2       : 30 p
    C4       : 10 u
    C5       : 220 u
    C6       : 100 n
    C7       : 100 n
    C8       : 100 n
    D        : Diode de redressement 1N4001
    Led      : Diode électoluminescente verte , 5mm (ou ce que vous voulez)
    Qz       : Quatz 4 MHz
    Q1       : bornier a vis 2 éléments (connecteur d'alimentation externe)
    Q2,3,4,5 : barette autosecable 2 éléments (prises d'alimentation pour montages externes)
    Q7       : barette autosecable 2 éléments (interrupteur de validation des sorties)
    Q8       : barette autosecable 5 éléments (connecteur de programmation)
    Q9,10,11,12 : barette autosecable 8 éléments (connecteurs pour les entrées (chiffre) )
    Q13,14,15,16,17,18,19,20 : barette autosecable 4 éléments (connecteurs pour les entrées (lettre) )
    Q21,Q23  : barette autosecable 10 éléments (sorties logiques)
    Q22,Q24  : barette autosecable 12 éléments (sorties de puissance)

     

     

    C.1 Choix du uC

    Le choix du uC est primordial car de lui dépend en grande partie : les performances , la taille ,la facilitée d'utilisation et le prix du montage .
    Le uC doit interpréter le graphcet littéral ,donc il faut une mémoire pour y mettre ce dernier .Pour que l'interprétation soit rapide , il faut une mémoire a accés parallèle .On a ici deux possibilités ,soit utiliser un uC avec bus externe sur lequel on y met une mémoire ,soit utliliser un uC qui possède sa propre mémoire .C'est cette derniere solution que j'ais choisis afin de rendre le montage simple .Bon il faut maintenant choisir le type de mémoire en sachant qu'elle ne doit pas s'éffacer lorsque l'on coupe le courant .On peut donc utiliser une RAM sauvegardée , une EPROM , une EEPROM ou FLASH .J'ais choisis la solution EEPROM/FLASH car c'est la plus fiable et la plus flexible , en effet il n'y a ni besoin de pile pour la sauvegarder ,ni d'éffaceur à ultraviolet pour l'éffacer .A ce stade deux micros font l'affaire : le PIC16C84 ou 16F84 et le 68HC811E2 .J'expose ici la réalisation avec le PIC 16F84 car avec son boitier DIL il est plus simple à mettre en oeuvre .

    Caracteristiques de ce uC :

    mémoire programme : 1Ko (flash)
    RAM               : 68o 
    EEPROM données    : 64o
    entrées/sorties   : 13 broches
    boitier           : DIL 18
    temps de cycle    : 1uS
    architecture      : RISC
    instructions très puissantes donc programme reduit
    programmation simple grace au mode serie
    flash programmable 1000 fois et eeprom 1000000 fois

    Vous devez utiliser le 16F84 et non le 16C84 car il dispose de plus de RAM , ce qui est nécéssaire pour gérer toutes les temporisations . (D'ailleur Microchip ne fabrique plus le 16C84)
    L'interpréteur et le graphcet logent dans la mémoire programme , les valeurs des temporisations sont dans l'EEPROM de donnée , tandis la RAM acceuille les variables temporaires et la zone des bits qui indique l'activitée du graphcet , des sorties ...
    Le programmateur programme le PIC dans son ensemble , interpréteur + graphcet , donc un PIC meme vierge peut y etre mis sans programmation préalable , ceci simplifie grandement la réalisation .

     

     

    C.2 étude de l'interfacage d'entrée

    Comme nous venons de le voir , le PIC présente 13 broches d'entrées/sorties . Ceci ne suffit généralement pas pour un automatisme , or je propose de réaliser soit un automates 32 entrées et 8 sorties soit 24 entrées et 16 sorties , ce qui fait 40 liaisons (ou est le truc ?) . En fait j'utilise le port B comme bus de 8 bits et je multiplexe les entrées comme dans le cas d'un clavier .
    la figure ci dessous montre le fonctionnement d'un clavier matricé :
    On alimente tour à tour les lignes A,B,C et D et on vient lire les colonne 1 à 8 . Ainsi dans l'exemple , seule l'alimentation de la ligne 3 , alimente la colonne 5 . Le systeme peut donc en déduire la touche préssée . (ici B6)
    Les lettres sont des sorties et les chiffres des entrées . comme tout le monde le sait , il ne faut pas laisser en l'air des entrées CMOS car on lit n'importe quoi . Il faut donc mettre des résistances de rappel sur les entrées . Comme on peut le remarquer sur le schéma , les entrées ou chiffres sont le portB et les sorties ou lettres sont le portA . Il faut donc mettre de résistances de rappel sur le port B , or le PIC permet d'activer des résistances de rappel au 5V (pull up) par la mise à 1 du bit /RBPU . Le fonctionnement est donc l'inverse de l'exemple précédent On lit donc 5V au repos et 0V lorsqu'une touche est appuyée à condition d'appliquer la masse tour à tour et laisser en l'air les sorties non utilisées . La figure ci dessous montre la meme utilisation :
    Cette approche marche très bien avec les claviers car il n'y à q'une seule touche enfoncée à la fois , car plusieurs touches donnent des erreurs :
    En effet , le micro croit que B2,B6,D2,D6 sont appuyées alors que seulement B2,B6,D2 le sont . Or les touches seront pour l'automate programmable , des capteurs et bien entendu , il n'y aura pas qu'un capteur actif à la fois . Aie ! Heureusement , il existe une solution qui est de mettre en serie avec chaque capteur une diode dont la cathode se branche sur les lignes (lettres) . La figure suivante montre cette organisation .

    En faisant la meme expérience que tout à l'heure , on peut voir que maintenant ca fonctionne correctement . Il ne faudra donc pas oublier ces diodes , on utilisera des diodes "signals" courante comme des 1N4148 , mais tout autre modele peut convenir .

    Le portA sélectionne donc les lignes et le B lit les colonnes .
    Pour la version 24 entrées ABC et 12345678 sont utilisés (3*8) . Les 2 autres bits du potrA servent pour le sous ensemble des sorties .
    Pour la version 32 entrées ABCD et 12345678 sont utilises (4*8) . L' autre bit du potrA sert pour le sous ensemble des sorties .

    Ainsi le montage de capteurs se fait comme ceci :

    Note : sur l'automate les chiffres vont de 0 à 7 .
    Les connecteurs Q9 à Q12 pour les chiffres et Q13 à Q20 pour les lettres permettent ces racordements . Ce sont des morceaux de barette autosécable ou des restes de support tulipe (moins onereux) . Pour la version 24 entrées , il est inutile de cabler la ligne D (connecteurs à 3 éléments au lieu de 4) et on peut supprimer Q12 .

    Ces capteurs sont dit flottants car ils ne sont pas référencés par rapport à l' alimentation , ils constituent la majorité des cas que vous rencontrerez . Cependant vous pouvez très bien avoir envie d'utiliser l'automate avec des capteurs non flottants comme une sortie logique d'un montage ( par exemple détection de suregime d'un moteur ) . Vous ne pouvez pas le relier directement car premier problème , il n'y a qu'un fil et deuxieme problème , si pour y remédier vous branchez la masse alors la scrutation qui met à la masse tour à tour ABCD sera concurencée d'ou des erreurs d'interprétation d'entrées actives ...
    Pour résoudre le problème , un simple transistor suffit , il remplace aussi la diode On peut utiliser n'importe quel NPN comme les 2N2222 ou BC537 ...
    La figure suivante montre la connection sur l'entrée D5 .

    La résistance au +5v est la résistance de pull up .
    La ligne 5 verra la masse uniquement lorsque la crutation sélectionne la ligne D et si la base du transistor est alimentée (cas 4) . Le transistor conduit uniquement dans le cas 4 car il lui faut une tension de 0.7V entre sa base et son éméteur . Il est important de signaler que la masse du montage doit etre connectée à celle de l'automate .
    La figure suivante montre le racordement d'un capteur de niveau à seuil réglable sur l'entrée C2 de lautomate .

    Il est aussi possible de racorder directement des capteurs à résistance variable (LDR , CTN ...) Car la pull up et la résistance du capteur forment un pont diviseur qui attaque une entrée logique (niveaux TTL bien que uC CMOS basculement entre 1.5 et 2.5V) .
    L'exemple suivant montre une LDR connectée en B7 .

    Ve=((Rldr/(Rldr+Rpu))*(5-0.7))+0.7 L'automate considère que le capteur est à 1 si l'entrée voit 0 . Les pull up font environ 10kOhms .
    Une LDR présente une faible résistance lorsqu'elle est éclairée (ex 1kOhms) tandis qu'elle est très élevée dans l'obscurité (ex 1MOhms) .

    Eclairée     : Rldr=1kOhms
                   Ve=((1000/(1000+10000)*(5-0.7))+0.7=1.1V
                   Donc l'entrée voit 0
                   L'automate considère le capteur à 1
    Non eclairée : Rldr=1MOhms
                   Ve=((1000000/(1000000+10000)*(5-0.7))+0.7=4.96V
                   Donc l'entrée voit 1
                   L'automate considère le capteur à 0

    J'ai utilisé cette approche en domotique pour interdir l'allumage de lampe durant la journée . Pour régler le seuil de basculement , on peut jouer avec des résistances en serie et parrallèle ou avec la transparence du boitier dans lequel prend place la LDR . attention à ne pas oublier la diode .
    On peut faire de meme avec tout autre capteur , meme pour les photodiodes .

    Voilà vous savez tout sur les entrées .

     

     

    C.3 Etude de l'interfacage de sortie

    L'étude est plus simple que la précédente . Pour sortir des données , on désactive le systeme de scrutation pour que les entrées ne perturbent pas le bus de 8 bits formé par le portB . Et un latch mémorise les données présentent sur le portB . L'entrée de commande de mémorisation des données utilise une ligne du portA (RA0) . Pour la version 16 bits , on utilise 2 latches , il faut donc commander 2 entrées de validation . La deuxieme ligne de validation remplace la ligne D du portA (RA1) . C'est pourquoi il faut choisir entre 32entrées et 8sorties ou 24entrées et 16sorties . Le latch utilisé est un classique 74574 . vous pouvez utiliser les versions LS,HC et HCT .
    On dispose des sorties du latch sur le connecteur Q21 (et Q23 si 16 sorties) . Ce sont des sorties logiques mais à faible puissance .
    Apres le latch on trouve un réseau de transistor darlington ULN2803 . Un tel réseau est capable d'écouler un courant max de 500mA par transistor et supporte une tension max de 50V . ainsi vous pouvez connecter directement la majorite des relais sans problème .
    Ces transistors se comportent comme des interrupteurs à la masse , ainsi en l'abscence de commande ou une commande "0" bloque les transistors , l'interrupteur est ouvert , tandis qu'une commande "1" sature le transistor et donc ferme l'interrupteur . il faudra donc brancher la bobine du relais entre le plus et un transistor du reseau . Remarquez que s'il vous reste des ULN2003 à la place des ULN2803 , vous pouvez quand meme les utiliser mais vous ne disposerez alors que de 7 sorties de puissance . Il suffit juste que la masse soit commune .
    J'ai choisit de ne pas implanter de relais sur la carte car ceci dépend fortement de l'application . en effet pour allumer un voyant il n'y a pas besoin de relais avec les darlingtons , de meme on n'utilise pas les memes relais pour commander une machine à laver 220V ou un ventilateur 12V , on peut utiliser un triac pour une lampe 220V ... Ce choix permet de mettre ce qu'il faut , ou il faut , c'est donc économique et réaliste .
    Le connecteur Q22 (et Q24 si 16sorties) permet d'accéder aux signaux de puissance et à l'alimentation 5V et non regulée (sortie directe de l'alimentation externe , toutefois protegée de l'inversion par la diode D ) .
    L'exemple suivant montre la connection d'un relais 12V sur l'alimentation non regulée qui est donc proche de 12V . Ce relais commande une lampe 220V . il est commandé par la sortie Q1 .

    N'oubliez pas la diode de roue libre DRL qui permet d'éviter la surtension à la coupure de l'alimentation de la bobine . Rappelons que lorsque l'on coupe l' alimentation d'une bobine , il apparait à ses bornes une tension très importante capable de detruire l'électronique du montage de commande . Sans DRL il n'est pas rare de mesurer des tensions de coupures de l'ordre de 100V (meme sur des petits relais ) . L'ULN posséde ses propres DRL , donc si les relais sont de faible puissance et s'ils sont tous alimentés par la meme source alors vous pouvez connecter le plus de cette source au point commun des anodes de toutes les DRL de l'ULN . A ce moment l'utilisation de DRL externes ne se justifie plus . Sinon ne les utilisez pas .

    A la sortie de l'ULN , vous avez soit la masse (interrupteur par rapport à la masse fermé) , soit rien (interrupteur par rapport à la masse ouvert) . Cela est très bien dans le cas des sorties de puissance , mais si vous voulez connecter les sorties à un montage à entrées logiques alors il faut mettre des pull up et tenir compte de l'inversion des niveau (0V = sortie active , 5V = sortie inactive ) . Mais pour cette opération il existe une solution plus simple qui éllimine ces deux problèmes : utiliser le connecteur logique Q21 (et Q23 si 16 sorties) . On peut aussi utiliser ce dernier pour mettre des LEDs indiquant l'activité des sorties .

    Les attentifs ont remarqué la présence d'un réseau RC sur l'entrée haute impedance du latch . Son but est de mettre les sorties en haute impédance à la mise sous tension , laissant ainsi le temps au uC de venir mettre 0 dans le latch avant qu'elles ne passent en basse impédance . ceci est une protection car à la mise sous tension il y à n'importe quoi dans le latch , ce qui peut etre dangereux pour le systeme commandé . Immaginez que vous demandez à un moteur d'accélerer et de freiner en meme temps ... Avec ce dispositif à chaque démarrage , meme après une coupure de courant , la securité est assurée . Cette question de sécurité justifie la presence de l'interrupteur de validation de l'étage de sortie qui encore une fois joue avec cette entrée haute impédance . Il convient donc de ne pas faire n'importe quoi car le systeme RC ne marche qu'a la mise sous tension (ce qui correspond à une utilisation normale) Ainsi lorsque vous programmez l'automate , mettez hors service les sorties avec l'interrupteur . Il n'y a pas de bouton de RESET afin d'éviter ces problèmes . Bien évidement ces précautions ne sont à prendre uniquement si le montage pilote est critique , mais ca ne fait pas de mal de prendre de bonnes habitudes !

    Les sorties du connecteurs Q22 s'appélent Y0,...,Y7
    Les 8 sorties additionelles dans le cas de 16 sorties s'appellent Z0,...,Z7

    Une derniere chose sur les sorties : les bobines des relais peuvent consommer beaucoup alors prévoyez l'alimentation en conséquence .

     

     

    C.4 Etude de l'alimentation

    Vous devez relier une alimentation redressée qui n'a pas besoin d'etre régulée au bornier Q1 . Je ne l'ai pas incorporé au montage car vous pouvez utiliser une batterie ou un transformateur et de plus le dimensionnement dépend de la consommation . un bloc secteur convient bien pour alimenter l'automate avec quelques relais . Sa tension doit etre d'au moins 8V pour que le régulateur travaille bien et etre adaptée aux relais s'ils sont alimentés par elle .
    La diode D protége l'électronique contre les invertions de branchement . Le condensateur C5 filtre cette tension . Le régulateur 7805 fournit le 5V nécéssaire au montage . Le condensateur C6 découple l'alimentation du montage et éllimine les composantes hautes fréquences .
    Chaque circuit logique dispose aussi de son condensateur de découplage au plus pret de leur alimentation pour etre éfficace . La LED indique que le montage est sous tension , son courant est limitée par la résistance R5 .
    Vu la faible consommation des circuits , le régulateur n'a pas besoin de radiateur . Mais si on met des LEDs de visualisation des sorties ou /et si on utilise le 5V pour alimenter les bobines de relais 5V alors il faudra impérativement monter le régulateur sur un radiateur . Les connecteurs Q2,Q3,Q4,Q5 sont des prises d'ou l'on peut tirer l'alimentation nécéssaire à de petits montages annexes s' il y en à .

     

     

    C.5 Etude du programmateur

    schéma électrique

    Attention: il manque sur le shéma R4 sur la base de T4
    Attention: sur le 4069 du shéma il faut inverser les pattes suivantes : 8,9 10,11 12,13


    nomenclature

    IC1              : 4069 (inverseurs)
    T1               : 2N2907 (transistor PNP)
    T2,T3,T4,T5,T6   : 2N2222 (transistor NPN)
    R1,R2,R3,R16,R17 : 470
    R4               : 100 K
    R5               : 100
    R6               : 2200
    R7,R8,R9,R12     : 10 K
    R10,R13          : 10 K
    R11              : 1K
    R14              : 100 K
    R15              : 4700
    C1,C2,C3         : 10 uF , 25V
    C4               : 100uF ,25V
    C5               : 150 nF
    C6               : 100 nF
    D1,D2,D3,D4,D5   : 1N4148 ou 1N4001

    Introduction
    Le programmateur n'est pas intégré sur la carte de l'automate car si vous réalisez plusieurs automates , vous ne réaliserez qu'un seul programmateur . En effet à quoi servent plusieurs programmateurs alors que vous programmez qu' un seul automate à la fois !
    Le programmateur utilise le port parrallèle , sa carte peut etre directement soudée sur un connecteur DB25 male qui s'enfiche sur le port parrallèle . Ceci supprime le cable de liaison PC programmateur . Un cable à 5 conducteurs relie le programmateur à l'automate afin d'y programmer le PIC qui s'y trouve . Eh oui vous n'avez meme pas besoin d'enlever le PIC pour le programmer . Ce cable se branche sur le connecteur Q8 de l'automate programmable . Attention , ce cable doit etre le plus court possible (le mien fait 30 cm) . Je programme le PIC avec la méthode seacute;rie , dans cette méthode il faut dabord présenter entre 12V et 14V sur la patte RESET du uC , A ce moment le PIC passe en programmation série ou RB6 sert à vehiculer le signal d'horloge et RB7 les données .
    Une rangeacute;e de transistor isole le PC du montage car uniquement la masse est commune . Donc si le montage grille , le PC reste intacte et inversement (c'est un peu plus ennuyeux) . Ainsi si le PC est allumé et l'automate eteint alors le PC n'endomage pas l'automate et inversement . C'est meme "hot plugable" et pour rire "plug and play" car le programme sait détecter si le programmateur est connecté et alimenteacute; . Relier le PC a l'automate sans que le logiciel de programmation tourne , ne devrait pa poser de problème car il est peu probable que l'ordinateur fasse de lui meme par hasard la séquence de programmation . Mais je ne vous recommande pas de lancer une impression sur le port ou est connecté le programmateur , ca pourrait déprogrammer ou mal programmer le PIC .
    Bref , ca discute , mais il y a un problème , en effet ou trouver la precieuse tension de programmation qui doit etre comprise entre 12V et 14V pour faire entrer le PIC en mode de programmation alors que l'on est entoureacute; de 5V ? Une alimentation externe ? Ah non ca doit etre simple ! Utiliser le 12V du port serie ? Non surtout pas en effet il est rare que ce dernier etteigne 12V , c'est d'ailleur là l'explication que les programmateur sur port série du commerce fonctionnent rarement . En lisant la documentation de programmation du PIC , on s'apercoit que ce dernier ne prélève aucun courant signsficatif de cette haute tension et qu'elle est juste là pour faire basculer un comparateur qui provoque le passage en programmation série . Dans ces conditions on peut utiliser un montage à pompe de charge pour fabriquer à partir du 5V notre haute tension . (remarque : C'est suivant ce principe que fonctionne le MAX232) . La pompe presentée est plus performante que les traditionelles cellules RC . Elle est capable de fournir la tension de programmation mais sous un très faible courant , donc la moindre résistances trop petite la fait chuter , c'est pourquoi il est recommendez de se tenir aux valeurs specifiées et surtout pour R1 de l'automate .

    Description
    L'oscillateur formé par IC1,R14,R15 et C5 fournit l'horloge à la pompe de charge formée par IC1,R1 à 3,C1 à 3 et D1 à 3 . Cette pompe charge le condensateur C4 a théoriquement 5V + 5V * nombre de céllule donc 20V . On mesure 18V . Bien sur lorsque T1 ne conduit pas . Quand T1 conduit , les diverses résistances améne cette tension dans la bonne plage (12V-14V) en faisant attention de tenir compte de R1 de l'automate . si la tension est trop grande on peut mettre une résistance entre A et M si c'est l'inverse il faut augmenter R1 . L'association R6,D5 aide la pompe au passage de 0 à 5V . L'ensemble T1,R4,T2,R7 permet d'appliquer la tension de programmation sur la patte /Reset ce qui fait passer le microcontroleur en mode de programmation série . L'ensemble formé par T3,R5,R8 permet d'appliquer 0V sur le /Reset ce qui initialise le microcontroleur . Si les deux ensembles précédents sont désactives alors /Reset=5V et le microcontroleur éxécute son programme .
    T6,R12,R13 et R16 controlent le signal d'horloge pour la programmation , tandis que T4,T5,R9,R10,R11,R17 s'occupent des données .
    L'etage à transistor protege le PC des betises , ainsi vous pouvez branchez sans crainte . L'ordre d'allumage n'a aucune importance . Le programme sait si la carte est presente grace au bouclage par R11 et détecte la presence de l'alimentation grace au bouclage par T5 et T4 .

    Mise en oeuvre
    Ce montage est tellement simple qu'il ne necessite pas de circuit imprimé , en effet une plaque en bande suffit . Je rappel que le cable entre le programmateur et l'automate doit etre le plus court possible (le mien fait 30cm) . Verifiez que la pompe donne bien la bonne tension , si non procedez comme indiqué afin de l'obtenir . La pompe génère un tel bruit que la programmation série se desynchronise , mais le logiciel se debrouille pour tout resynchroniser . Voilà vous savez tout sur ce programmateur , eh bien non , frottez vous les mains car il peut faire d'autres choses , en effet il permet aussi de programmer les PIC16C84 et 16F84 en assembleur ou de réaliser un séquenceur programmable a la place de l'automate . Enfin vous pourrez jouer avec le BUS I2C , programmer des EEPROM I2C ou d'autres PIC comme les 12C508 et 12C509 en faisant une petite carte qui se resume à un support , de plus elle puisse son alimentation d'une des 4 prises pour montages externes de l'automate , mais ce logiciel n'est pas encore disponible .

    Bref , mais n'oubliez pas cette histoire d'invalidation des sorties durant la programmation à l'aide de l'interrupteur prevu à cet effet . Pour en savoir plus sur la programmation série des PICs ou sur les PICs eux memes , je vous propose d'aller chercher des fichier PDF sur le site très agréable de microchip son fabriquant à l'adresse http://www.microchip.com .

     

     


    D. La réalisation

    La réalisation est très simple , tellement simple qu'on peut meme se passer de circuit imprimé , en effet une plaque percée en bande suffit .
    Bien sur vous pouvez toujours réaliser un circuits imprimé , pour vous aider , la figure suivante présente les thypons (non testés) .

    Et celle ci l'implantation des composants

    Dans le cas d'un circuit imprimé , on le fait par la méthode de son choix car j'ai voulu faire simple aussi il n'y a pas de piste qui passent entre les pattes des composants et c'est en simple face . Ceci explique la présence des straps mais je ne pense pas en avoir abusé . Comme d'habitude , on commence par souder des plus petits composants vers les plus gros . Ainsi on n'oublira pas de souder la diode D avant de souder le condensateur C5 car elle se trouve dessous . Les condensateurs de découplages sont à souder coté cuivre afin d'etre le plus pret possible des alimentations des boitiers car sinon ils ne servent à rien , question de compatibilité électromagnetique . Ces condensateurs sont donc a souder en dernier car sinon ils gènent la soudure des autres composants , notament les supports . On montera les circuits integrés sur supports afin de les remplacer simplement . Le support du PIC sera du type tulipe car il résiste mieux à des manipulations fréquentes que le type lyre , ainsi vous pourrez programmer des PICs dans les meilleurs conditions . Avant d'insérrer les circuits intégrés on verifira la présence de l'alimentation aux bon endroits et le fonctionnement de la cellule RC d'invalidation des sorties . On pourra alors mettre en place les differents circuits . Pour l'alimentation externe , se référrer à la partie alimentation , mais pour tester , un simple bloc secteur d'au moins 8V suffit . On préffèrera un bornier à vis pour Q1 et de la barrette autosécable ou des bouts de supports tulipes pour les autres connecteurs . Il est interressant de réaliser un systmème de détrompage afin de ne pas brancher les connections à l'envers . en effet brancher le cable du programmateur à l' enver signe l'arret de mort de ce dernier , pour ce cas on peut utiliser un connecteur DB9 car les branchements seront fréquents , aini on ne se trompera pas . Pour détromper une barette il suffit de mettre en place un élement supplémentaire qui interdit de se tromper de sens , en coupant la partie male de cet élement et en bouchant la partie femelle . La figure ci dessous explique cet astuce simple et qui peut éviter bien des soucis .

     

     


    E. Le graphcet

    Soyez patient ! Je sais que vous voulez voire si votre application fonctionne , mais comme je l'ai dit l'automate se programme avec le graphcet , donc il faut apprendre le graphcet .

     

     

    E.1 Présentation

    Le graphcet pour Graph de Commande Etapes Transition est un outil extrémement puissant et bien adapté pour représenter la commande d'un systmème . C'est une adaptation des réseaux de Petris à la commande des systmèmes . De plus il à l' avantage d'etre normalisé et extrèmement utilisé dans l'industrie .
    Comme son nom l'indique il sagit d'un graph , donc c'est agréable et facilement accéssible au non initié , de plus c'est intuitif .
    Les 3 éléments graphiques de bases sont :

    • les étapes
    • les transitions
    • les liaisons

    Les liaisons permettent de joindre les étapes et les transitions ( à angle droit d'après la norme ) . La figure suivante montre ces éléments .

     

     

    E.2 Les étapes

    Les étapes représentent une position dans laquelle est le systmème . Une étape peut etre active ou inactive . L'ensemble des étapes actives indique l'état du systmème . On associe généralement les sorties au étapes , il sagit alors d'un automatisme de Moore . De plus les étapes portent des numeros .
    La figure suivante indique que lorsque l'étape 3 est active alors il faut allumer la lampe 1 .

    Ainsi lorsqu'une étape est active alors la ou les sorties associées sont activées .
    En fait il existe deux sortes d'étapes , les étapes "normales" et les étapes "initiales" qui sont actives à l'initialisation , les "normales" étant bien sur inactives .
    La figure suivante montre une telle étape .

     

     

    E.3 Les transitions

    Les transitions permettent de passer d'une étape à une autre .
    Les transitions sont reliées aux entrées le plus souvent et poss èdent une équation logique . Si cette expréssion logique est vérifiée (vrai) alors la transition est dite récéptive ou active .
    La figure suivante montre une étape avec son équation logique .

    Si une transition et l'étape qui la précéde sont actives alors l'étape précédente devient inactive et l'étape suivante active .

     

     

    E.4 Un exemple simple

    Pour illustrer ces notions , prenons un exemple simple . Il sagit de remplir une résèrve d'eau avec une pompe . Lorsque le capteur bas n'est plus recouvert alors la pompe se met en route , cette dernière s'arrete lorsque le capteur haut est recouvert . Un capteur recouvert vaut 1 , sinon 0 .

    A l'initialisation , l'étape 0 est active et la 1 inactive . La pompe est arretée car aucune étape ne la commendant (ici la 1) est active .
    Lorsque le niveau d'eau passe sous le capteur bas , alors celui ci n'est plus recouvert , donc la transition "/bas" est verifiée . Il s'en suit une désactivation de l'étape 0 et une activation de l'étape 1 d'ou la mise en route de la pompe . Grace à la pompe , le niveau d'eau monte et lorsqu'il recouvre le capteur haut , alors la transition "haut" devient active d'ou la désactivation de l'étape 1 et de la pompe et l'activation de l'étape 0 . Et le cycle recommence . Ainsi le jardinier peut arroser son jardin tranquillement . J'entend les murmures ironiques du genre "Y à t'il besoin d'un uC la ou une simple bascule RS suffit ?" , certe non mais c'est un exemple simple pour comprendre .

     

     

    E.5 Le parrallélisme

    Un des grands avantages du graphcet , c'est le parrallélisme , en effet dans un graphcet il peut y avoir plusieures étapes actives en meme temps , il peut meme y avoir plusieurs graphcets qui tournent simultannément ! Ainsi vous pouvez commander la pompe précédente en meme temps que la porte du garage , les lampes de la maison et une alarme , et ceci avec le meme API ! Intérréssant non ? Et ceci sans que les graphcets ne se genent mutuellement . On peut aussi les faire interagir entre eux (exemple : l'alarme s'arme quand on ferme la porte du garage) ...

     

     

    E.6 La divergence en "OU"

    Le premier graphcet été linéaire , mais comme le graphcet s'apparente à un programme , il doit etre capable d'éffèctuer des choix . En effet à partir d'une étape , on doit pouvoir aller à d'autres étapes suivant un choix .
    Par exemple , on à deux pompes et les entrées sélect1 et sélect2 sélectionnent la pompe à engager .

    Mais attention , le parrallélisme fait que si les deux transitions sont récéptives en meme temps alors les étapes 1 et 2 s'activent simultanément . Ici c'est pas grave , le bassin se remplira plus vite , de plus la condition d'arret étant la meme ... Mais cela peut poser des problèmes graves dans certains cas , en effet immaginons que l'étape 1 fasse monter un ascenseur et la 2 le fasse descendre ! De plus si les conditions d'arret ne sont pas les memes alors il se pourrait que l'étape 1 termine , ce qui active l'étape 0 alors que la 2 est encore active d'ou un désordre grave et dangeureux ...
    Bref si on veut vraiment faire un choix , alors il faut que les transitions soient exclusives, c'est à dire qu'elles ne puissent pas etre récéptives en meme temps . La figure suivante montre le graphcet modifié , c'est rien mais ca change radicalement le fonctionnement .

    Comme vous le voyez la divergence en "OU" est représentée par une simple barre horizontale .

     

     

    E.7 La divergence en "ET"

    La divergence en "ET" permet de lancer plusieures actions en parralléle , il ne faut donc pas oublier de les resynchroniser à la fin afin de ne pas perdre des étapes actives en chemin , ce qui est un réel risque .
    Dans l'exemple suivant , il y a maintenant deux réservoirs , chacun ayant un capteur plein qui passe à "1" lorsqu'il est plein . Lorsque l'on appuie sur le bouton remplit alors les deux réservoirs se remplissent . Le graph ci dessous montre ce fonctionnement .

    A l'initialisation , l'étape 0 est active et donc les pompes sont à l'arret . Lorsque l'on appuye sur le bouton remplit alors les étapes 1 et 2 s'activent en meme temps alors que la 0 se désactive .
    Quand le réservoir 1 est plein , le capteur plein1 rend la transition active d'ou une désactivation de l'étape 1 et de la pompe1 et une activation de l' étape 3 qui attend que la 4 soit active .
    De meme , quand le réservoir 2 est plein , le capteur plein2 rend la transition active d'ou une désactivation de l'étape 2 et de la pompe2 et une activation de l' étape 4 qui attend que la 3 soit active .
    Le franchissement de la double barre ne peut se faire que si les étapes directement au dessus sont actives et si la condition est verifiée . Ici la condition est toujours verifiée car egale à 1 , donc des que les étapes 3 et 4 sont actives , on retourne à l'étape initiale .
    La divergence en "ET" est représentée par une double barre horizontale .

     

     

    E.8 Le reste

    La norme ne s'arrete pas là , il y a encore des pages et des pages , mais vous en savez suffisament . N'hesitez pas à consulter des ouvrages sur ce sujet . Un outil complementaire interressant est le GEMMA ou Graph d'Etude des Modes de Marche Arret qui est un graphe avec des cases vides à remplir , sur ce graph tout les problèmes pouvant arriver au systmème sont ressencés , à vous de décider si vous les traitez ou pas et comment . Exemple , coupure d'alimentation , faut il réinitialiser , Une machine de la chaine est en panne , faut il produire en dégradé ou tout arreter , comment traiter le bouton d'arret d'urgence ... Dans cette approche on construit dabord le graphcet en fonctionnement normale puis on rajoute des bouts de graphcet au graphcet normale afin de réagir aux problèmes . Notez que la plupart des automatismes fonctionnent grace au graphcet souvent associé au GEMMA .

     

     


    F. Particularités du graphcet utilisé

    Soyez rassurés , tout ce que l'on a vu auparavant , l'automate peut le faire et le fait meme très bien . Afin de simplifier mon travail pour la réalisation des logiciels , vous fabriquerez vous meme vos convergences en "OU" et en "ET" , les notions de simple et double barre n'existe pas chez moi , mais vous pourrez bien entendu faire le meme comportement . La figure suivante reprend les graphe avec ma notation .

    Avouez que ca ne change pas grand chose .
    Je propose deux manièress de programmer , soit en graphique , soit en littéral . Ce que j'appelle graphcet littéral est simplement une description textuelle du graphique . Ca peut etre plus rapide et plus puissant que le graphique mais moins conviviale , bref on doit arriver au meme resultat .

     

     


    G. Programmes

     

     

    G.1 Présentation

    Cette réalisation utilise deux programmes :

    1. Le programme d'interprétation au niveau du PIC .
    2. Le logiciel de convertion de graphcet graphique , en graphcet littéral et de transfert du graphcet littéral dans l'automate au niveau du PC .

    Pour ne pas s'y perdre , la figure suivante , montre cette organisation .

    Si vous désirez programmer en graphcet littéral alors , éditez un fichier texte avec les instructions du graphcet littéral . Nommez le avec l'extension .grs . Lancer progapi.exe et choisir charger GRS dans le logiciel . Le programme convertit le graphcet littéral en code et ajoute l'interpréteur . il ne reste plus qu'a demander son transfère .

    Si vous désirez programmer en graphique , alors lancer progapi.exe et construisez votre grahcet . Le programme transforme ensuite ce graphique en grapcet littéral . Modifier le graphcet littéral si vous voulez puis téléchargez le . Toutes ces operations mise à part la modification du graphcet littéral peuvent se faire à partir du programme progapi.exe .

    J'ai réalisé moi meme , ces programme à l'aide d'un compilateur C , ils sont libres de droit et à utilisation non commerciale . Si vous voulez les sources , envoyer un mail à udelmas@etud.insa-tlse.fr . Je vous les enverrez après les avoir rendu plus comprehensibles . Vous pourrez aussi trouver les mises à jours . Signalez moi les bugs , je tenterai alors de les corriger .

    Examinons maintenant les differents programmes

     

     

    G.2 L'interpréteur au niveau du PIC

    Ce programme est chargé d'éxécuter le graphcet au niveau de l'API . Il dispose d' une table ou est rangé le graphcet littéral à interpréter et d'une zone en RAM appellée zone des bits qui indique l'activitée des entrées , sorties , étapes , bits internes et bits systmèmes . Ces 2 derniers termes seront expliqués au niveau du graphcet littéral .
    Son fonctionnement est le suivant .

    Les operations systmèmes consistent à mettre à jour les différents bits systmèmes qui procurent des services à l'utilisateur , elles gèrent aussi les temporisations .
    Ce programme à été fait en assembleur et est optimisé pour la vitesse , la programmation du PIC en assembleur est un vrai régal !

     

     

    G.3 Le graphcet littéral

    Comme nous l'avons vu , le graphcet littéral est un petit language qui est sensé représenter un graphcet .

     

     

    Bases

    Les étapes se representent par * pour les initiales et - pour les autres .
    Pour changer d'étape , on utilise > , mais le changement est éffectué seulement si l'étape dans lequel il est définit est active et si l'indicateur de test vaut 1 .
    L'indicateur de test est un bit avec lequel on peut faire les operations suivantes :

    • l bit : chargement de l'indicateur avec la valeur de bit
    • ln bit : chargement de l'indicateur avec le complément de la valeur de bit
    • a bit : et logique entre l'indicateur et le bit (indicateur = indicateur et bit)
    • an bit : et logique entre l'indicateur et le complément du bit (indicateur = indicateur et /bit)
    • o bit : ou logique entre l'indicateur et le bit (indicateur = indicateur ou bit)
    • on bit : ou logique entre l'indicateur et le complément du bit (indicateur = indicateur ou /bit)
    • x bit : ou exclusif entre l'indicateur et le bit (indicateur = indicateur xor bit)
    • xn bit : ou exclusif entre l'indicateur et le complément du bit (indicateur = indicateur xor /bit)

    Les transitions sont donc réalisés avec l'indicateur et l'instruction > .
    = permet d'affecter un bit de la valeur de l'indicateur .
    @ permet de mettre des commentaires (commentaires sans blancs et non collés à @) . Les commentaires ne sont pas chargés dans le PIC .
    Voici pour les instructions .

    L'opérande bit indique le bit qui entre en jeux , il y a 256 bits possibles . On peut mettre directement leurs numeros , mais il faut les connaitre et ce n'est pas pratique . Pour simlpifier , ces numéros sont remplacés par une chaine et un numéro . Attention il faut coller la chaine et son numero . Cette chaine est un offset et chaque chaine indique une zone particulière .

    x  : étape    0-63
    i  : entrée   0-31   
    o  : sortie   0-15   
    bi : bit interne 0-31
    bs : bit systmème 0-7
    tc : commande de tempo 0-15
    tf : indicateur de fin de tempo 0-15

    Les bi pour bits internes , sont des bits laissés libre pour l'utilisateur , il peut les utiliser comme mémoire et jouer avec l'indicateur de test .
    Les bs ou bits systmèmes , sont des bits gerés par le uC qui fournissent des services a l'utilisateur , ainsi le bit bs7 est à "1" lors de la premiere éxécution du graphcet littéral , il passe à "0" ensuite , les bits bs0 à bs6 clignotent afin de réaliser des voyants clignotants très simplement . bs0 clignote à 10Hz (1 pendant "50"mS et 0 pendant "50"ms) bs1 2 fois moins vite et ainsi de suite .
    Les bits tc sont les commandes de lancement des 16 temporisations .
    Les bits tf indiquent que la temporisation correspondante est terminée . Si le lancement d'une temporisation intervient dans une étape , alors elle doit etre testée à la transition qui suit cette étape . Les temporisations sont définies entre 0 et 25.5 secondes au pas de 0.1s et sont précises à +/- 0.1s , donc 0.3 peut durer entre 0.2 et 0.4s .
    La définition de la valeur d'une temporisation , se fait de la maniè suivante : #t0 135 , signifie que la valeur de la temporisation 0 est de 135 fois 100ms , soit 13.5s ici . Ces valeurs sont stoquées dans l'EEPROM de donnée du PIC qui peut etre reprogrammée 1000000 de fois , donc il n'est pas besoin de recharger le graphcet pour modifier uniquement une temporisation . Le programme de programmation permet de modifier les tempos , ainsi vous pouvez les régler expérimentalement jusqu'a obtenir le resultat escompté . La faible taille de la RAM ne permet pas d'avoir plus de temporisations ( bien que les valeurs soit en EEPROM , le decomptage se fait en RAM ) .
    L'exemple suivant montre un premier graphcet littéral qui utilise les temporisations . Le but est d'allumer une lampe pendant 10s lorsque l'on appuie sur le bouton poussoir bp . On suppose que la lampe est sur la sortie Y2 et le bouton poussoir sur l'entrée A1 .
    Graphcet graphique

    Graphcet littéral

    @  Exemple_tempos
    *   0
    l   iA1
    >   1
    -   1 
    l   tf0
    >   0
    l   x1
    =   oy2
    =   tc0
    #t0 100

    Ce premier exemple permet de montrer la programmation en graphcet littéral .
    - Au niveau de la syntaxe , les 2 colonnes doivent etre séparées et il ne doit pas y avoir de blancs dans chacune des 2 colonnes

    l i A1       NON! , remplacez par   l iA1
    @ exempe 1   NON! , remplacez par   @ exemple_1

    - Lorsque les bits d'étapes (x0 à x63) sont utilisés avec des instructions d'étapes (* - >) alors il n'est pas nécéssaire de mettre le x devant le numero . Mais ca marche aussi si vous le mettez .

     

     

    Méthode de programmation

    Il est d'usage et de bon usage de respecter une programmation en 3 parties du type :

    • PRETRAITEMENT
    • TRAITEMENT
    • POSTTRAITEMENT

    Pré traitement
    On y éffectue souvent les operations combinatoires complexes qui entre autre peuvent servir pour les transitions , par exemple si on a besoin plus tard de (i1 et i2) xor (i3 ou i4) , on peut évaluer cette expression dans bi0 comme suit .

    l i1
    a i2
    = bi1
    l i3
    o i4
    = bi2
    l bi1
    x bi2
    = bi0

    Bien sur on peut faire plus simple , mais c'est pour que vous compreniez .

    Traitement
    Cette seconde partie s'occupe de l'évolution du graphcet , on y indique , la dynamique du graphcet , c'est à dire comment passer d'une étape à une autre avec les transitions , mais les sorties n'interviennent pas encore ici . Ainsi l'évolution du graphcet suivant , donne les lignes suivantes .

    *  0
    l  i1
    a  i2
    >  1
    -  1
    ln i3
    >  0

    Post traitement
    On affecte les sorties à ce niveau la .
    Exemple .

    l x1
    = o3

    ATTENTION , il ne doit y avoir q'une seule affectation de sortie

    Avec deux affectations .

    l x1
    = o5
    l x21
    = o5

    L'interpréteur interpréte tout le graphcet littéral dans l'ordre , puis affecte les sorties à la fin de cette interprétation . donc ici il met à jour la sortie 5 suivant l'activité de l'étape 1 , puis suivant l'activité de l'étape 21 , on se retrouve donc avec l'activite de l'étape 21 , c'est comme s'y on faisait en arythmetique o5 = x1 , puis o5 = x21 , donc à la fin o5=x21 , c'est clair ! Il faut donc une seule affectation par sortie , donc dans ce cas :

    l x1
    o x21
    = o5

    C'est pas sorcier , mais il faut faire attention

    Il n'y a pas besoin d'instruction pour séparer ces trois parties , on met dans l'ordre pré traitement suivit de traitement et enfin post traitement .

     

     

    Divergence en "OU"

    La divergence en "OU" ne pose pas de problèmes particuliers , si ce n'est qu'il ne faut pas oublier de la rendre exclusive .

    Le graphcet précédent , donne le graphcet littéral suivant .

    @ Ex_de_divergence_en_"OU"
    
    @  Pre_traitement
    @  Traitement
    *  0
    l  i1
    >  1
    ln i1
    a  i2
    >  2
    -  1
    l  i4
    >  0
    -  2
    l  i5
    >  0
    @  Post_traitement
    l  x1
    o  x2
    =  o1
    l  x2
    =  o2

     

     

    Divergence en "ET"

    Aie , aie aie ! Ici c'est difficile de comprendre !
    Normalement il faudrait que la zone des bits ne soit modifiée qu'a la fin des passages d'interprétation , or les 68 octets de RAM du PIC 16F84 ne permettent pas de travailler sur une seconde zone des bits que l'on viendrait recopier sur la premiere après chaque traitement . en clair , dés que vous modifiez un bit ou vous changez d'étape , le bit correspondant est immédiatement modifié . Cela pose un problème , pour s'en convaincre examinons l'exemple du chapitre E .

    @  Ex_divergence_en_"ET"_qui_ne_marche_pas
    
    @  Pre_traitement
    @  Traitement
    *  0
    l  i0
    >  1
    >  2
    -  1
    l  i1
    >  3
    -  2
    l  i2
    >  4
    @  repere_A
    -  3
    l  x4
    >  0
    @  repere_B
    -  4
    l  x3
    >  0
    @  Post_traitement
    l  x1
    =  o1
    l  x2
    =  o2

    Examinons le cas ou l'étape 1 soit finit avant la 2 , dans ce cas x3 et x2 sont actives .
    Puis au moment ou x2 finit , x4 devient active .
    Au repère A , lors de l'examun de x3 , on voit que x4 est active , donc on désactive x3 et on va à x0 .
    au repère B , on ne peut pas aller à l'étape 0 car l'étape 3 n'est plus active , en effet on vient de la désactiver !
    Donc ca ne marche pas . 2 zones de bit pour les étapes auraient été l'ideal mais avec cette faible place en mémoire , c'est impossible .
    Heureusement , il y a une solution , en effet il suffit dans le pre traitement d'affecter un bit interne à 1 si les 2 étapes x3 et x4 sont actives , ainsi lorsque la 3 passe à 0 , cela ne gene pas la 4 et inversement car le bit n'est modifié que lors de la prochaine interprétation . Grace à cette astuce , on se passe de la double zone des bits .
    Le graphcet suivant tient compte de cette modification en utilisant , le bit interne bi0 .

    @  Ex_divergence_en_"ET"_qui_marche
    
    @  Pre_traitement
    l  x3
    a  x4
    =  bi0
    @  Traitement
    *  0
    l  i0
    >  1
    >  2
    -  1
    l  i1
    >  3
    -  2
    l  i2
    >  4
    -  3
    l  bi0
    >  0
    -  4
    l  bi0
    >  0
    @  Post_traitement
    l  x1
    =  o1
    l  x2
    =  o2

     

     

    Bits systmèmes

    L'automate offre 8 bits systmèmes bs0 à bs7 .
    Le bit bs7 est à "1" lors de la premiere éxécution du graphcet littéral , il passe à "0" ensuite . Les bits bs0 à bs6 clignotent afin de réaliser des voyants clignotants très simplement . bs0 clignote à 10Hz (1 pendant "50"mS et 0 pendant "50"ms) bs1 2 fois moins vite et ainsi de suite .


    La fléche au dessus de l'action o1 indique que la sortie est à activer si lorsque l' étape 1 est active , bs2 est à 1 . C'est ce que l'on appelle l'activation conditionnelle . Ceci fait est aussi normalisé . Ici la sortie clignotera à 2.5Hz quand l'étape 1 sera active .
    Le graphcet littéral est le suivant .

    @  Ex_de_clignotement
    
    @  Traitement
    *  0
    l  i0
    >  1
    -  1
    l  i1
    >  0
    @  Post_traitement
    l  x1
    a  bs2
    =  o1

     

     

    Informations pratiques

    Pour créer ces fichiers , on utilisera un éditeur de texte . Par exemple Edit sous DOS ou Blocnote sous windows , ces éditeurs marchent très bien ( pitié , n'utilisez pas word ! ) . Sauvegardez les avec l'extension .grs afin de vous y retrouvez facilement . Supposons que vous l'avez sauvé sous monfich.grs . Ensuite sous DOS ou dans une fenetre lancez progapi , charger le fichier avec chargeGRS , le programme indique alors les erreurs , et le transforme en resultat.hex qui reflete l'image de ce qui va etre envoyé dans la mémoire du uC ( graphcet littéral codé + interpréteur ) . Ne téléchargez pas un fichier avec des erreurs ! Par contre il n'emet pas d'avertissement si les temporisations ne sont pas initialisées ( definit avec #t0 100 par exemple ) car vous pouvez les modifiez par la suite . Mais ca surprend toujours à l'éxécution quand une operation qui doit se faire en 0.5s prend 25s ou inversement . Une des choses très importante dont je ne vous ais pas encore parlé , est la place en mémoire occupée par le graphcet littéral . en effet la mémoire du PIC n' est pas extensible et si le graph est trop grand alors il ne rentrera pas . Actuellement la place reservée pour le graphcet littéral est de 700 octets , soit 350 lignes de graphcet littéral sans compter les commentaires qui ne sont pas chargés et les initialisations des temporisations qui vont dans l'EEPROM de donnée . Un graphcet simple de 64 étapes doit pouvoir tenir en mémoire . Vous pouvez donc faire de bonnes applications sans craintes . Le graphcet littéral constitu la meilleur facon de tirer toute la puissance de l'API et de reduire au minimum l'espace occupé en mémoire .

     

     

    G.4 La programmation graphique avec progapi.exe

    Avant de lire cette partie , je vous conseille de lire la précédente car certaines notions sont essentielles .
    Ce programme permet d'éditer un graphcet "graphique" , de le sauvegarder , le rapatrier , le convertir en graphcet littéral , le charger dans l'automate et de regler les temporisations .
    Pour s'y retrouver , sauvegardez les fichiers des graphcets graphiques en .gra et ceux des graphcets littérals en .grs . Le logiciel est composé de trois écrans :
    L'ecran general permet d'éffectuer les opérations précédaments décrites .
    L'ecran de "la grille" permet de saisir le graphcet . Pour construire le graphcet , placez vos étapes , transitions sur la grille ... Ici les étapes comme les transitions portent des numeros (étapes 0-63 , transitions 0-99) afin de les repèrer plus facilement . Vous devez ensuite spécifier les sorties à activer pour les étapes , puis donner les équation logique des transitions , équations qui sont à écrire avec les codes du graphcet littéral . Si les couleurs vous fatigue , vous pouvez les changer . il n'y a pas grand chose à dire sur l'utilisation , en effet c'est assez conviviale et intuitif .
    L'ecran de transfert permet de charger les graphcets dans l'automate , lancer l'automate pour verifier le fonctionnement et régler les tempos dans l' automate (celles du fichiers ne sont pas modifiées) . L'option autres permet de charger ses propre programmes en assembleur au format hex . Attention , avant de transfférer un fichier graphique , il faut le compiler avec le bouton compil.

    Ce programme est fait en C et tourne sous DOS ou sous Windows
    Pour apprendre la programmation en graphcet littéral , il est agréable de dessinner un graphcet , de le convertir en graphcet littéral et de regarder ce que ca donne en littéral .
    Avec la programmation graphique on peut faire moins de choses qu'en littéral , et le graphcet littéral qui en resulte est plus long . Vous pouvez neamoins faire l'architecture en graphique et venir modifier ensuite le reste en littéral . Bref touchez à tout .

     

     


    H. Epilogue

    Voilà , vous savez tout sur cet automate programmable . C'est un outil très puissant pour tout ce qui touche à l'automatisation . Pour ma part , je l'utilise avec satisfaction en domotique et en modelisme ferrovière . La réalisation de ce projet m'a prit énormement de temps , mais je suis satisfait de l'utilisation . Envoyez moi vos remarques , suggestions à l'adresse udelmas@etud.insa-tlse.fr . Je mettrais les modifications , bugs et amélioration sur mon site a` l' adresse : http://www.etud.insa-tlse.fr/~udelmas/index.html . J'ai essayé de rendre cet automate le plus simple et le moins cher possible afin que tout le monde puisse le réaliser , il devrait vous couter dans les 100F brute et dans les 200F avec boitier , alimentation , relais ... Pour ceux qui ne peuvent pas réaliser des circuits imprimés , je conseille de le faire avec des plaques en bandes percée . De plus le PIC n'a pas besoin d'etre préprogrammé , il suffit de le mettre sur le montage et le logiciel le programme qu'il soit vierge , protégé ... Vous n'avez donc pas de crainte à avoir ni d'escuse pour ne pas réaliser cet API . Meme si vous n'avez pas de PC rien ne vous empèche d'aller programmer chez un collègue . De plus avec ce materiel , vous pourrez faire plein d'autres choses comme programmer des PIC , des mémoires I2C , jouer avec l'I2C , utiliser le montage comme séquenceur , des logiciels pour cela sont en cours de création .
    Cependant tout ne peut pas etre piloté par un API , par exemple , la commande d'un moteur pas à pas serait une vraie galère , c'est pourquoi la programmation classique ne doit pas etre oubliée . Pourquoi ne pas utiliser ce montage avec un programme en assembleur ? Mais vous pouvez encore faire mieux en melangeant graphcet et assembleur en mettant votre programme en assembleur dans la boucle de l'interpréteur . Votre programme ne doit pas toucher à certaines variables afin de ne pas faire n'importe quoi à l'interpréteur . Votre programme doit etre un programme assez rapide afin de rafraichir le graphcet assez souvent . Vous pouvez meme faire un programme de service qui communique avec la table des bits offre des ainsi des fonctions supplementaires , mais à chaque programme l' espace pour le graphcet diminue ... Un conseil , communiquez vous vos graphcet , ca fait avancer le "chmimblick" .
    Bref l'automate programmable industriel , c'est super et après quelques utilisations , vous ne pourrez plus vous en passer .

     

     


    Ulysse Delmas-Begue
    Décembre 1998
    La présente réalisation ainsi que les logiciels ne peuvent en aucun cas etre utilisés à des fins commerciales sans mon consentement .


    Mon e-mail : udelmas@etud.insa-tlse.fr
    N'hésitez pas à me contacter pour toutes questions .

    source de ma rubrique http://www.chez.com/udelmas/autopic2.htm