Td corrigé Explications pdf

Explications

Utilisant le langage Ladder, il est facile pour l'utilisateur d'obtenir un programme simple et efficace. Très répandu dans l'industrie, .... Dans le cas d'une temporisation il est alors possible de choisir entre différent types de tempo (TD, TA, TE) ainsi qu'une durée (ici 3 secondes). Pour plus d'informations, se référer à la ...




part of the document



 


Collège :

Explication du programme











Introduction au programme VisiLogic :

Le logiciel VisiLogic permet de programmer les automates de la gamme Vision. Utilisant le langage Ladder, il est facile pour l’utilisateur d’obtenir un programme simple et efficace. Très répandu dans l’industrie, ce langage n’en reste pas moins facile à apprendre.

Pour bien commencer il est nécessaire de connaître quelques principes de bases :

L’environnement VisiLogic se compose de deux parties : la partie IHM pour Interface Homme Machine (écran, clavier, …) et la partie Ladder (le langage à proprement parlé). Ces deux parties, bien que complètement différentes, sont en permanence reliées. Une pression sur un bouton à tel écran sera traitée dans telle partie du programme Ladder. Une variable qui
prend telle valeur dans le programme sera affichée à tel écran.

Le programme Ladder se lit de gauche à droite puis de haut en bas. Il est divisé en segments (ou net). Lorsque l’automate va fonctionner, il va d’abord exécuter le segment 1 (de gauche à droite), puis, une fois qu’il a fini, va passer au segment 2 (de haut en bas).

Le langage Ladder se représente sous la forme de blocs interconnectés. Ainsi l’utilisateur n’aura qu’à placer les blocs adéquats puis les relier entre eux pour obtenir un programme fonctionnel. A aucun moment il n’est nécessaire de taper des lignes de code.

Il est possible de structurer son programme grâce aux sous routines. Plutôt que de mettre tout le programme dans une seule et même routine, il est possible de le fractionner et le rendre ainsi plus lisible.

L’automate fonctionne par cycle qu’il va réaliser périodiquement. Lorsqu’il commence son cycle, l’automate va lire le segment 1 et va y interpréter les blocs. Une fois qu’il a fini il met à jour les données qui ont été modifié puis passe au segment suivant et ainsi de suite. Une fois que tout les segments ont été exécuté (on arrive donc à la fin du programme), l’automate recommence revient au début du programme et attends le commencement d’un nouveau cycle pour exécuter à nouveau le programme.


Main Routine : routine principale


Lors de l’exécution du programme, cette routine sera la première à être appelée. C’est la routine de référence pour l’automate.

Dans cette routine on va placer tout ce qui est « général » pour le programme. C’est à dire tout ce que l’on est susceptible d’utiliser en permanence. On va donc initialiser l’automate.



Les blocs représentés si dessus permettent d’effectuer des sauts vers une sous routine spécifique. Plus on en met plus il est possible d’appeler de sous routine. Ainsi lorsque le programme va s’exécuter et qu’il va rencontrer l’un des blocs suivant, il va effectuer un saut à la sous routine correspondante.




On utilise cette structure pour structurer au maximum le programme. Il est tout à fait possible de placer des fonctions réalisant d’autres actions que le saut à une sous routine spécifique.

Lorsque l’automate rencontre une instruction de saut, il va aller chercher le bout de programme correspondant (ici la sous routine) et va l’exécuter tant que la condition devant le bloc de saut est valide. Dans la Main Routine, il n’y a pas de condition devant les blocs de saut. Cela signifie que la sous routine est exécutée en permanence.

Tout programme contient une Main Routine. Elle peut être appelée différemment mais l’utilisateur qui regarde le programme (ou le programmeur) doit toujours avoir en tête quelle routine est exécutée en premier. Il est donc conseiller de garder le nom de Main Routine ou d’utiliser un nom équivoque.





























Plan du programme : affichage.


Schéma du programme :




Les blocs Sous Routine correspondent aux sous routines du même nom dans le programme Ladder. Les blocs Ecran correspondent aux différents affichages qui peuvent apparaître à l’écran.

Ainsi chaque écran va entrer en interaction avec la sous routine qui porte le même nom. Par exemple : les actions réalisables à l’écran volet seront traitées dans la sous routine volet.



Chronologiquement, les écrans apparaîtront dans cet ordre :


Page d’accueil (pendant une durée de 3 secondes)

Page menu (recensant l’état de chaque dispositif)

Page volet/Ventilation/Lampe/Chauffage/Alarme.


Il faut savoir qu’à tout moment, lorsqu’une des pages Volet / Ventilation / Lampe / Chauffage / Alarme est affichée, il est possible de retourner à la page menu en appuyant sur la touche ESC.

L’explication de la suite du programme se fera chronologiquement pour une meilleure compréhension.



























Page d’accueil :

Cette page sert de préambule au programme. Elle s’affiche pour une durée de 3 secondes et on peut y voir le nom du programme ou tout autre élément que l’on souhaite afficher :



La gestion de cette page s’effectue dans la sous routine page d’accueil. Il faut que cette sous routine soit capable d’effectuer une temporisation de 3 secondes (il est tout à fait possible d’utiliser une temporisation d’une durée différente) uniquement lorsque l’écran est affiché. Une fois la temporisation terminée, il faut que la sous routine affiche un autre écran.

Il faut donc prévoir l’utilisation :

D’une temporisation.
D’un bloc permettant d’effectuer des sauts d’écran.
D’un bloc permettant de repérer la page actuellement affichée.






Détection de la page affichée :

Le repérage de la page active s’effectue dans le premier segment du programme. Ce bloc IHM prends un paramètre et possède une sortie.

Le paramètre correspond à l’écran dont on veut savoir si il est actuellement affiché ou non. La sortie est le bit 0 placé à la position 0 dans la mémoire de l’automate (aussi appelé MB 0 pour memory bit 0) qui peut prendre deux états :

1 lorsque que la page d’accueil est affichée
0 lorsque que la page d’accueil n’est pas affichée.
Nous pouvons ainsi savoir quel écran est affiché et faire des actions spécifiques en conséquence. Dans ce programme, on veut que la temporisation se déclenche lorsque que la page d’accueil s’affiche. Il est donc nécessaire d’imposer une condition au déclenchement de la temporisation. Nous allons donc utiliser MB 0 pour éviter de déclencher la temporisation au mauvais moment.

Pour cela on utilise un contact direct qui est représenté par le bloc :



Pour le configurer il suffit de double cliquer dessus puis de choisir à quel MB il sera sensible (attention le contact direct ne marche que pour des bits). Son utilisation est simple : si MB 0 = 1 alors on exécute la suite de la ligne (tout ce qui est à droite du bloc). Sinon (MB 0 = 0) on n’exécute rien.

Nous avons donc notre condition. Il suffit maintenant de lancer la temporisation. Pour cela nous allons utiliser une bobine. Contraire à un contact (qui sert à tester l’état d’un bit), la bobine sert à changer l’état d’un bit :




Nous avons ici une bobine directe. C’est à dire que tant que la condition placée juste avant est vraie, alors le bit auquel est reliée la bobine sera à 1. Si la condition n’est plus vraie alors le bit passe à 0.

La bobine est configurable en double cliquant dessus :


Il est alors possible de choisir sur quel type de bit et sur quel bit en particulier la bobine aura un effet (T pour temporisation et 0 pour la temporisation 0).

Dans le cas d’une temporisation il est alors possible de choisir entre différent types de tempo (TD, TA, TE) ainsi qu’une durée (ici 3 secondes).
Pour plus d’informations, se référer à la documentation relative aux temporisations.

On choisit une temporisation TD (on Delay = en retard) qui reste à zéro après avoir été activé puis passe à 1 quand elle a fini de compter.

Dans cette situation, quand la bobine s’active, le bit auquel elle est reliée devrai passer à 1, mais dans ce cas précis, lorsque la temporisation est activée, elle ne passe pas tout de suite à 1 mais attend 3 secondes avant d’effectuer le changement d’état. C’est là que réside la particularité des temporisations. Il en existe deux autres types mais nous ne verrons pas leur fonctionnement dans ce programme.

Nous avons jusqu’à présent résolu une partie du problème. Nous avons une temporisation qui se déclenche uniquement lorsque l’écran page d’accueil est affiché. Une fois activée, elle attend trois secondes avant de passer à 1. On peut ainsi retarder l’exécution d’un autre segment.

Nous allons réutiliser un contact :



On remarque un P qui le différencie du précédent contact. Nous avons ici un contact sur front montant.

Explication :

Un signal binaire possède deux états. Quand il est à 1 ou quand il est à 0. Cependant pour passer d’un état à un autre, il doit y avoir une étape de transition. C’est ce que l’on appel les fronts : montant lorsque l’on passe de 0 à 1 et descendant lorsque l’on passe de 1 à 0. Les automates Vision permettent d’utiliser cet état transitoire afin de limiter le nombre d’exécution d’un segment ou d’un bloc en particulier.

En effet, l’automate fonctionne sous forme de cycle. A chaque cycle tous les segments seront exécutés. Ainsi si on avait gardé un contact direct, le segment aurait été exécuté en permanence. Dans certains cas cela peut s’avérer nécessaire mais dans ce programme cela pourrait s’avérer néfaste.

Il nous reste donc plus qu’à effectuer un saut à l’écran désiré :



Ce bloc IHM prends un paramètre (l’écran à afficher) mais ne possède aucune sortie. Ainsi lorsque les conditions placées juste avant le bloc seront vraie, alors on pourra effectuer un saut à la page IHM désirée.


Nous venons donc de résoudre le premier problème. L’écran de page d’accueil s’affiche bien pendant trois secondes avant d’afficher un autre écran. Il est tout à fait possible de modifier les valeurs de temporisation, les MB ou encore ce qui sera affiché à l’écran. D’autre solution sont possibles et celle qui est présentée ici n’est en rien la meilleure. Elle fonctionne mais il existe d’autres moyens de parvenir au même résultat.





















Page Menu :

Nous allons maintenant voir le fonctionnement du menu et comment il a été programmé. Avant de commencer l’explication nous allons d’abord voir ce qu’il fait :

Une pression sur la touche alarme et on affiche la page alarme.
Une pression sur la touche chauffage et on affiche la page chauffage.
Une pression sur la touche ventilation et on affiche la page ventilation.
Une pression sur la touche lampe et on affiche la page lampe.
Une pression sur la touche ouverture volet ou fermeture volet et on affiche la page volet.
A tout moment, une pression sur la touche ESC (echap) et on revient au menu.

De plus, la page IHM menu devra afficher un récapitulatif de l’état de chaque dispositif vu plus haut :

Un rond plein indiquera que le système est actuellement en fonctionnement.


A l’inverse un rond vide indique qu’il ne fonctionne pas.



Pour le volet, trois états sont possibles : le volet est ouvert/fermé/entre ouvert.

Il est donc nécessaire de prévoir un programme capable de gérer les boutons du clavier et d’afficher une page IHM en conséquence. Il doit posséder aussi une page IHM menu qui sera capable d’afficher des informations propre au programme Ladder.

Dans un premier temps nous verrons la gestion des boutons. Le fonctionnement de la page IHM menu sera étudié une fois que chaque dispositif (lampe, chauffage, …) sera mis en place car les éléments à afficher dépendent de l’état des différents dispositifs.




Page Menu : gestion des boutons.


L’automate possède en façade plusieurs boutons. Ils sont tous utilisables de la même façon et peuvent être configurés dans la partie Ladder de VisiLogic. De plus chaque bouton possède un bit système (SB) qui lui est propre. Un bit système est un bit interne de l’automate que l’utilisateur ne peut pas modifier (sauf exception). Ils donnent ainsi des informations sur l’automate, l’état de chaque bouton (enfoncé ou relâché) ou différents outils nécessaire à la programmation.

Le plastron en façade possède en tout 16 boutons :



Chacun est relié à son propre SB. Lorsqu’un bouton est relâché, le SB qui lui correspond vaut 0. Quand il est enfoncé, alors le SB vaut 1. Ainsi grâce à des contacts, il est possible d’exploiter l’état d’un bouton. Dans ce programme, tous les boutons ne sont pas utilisés. Seul ceux qui portent le numéro 2, 3, 4, 5, 7, 8 et ESC le sont.







Pour paramétrer un contact, il n’est pas nécessaire de connaître quel SB correspond à quel bouton, il suffit d’utiliser la fonction spéciale qui est dédiée au boutons :




Une image de l’automate s’affiche alors et il ne reste plus qu’à cliquer sur le bouton désiré. Le programme VisiLogic s’occupera de choisir le SB correspondant :



Le plastron affiché n’est pas le même mais les boutons sont aux mêmes endroits et la correspondance avec les SB reste identique.








Nous allons maintenant voir comment gérer les boutons dans le programme Ladder.

Lorsqu’un bouton est activé par l’utilisateur (il appuie dessus), l’automate doit changer de page à afficher. Il faut donc prévoir :

Un contact pour gérer le bouton
Un bloc permettant d’effectuer un saut de page
Une deuxième condition pour éviter les sauts de page excédentaire.

Premièrement le contact doit se faire sur un front montant sinon plusieurs sauts seront exécutés. La conséquence sera un affichage qui aura tendance à scintiller tant que le bouton sera enfoncé.

Ensuite, il faut imposer une autre condition pour le saut de page. En effet, il n’est pas nécessaire d’effectuer de saut vers une page qui est déjà affichée. Pour cela, on va utiliser la même technique que pour la page d’accueil à savoir le repérage de la page active.
Ce bloc est placé dans la sous routine correspondant à la page que l’on veut afficher. Il n’est pas présent dans la sous routine menu mais cela ne dérange pas le déroulement du programme tant que cette sous routine est appelée.
Un contact inversé permet de savoir si un bit est à 0. Si c’est le cas la condition est vraie et on exécute ce qui est placé à droite du bloc. Si la condition est fausse alors on n’exécute rien. Ce contact est relié au bit permettant de savoir si la page que l’on veut affichée est déjà à l’écran ou non. On évite ainsi le scintillement de l’écran.

Finalement, on place le bloc permettant d’effectuer un saut à la page IHM et la gestion du bouton se fera complètement.

L’exemple si dessous sert pour le bouton ESC. Lorsque l’on n’est pas à la page menu et que l’on appuie sur le bouton ESC alors on affiche la page menu :








Les autres boutons sont gérés de la même façon sauf pour le volet. En effet, deux boutons servent à actionner le volet (un pour la monté et un pour la descente). Il faut donc une structure en OU pour gérer complètement le volet : si le bouton de monté OU le bouton de descente du volet sont activés, alors on effectue un saut à la page volet :




Nous avons maintenant un menu fonctionnel qui effectue les sauts vers les pages correspondantes aux boutons sur lesquels l’utilisateur est susceptible d’appuyer.

Nous allons donc pouvoir étudier les différents dispositifs :

Alarme
Chauffage
Lampe
Ventilation
Volet.

Bien que relativement proche de par leur fonctionnement, certains de ces dispositifs intègre en plus un affichage spécialisé qui nécessite quelques actions supplémentaires en Ladder.

Nous allons commencer par la Lampe qui est le plus simple et qui intègre déjà quelques particularités au niveau de l’affichage.









Page Lampe : gestion des boutons et de l’affichage.

L’affichage de la page se présente de la façon suivante :







On remarque qu’il y a deux possibilités pour l’ampoule : allumée ou éteinte. De même pour le dessin juste à côté, deux images peuvent être affichée représentant soit une ampoule éteinte soit une ampoule allumée.

L’idéal serait que le texte et l’image soient modifiés en même temps et que cela se fasse de façon autonome. Le programme VisiLogic intègre une fonctionnalité qui permet entre autre d’affiché du texte ou une image en fonction de la valeur d’un bit ou d’un entier. Ainsi dans le programme Ladder on pourrait modifier une valeur selon les actions effectuées par l’utilisateur et on observerait les modifications à l’écran.

Pour la lampe, deux états seulement sont possibles il est donc logique d’utiliser un bit pour gérer l’affichage.


Les outils graphiques pour ce genre d’opération sont : Binary text et Binary image :




















Binary text :



Pour configurer du Binary text (texte binaire), il suffit de choisir le bit auquel sera relié le texte (ici MB 41) et d’indiquer dans les champs correspondant quel sera le texte à afficher quand MB 41 = 0 et MB 41 = 1. Il est aussi possible de choisir une police différente de celle par défaut.

Binary image :




Pour configurer une Binary image (image binaire), le procédé est quasiment identique que pour du Binary text. On indique le bit auquel sera relié l’image (ici MB 41 qui est le même que pour le texte) et on choisi l’image à afficher quand MB 41 = 0 et MB 41 = 1 avec le bouton Browse. Le programme VisiLogic va alors automatiquement redimensionner l’image en fonction de la taille du cadre (que l’utilisateur peut bouger ou redimensionner en fonction de ses besoins).

Le reste du texte affiché est fixe et ne sera pas modifié selon l’état du bit MB 41.

Nous allons voir maintenant comment fonctionne le programme Ladder afin d’effectuer correctement la transition entre l’ampoule allumée et l’ampoule éteinte.

Pour que le programme fonctionne correctement il faut prévoir :

Un contact permettant de tester l’état du bouton
Une bobine permettant de modifier l’état de MB 41
Une bobine permettant de modifier l’état de la sortie O 3 (output 3) qui ira allumer un voyant sur le pupitre.
Une condition évitant l’allumage ou l’extinction de la lampe lorsque cela n’est pas désiré.
Il ne faut pas oublier le repérage de la page active nécessaire au fonctionnement de la sous routine menu.

Nous ne reviendrons pas sur le repérage de la page active. Il est juste nécessaire de savoir que le bit utilisé est MB 40. Ainsi si MB 40 = 1 alors la page Lampe est affichée. Si MB 40 = 0 alors une autre page est affichée.

Ce bit MB 40 va non seulement servir à la sous routine menu mais il va aussi servir de condition pour toutes les actions relatives à l’allumage et l’extinction de la Lampe. Ainsi un simple contact direct fera l’affaire :



Lorsque l’utilisateur appuie une première fois sur le bouton, la Lampe va s’allumer. Pour l’éteindre l’utilisateur va appuyer une nouvelle fois sur le bouton. Pour gérer cela, il y a plusieurs possibilités :

A chaque pression, on vérifie l’état de la lampe et, en conséquence, on allume ou on éteint la lampe. La fois d’après, il faudra à nouveau vérifier l’état de la lampe et faire l’action inverse.
On utilise une bascule qui changera l’état du bit à chaque pression sur le bouton.



La deuxième solution est beaucoup plus simple et utilise moins de blocs pour la mise en œuvre. Quant à la première solution elle est tout à fait réalisable mais nécessite l’utilisation d’un MB supplémentaire et est plus difficile à comprendre.

L’utilisation d’une bascule est donc très bien adaptée dans ce cas. Ce bloc est en fait une bobine spéciale appelée Télérupteur ou Toggle et se représente sous la forme suivante :



Lorsque ce bloc va être activé (la condition le précédant est vraie), le bit MB 41 va « basculer ». C’est à dire que si il était à 0 alors il va passer à 1 et vis versa. Ainsi, lorsque l’utilisateur va appuyer sur le bouton de la Lampe, celle-ci va s’allumer ou s’éteindre. Le segment permettant de gérer complètement la Lampe est le suivant :



MB 40 s’active quand l’écran est affiché, SB 44 correspond au bouton de la Lampe et MB 41 est le bit d’état de la Lampe (MB 41 : allumé =1/éteint =0).
Pour finir la gestion de la lampe, il faut aussi que la sortie O 3 s’active lorsque la lampe est allumée. On utilise donc un contact relié à MB 41 et une bobine direct :



L’affichage devrait s’effectuer correctement car le texte Binaire et l’image Binaire sont reliés à MB 41.






Page Chauffage : gestion des boutons et de l’affichage.


Le dispositif de chauffage se comportant de la même façon, il n’est pas nécessaire de voir son fonctionnement. Il suffit juste de changer les MB pour les outils graphiques ainsi que la sortie :

MB 50 pour le repérage de la page active
MB 51 pour l’activation du chauffage
Output 4 (O 4) pour l’allumage du témoin.























Page Alarme : gestion des boutons et de l’affichage.


Le prochain dispositif à voir est l’alarme. Contrairement à la Lampe et au Chauffage, il est nécessaire de faire clignoter le témoin comme le ferai une alarme normale. Une fois de plus, plusieurs solutions sont possibles :

On utilise une temporisation d’une seconde pour faire clignoter l’alarme. Il faudra déclencher la tempo, mettre une condition de fin de temporisation et remettre celle-ci à zéro.
On utilise une pulsation de l’automate.

Il est nécessaire de savoir que les SB (system bit) de l’automate sont utile pour connaître l’état des boutons mais qu’ils peuvent en plus servir d’outils et d’aide pour la programmation. En effet, certains SB servent de pulsations de fréquences différentes. La pulsation est un signal carré dont la période est de 100 millisecondes ou 1 seconde. Il n’en existe que deux mais elles sont très largement utilisées.

Pour récupérer cette pulsation, un simple contact sur front suffit (montant ou descendant). La condition sera alors vraie UNE SEULE fois toutes les secondes. Il est possible de créer sa propre pulsation avec la valeur que l’on veut mais nous verrons cette possibilité plus tard.




















Nous allons voir la partie graphique de la page Alarme :



 


La présentation de l’affichage de l’Alarme est similaire à celle de la Lampe et du chauffage. La différence vient du fait que l’image de l’alarme n’est pas reliée au même bit que le texte. Cela est du au fait que lorsque l’alarme est active, le témoin de fonctionnement va clignoter tout comme l’alarme qui est dessinée sur l’écran. Par soucie de simplicité l’image est directement reliée à la sortie Output 5. Ainsi dans notre programme Ladder il sera juste nécessaire de faire basculer Output 5 afin de faire clignoter le témoin et le dessin de l’alarme.

Le texte est relié à MB 61 et il sera donc nécessaire de prévoir un bout de programme afin de modifier cette valeur. Il faut donc prévoir :

Un système permettant de mettre en fonctionnement et d’éteindre l’alarme.
Un deuxième système permettant de faire clignoter le témoin et l’image tout en restant sous le contrôle du premier système.







Le premier système que l’on va mettre en œuvre sera celui de la mise en fonctionnement/arrêt de l’alarme. Il reprend le même principe que les autres dispositifs avec le repérage de la page active et le contact sur front montant du bouton. Ce système fonctionne parfaitement et nous allons maintenant voir comment l’utiliser pour contrôler le clignotement du témoin.



Le deuxième système est différent de ce que l’on a pu voir jusqu’à présent. En effet, il se divise en deux branches après une condition. Cette particularité permet de n’utiliser qu’un seul segment et une seule condition pour ensuite pouvoir exécuter deux fonctions différentes chacune étant soumise à une autre condition.



Pour simplifier l’étude de ce cas, on va le séparer en deux segments distincts. Le fonctionnement est le même mais la présentation est différente :



Ce premier segment ressemble à tout ce que l’on a pu voir jusqu’à présent sauf que la deuxième condition n’est ni un bouton ni un MB. On utilise ici le SB 3 qui est une pulsation de 1 seconde. Comme expliqué précédemment, une pulsation est signal carré qui a une période de 1 seconde. Dans ce cas précis tant que MB 61 est actif (=1) et une fois toutes les secondes, on bascule l’état du bit MB 62.

On aura donc le bit MB 62 qui sera à 1 pendant une seconde puis à 0 pendant une seconde puis à nouveau à 1 pendant une seconde et ainsi de suite.



Pour ce deuxième segment, il ne faut pas utiliser de bascule car tous les contacts sont directs. Il faut donc mettre une bobine direct pour éviter d’avoir des changements d’états intempestifs. On peut donc interpréter cette ligne : tant que MB 61 est actif et tant que MB 62 est actif alors Output 5 est actif. Si une seule des deux conditions n’est plus vraie alors la bobine de Output 5 est inactive.

Le fait d’avoir rassembler ces deux segments en un seul n’influera pas sur le fonctionnement de l’automate.





























Page Ventilation : gestion des boutons et de l’affichage.

Nous venons de voir l’utilisation de texte binaire et d’image binaire. Il existe cependant le moyen d’aller beaucoup plus loin dans le nombre d’image. Jusqu’à présent, deux images étaient suffisantes pour afficher deux états différents. Mais lorsque l’on veut indiquer qu’une action est en cours, il est préférable d’avoir recours à une animation. Le Vision 120 ne possède pas de lecteur vidéo ou de carte de calcul 3D mais il est possible d’afficher quelques animations prédéterminées.

On utilise pour cela le texte par pointeur et les images par pointeur :











Cette technique permet d’afficher quelques animations sommaires comme une porte qui s’ouvre ou un moteur qui tourne. Pour un Vision 120 l’utilisation de 2 à 3 images par secondes est amplement suffisante pour décrire un mouvement simple comme la rotation d’un ventilateur.

La fonction d’image par pointeur nécessite quelques connaissances avant de commencer.

En informatique, un pointeur est une variable qui contient une adresse. Par exemple : l’image d’un arbre est stockée à l’adresse 1. L’image d’un ballon est stockée à l’adresse 2. Le pointeur a pour valeur l’adresse 1. Si l’on décide d’afficher à l’écran l’image dont l’adresse est contenue dans le pointeur, alors l’image d’un arbre va s’afficher. Maintenant l’utilisateur change la valeur du pointeur et rajoute 1 à l’ancienne valeur. On obtient donc un pointeur qui contient l’adresse 2 et l’image de l’arbre est remplacée par celle du ballon.

Le principe de pointeur est souvent utilisé en informatique. Il est donc nécessaire de bien le comprendre.

Maintenant configurons notre image par pointeur :



Tout d’abord, il faut choisir notre pointeur. Il se configure dans le champ Link. Il est obligatoire d’utiliser une variable numérique et non binaire comme un MI, un ML (memory long), un SI (system integer) ou un SL (system long). Ainsi l’image qui sera affichée à l’écran dépendra de la valeur du pointeur.



Il faut ensuite choisir les images à afficher. Dans un premier temps, on va choisir l’image que l’on veut afficher quand MI 30 vaut 0. On clique sur browse et on choisit le fichier image souhaité puis on clique sur « append ». On remarque dans le champ de gauche que l’image sélectionnée apparaît avec la valeur 0. Si on recommence, la nouvelle image apparaîtra avec le numéro 1 puis 2 et ainsi de suite.

Nous retrouvons donc nos images à l’adresse 0, 1, 2 et 3. La modification de la valeur de MI 30 permettra de faire défiler les images que l’on a choisi. Si MI 30 vaut 0 alors on verra l’image 0, si il vaut 1 on verra l’image 1 et ainsi de suite.

Si MI 30 prends la valeur 10 alors aucune image ne sera affichée car aucune ne porte ce numéro. Il n’est pas nécessaire de configurer des images jusqu’au maximum possible, il faudra juste faire attention dans le programme à ce que la valeur de MI 30 ne dépasse pas 3.

Le texte affiché à côté reste du texte binaire dont on connaît déjà le fonctionnement.
























Nous venons de voir la partie graphique. La partie Ladder devra donc comporter :

Un système pour gérer l’allumage/l’extinction de la ventilation
Un système pour changer la valeur du pointeur
Un système permettant de contrôler les valeurs du pointeur (plus grand que 0 et plus petit que 3).


Tout comme les autres dispositifs, il est nécessaire d’avoir un repérage de la page active afin de faire fonctionner le menu. MB 30 servira donc au repérage.

De même on intègre une ligne permettant d’activer/désactiver la ventilation :



Il est similaire à ce que nous avons utilisé jusqu’à présent. MB 31 est donc le bit qui indique le fonctionnement de la ventilation.

Nous avons évoqué précédemment le fait que deux images par secondes était un taux de rafraîchissement suffisant pour une animation. Ce qui veut dire que toutes les 500 millisecondes une nouvelle image doit s’afficher. Il n’existe pas de pulsation de 500 ms mais il est possible d’en créer une. Pour cela on utilise la technique suivante :



On place ces quatre blocs dans un segment et l’on dispose alors d’une pulsation dont on peut régler la période. Il suffit pour ça de changer la valeur de la temporisation. Cette ligne peut se lire : si TD 1 n’est pas à 1 alors on active TD 1 (commence à décompter). Une fois qu’il a fini de décompter TD 1 s’active. Si TD 1 est actif alors on le remet à zéro. La ligne recommence alors depuis le début.




Si on veut utiliser cette pulsation dans notre programme, il suffit de placer un contact sur front montant de TD 1 :



Il faut maintenant gérer le défilement des images. Pour cela il faut agir sur le pointeur MI 30 en l’incrémentant à chaque front montant de la pulsation :



Le bloc INC est le bloc d’incrémentation de VisiLogic. C’est une fonction mathématique qui, à chaque fois qu’elle est activée, rajoute 1 à la valeur du MI auquel elle est associée. Ainsi à chaque front montant de TD 1 et si MB 31 vaut 1 alors on incrémente MI 30.

Grâce à ce bout de programme, il est possible de changer d’image. Mais lorsque MI 30 aura une valeur supérieure à 3, plus aucune image ne sera affichée. Il faut donc prévoir un système pour empêcher le « débordement ». Pour cela il faut utiliser des blocs de comparaison et de stockage :




Dans un premier temps, le bloc de comparaison sert de condition : tant que MI 30 n’est pas supérieur à 3, alors la condition n’est pas vraie et on n’exécute pas ce qui se trouve à droite. Pour le configurer il faut donner une valeur pour A et pour B. Il s’occupe de faire la comparaison SI A>B.


Si la valeur de MI 30 est supérieure à 3 alors la condition est vraie et la suite du programme peut être exécutée. On va alors stocker la valeur 3 dans MI 30, c’est à dire que quelque soit la valeur de MI 30 on va lui imposer une nouvelle valeur.

Cela a pour effet d’afficher la première image à l’écran. Le programme recommence ainsi à incrémenter la valeur de MI 30 et à faire défiler les images à l’écran.

Dans le programme, l’image par pointeur possède 4 images. Il est donc possible d’afficher 4 images différentes en tout. Dans notre cas, l’animation finale ne possède que deux images différentes mais il est possible de les retravailler afin d’obtenir une animation plus précise. Il est aussi possible de changer la valeur de la pulsation pour obtenir une animation plus fluide.


Pour finir la programmation de la ventilation, il faut que la sortie Output 2 s’active lorsque la ventilation est en marche :





Pour finir il ne reste plus que la gestion du volet et la programmation des différents dispositifs sera terminée.
















Page Volet : gestion des boutons et de l’affichage.

La page Volet est peut être la plus difficile à comprendre car elle intègre toutes les fonctionnalités que l’on a vu précédemment. Elle intègre notamment un outil graphique dont on a dérivé la fonction principale.

Afin de simuler l’ouverture ou la fermeture du volet, une animation aurait été idéale. Néanmoins, l’utilisation d’un BarGraph est plus judicieuse et permet une meilleure lisibilité. Normalement utilisé pour représenté un pourcentage sous forme de barre plus ou moins remplie (représentation du taux de remplissage d’une cuve ou la puissance d’un moteur), il sert ici donner des indications sur la position du volet :



Pour configurer un BarGraph, il faut lui donner une valeur minimale et une valeur maximale. Il faut aussi l’orienter pour savoir dans quelle direction il va se remplir. Finalement, il faut indiquer à quel MI il sera relié. Une fois le BarGraph configuré, il se remplira plus ou moins en fonction de la valeur du MI auquel il est relié.

Le BarGraph étant orienté vers le bas pour mieux simuler l’ouverture et la fermeture, l’incrémentation correspond à la fermeture et la décrémentation correspond à l’ouverture. Il a pour valeur minimale 0, pour valeur maximale 50 et est relié à MI 20.

Lorsque l’utilisateur va appuyer sur bouton de descente du volet, il va falloir incrémenter MI 20 pour que le BarGraph à l’écran se remplisse. A l’inverse, lorsque l’utilisateur va appuyer sur le bouton de monté du volet, il va falloir décrémenter MI 20 pour que le BarGraph se vide.

Si l’utilisateur arrête d’appuyer sur un des deux boutons, alors le BarGraph garde sa position et la valeur de MI 20 reste inchangée.

Il faut aussi prévoir un système évitant le dépassement de MI 20 qui doit être supérieur ou égal à 0 et inférieur ou égal à 50.

Finalement il faut que la sortie Output 0 soit active uniquement lorsque le volet est en train de se fermer et que la sortie Output 1 soit active uniquement lorsque le volet est en train de s’ouvrir.

Il ne faut pas oublier le repérage de la page active pour la sous routine menu. MB 20 sera utilisé pour le repérage.


Nous allons dans un premier temps voir comment incrémenter et décrémenter la valeur de MI 20. Pour changer la valeur de MI 20 à la bonne vitesse, il est nécessaire d’utiliser une pulsation. De 0 à 50, il y a 51 valeurs. Ainsi l’ouverture (et la fermeture) du volet doit s’opérer à une vitesse raisonnable pour permettre à l’utilisateur de bien observer l’ouverture sans pour autant que ce soit trop rapide ou trop lent.

Une pulsation de 100 Ms permet une ouverture complète en 5 secondes. C’est donc un choix judicieux et cela permet de ne pas créer de temporisation.

L’ouverture ne peut se faire que quand la page volet est affichée et que quand l’utilisateur appuie sur le bouton d’ouverture. Dans ces conditions, la valeur de MI 20 sera incrémentée ou décrémentée toutes les 100 Ms :



Nous avons ici le segment permettant l’ouverture du volet. On utilise directement SB 7 pour la pulsation de 100 Ms. A chaque front, et si l’utilisateur appuie sur la touche d’ouverture, alors toutes les 100 Ms MI 20 sera incrémenté.











De même pour la fermeture :



Cette fois ci, MI 20 est incrémenté toutes les 100 Ms lorsque l’utilisateur appuie sur le bouton de fermeture.

Il faut maintenant s’occuper du problème du débordement. En effet, lorsque MI 20 dépasse la valeur 50, alors le BarGraph reste plein mais la valeur de MI 20 continue de s’incrémenter. Ainsi lorsque l’utilisateur voudra fermer le volet, il faudra atteindre que la valeur repasse en dessous de 50 avant de pouvoir observer un changement à l’écran.

Contrairement à l’animation réalisée pour la ventilation, ici il faut faire attention à ce que la valeur de MI 20 soit contenue entre deux valeurs :

Au minimum 0
Au maximum 50.

Il faut donc prévoir un segment pour la valeur minimum et un segment pour la valeur maximum :




La structure utilisée est la même que pour le ventilateur. Il faut juste modifier les valeurs et l’un des blocs de comparaison.

Il ne manque plus que la gestion des sorties :

Lorsque le volet est en ouverture, Output 1 s’active.
Lorsque le volet est en fermeture, Output 0 s’active.

Il faut faire attention à ce que les sorties ne s’activent que lorsque l’utilisateur est en train d’appuyer sur un des deux boutons ouverture/fermeture et qu’il n’y a pas eu de dépassement pour MI 20. On va pour cela utiliser d’autres blocs de comparaison que l’on va coupler avec des contacts :




Ainsi, lorsque MI 20 aura atteint les valeurs extrêmes 0 ou 50, la sortie va se désactiver car le volet aura fini sa monté ou sa descente.


Il reste un dernier élément à traiter afin de pouvoir compléter le programme de la page volet. En effet, à l’écran volet, du texte indique quel est le statut du volet : Ouvert/fermé/entre ouvert.



On utilise pour cette description l’outil graphique texte by range :



Cet outil permet de définir un texte à afficher selon une plage de valeur. Ainsi pour configurer du texte by range, il faut avant tout définir une valeur (un MI par exemple) que l’on fera varier pour pouvoir faire défiler les différentes plages de valeurs.

Il faut ensuite définir les plages de valeurs :

Un début
Une fin
Un texte à afficher et la police utilisée.




Pour rajouter une nouvelle plage de valeurs, il faut appuyer sur le bouton Append :




Il faut faire attention à ce que deux plages de valeurs ne se superposent pas. Il n’est en revanche pas nécessaire de prévoir de plage pour toutes les valeurs possibles de MI 20. Si la valeur de MI 20 ne correspond à aucune plage alors rien ne sera affiché dans la zone de texte.

Ainsi nous avons défini trois plages de valeurs possibles :

De -1 à 0 le volet est considéré comme ouvert
De 1 à 49 le volet est considéré comme entre ouvert
De 50 à 51 le volet est considéré comme fermé.

Il faut faire attention au fait que MI 20 peut prendre la valeur -1 ou 51 pendant un très petit laps de temps. Il est donc nécessaire de prendre en compte ce détail pour éviter de voir le texte disparaître pendant ce laps de temps.












Page Menu : gestion de l’affichage.

Tous les dispositifs sont maintenant fonctionnels et il ne reste plus qu’à finaliser l’affichage du menu pour terminer le programme.

Pour améliorer la visibilité et la compréhension il est nécessaire d’afficher l’état de chaque dispositif à la page menu :



Pour ce faire nous allons utiliser les même bits d’état ou les mêmes entiers que dans les sous routines :

MI 20 pour le texte by range du volet (identique à la page volet)
MB 31 pour la ventilation
MB 41 pour la lampe
MB 51 pour le chauffage
MB 61 pour l’alarme.

Il est ainsi possible d’indiquer quel est l’état de chaque dispositif sans pour autant avoir à créer d’autre segment dans la partie Ladder.










PAGE 


PAGE 9
Banc de test Domotique : explication du programme


 :