IPA04 – Tutoriel programmation: les boucles while et for.

Pages : 1 2

Tutoriel programmation: les boucles while et for.

Voici le quatrième chapitre de l’initiation à la programmation d’arduino. Après un premier aperçu du littéral acquis précédemment, vous allez découvrir comment rendre plus performant vos programmes grâce aux fonctions. Puis vous verrez (encore) un nouveau type de variable, les tableaux. Enfin  nous nous attaquerons au principal atout de la programmation en littéral, les boucles. Voici donc le chapitre tutoriel programmation boucle.

Note: si vous n’avez pas installé Codesys, le logiciel que nous utilisons pour nous exemple, voici le lien expliquant la procédure à faire: Lien pour télécharger et installer codesys.

Lien du chapitre précédent, du littéral au ladder:

Tutoriel du ladder au littéral

 

1er vidéo: Les fonctions

2e vidéo: Les boucles WHILE et FOR

 

Les fonctions.

Petit rappel sur les bibliothèques.

Les bibliothèques sont des ensembles de fonctions livrées « clé en main », permettant d’effectuer des actions sans se préoccuper de « comment est ce que cela est fait ».

Petit rappel du chapitre 2, lors de l’étude des fronts montants et descendants. Nous avions du importer une bibliothèque nommée « standard » pour avoir ces fonctions, et lors de leurs utilisations, nous ne nous sommes jamais demandé comment est ce que cela fonctionnait. Nous appliquions nos entrées, et nous récupérions notre sortie. Et bien voila la définition que l’on pourrai donner aux fonctions:

Créons notre première fonction.

Encore une fois un exemple sera bien plus parlant. Alors imaginez vous devoir faire un programme convertissant une température de degrés Fahrenheit en degrés Celsius.

Pour rappel la formule est:        [°C] = ([°F] – 32) x 5/9

Et ceci est à exécuter cinq fois (ou plus!).

Commencez par créer un programme en littéral sous codesys avec nommé PLC_PRG (le noms d’origine).

Puis, dans l’arborescence de gauche, faites un clique droit sur modules -> Insérer objet -> Type de l’unité:Fonction, type de retour:REAL, Langage de l’unité:ST, nom: conv_temp.

Création d'une fonction sous codesys

Création d’une fonction

Plusieurs choses à remarquer:

  • Dans l’arborescence, à coté de conv_temp, il est écrit FUN, alors que jusque là ce fût tout le temps PRG. Cela signifie que conv_temp est une fonction (FUNction), alors que pour l’instant nous n’avions fait que des programmes (PRG).
  • Dans l’écran de déclaration de variables, le noms de la fonction est précédé de FUNCTION, et juste aprés nous voyons REAL (équivalant à flottant, un nombre à virgule). Ceci indique le format du résultat que la fonction va renvoyer.
  • Enfin VAR_INPUT est la zone où nous spécifierons quelles variables « d’entrées » sont attendus.

Retournons à notre exemple, nous voulons récupérer une température la plus précise possible, donc un réel (ce qui a été fait lors de la création de la fonction; conv_temp:REAL).

Nous n’aurons qu’une seule entrée (VAR_INPUT) qui sera la température en degrés Fahrenheit.

Le contenu de notre fonction ne comportera aucune variable interne, l’opération effectuée n’utilisant que des nombres constants (à savoir 32 ; 5 et 9).

Programmons notre fonction.

Dans la zone de déclaration de variable, entre VAR_INPUT et END_VAR, déclarons notre entrée (la température en fahrenheit, que nous nomerons donc: fahrenheit) de telle sorte que l’on puisse y mettre un chiffre à virgule. Donc fahrenheit:REAL;Cela suffit pour nos déclaration, maintenant tapons le programme.

Le résultat retourné est stocké dans le noms de la fonction, donc ici conv_temp. Ce qui fait que notre fonction ne comportera qu’une seule ligne qui sera:

conv_temp:=(fahrenheit-32)*5/9;

Voilà notre fonction est créée!

Utilisons la fonction dans un programme.

Dans l’arborescence des programmes, cliquez deux fois sur PLC_PRG pour ouvrir sa fenêtre, car nous allons maintenant utiliser notre fonction.

Nous voulons donc convertir 5 températures, nous allons donc déclarer 5 températures en degrés Fahrenheit (degresfahrenheit1, degresfahrenheit2…) et la même choses pour nos températures récupérée en degrés Celsius (degrescelsius1, degrescelsius2…).

Puis créez vos 5 lignes de programmes, avec en entrée de fonction la température en Fahrenheit, et en sortie celle en Celsius.

Pour cela, commencez par le résultat, ex: degrescesius1:=

Puis appelez la fonction en tapant simplement son noms et en ouvrant les parenthèses, ce qui donne: degrescesius1:=conv_temp(

enfin renseignez la variable d’entrée de la fonction et refermez la parenthèse. degrescesius1:=conv_temp(degresfahrenheit1);

Répétez cela pour les 5 températures, et voyez le résultat:

Conversion de température sous codesys.

Conversion de température.

Pensez aux commentaires!!!

Voila comment vous pouvez effectuer cinq opérations compliquées de façons simple, grâce aux fonctions. D’un point de vue communautaire, l’intérêt est de pouvoir récupérer sur internet des fonctions crées par d’autres personnes afin d’effectuer des actions complexes sans vous soucier réellement de la façon dont cela est fait.

Le retour du télérupteur.

(A la fin de cette série de tutoriel je pense que vous deviendrez incollable sur le télérupteur!)

Je vous met au défie de réaliser une fonction permettant de réaliser un télérupteur. Ceci n’est pas facile, alors nous irons par étape.

  • Nous réaliserons d’abord un télérupteur en littéral.
  • Puis  nous l’adapterons pour qu’il devienne un fonction.
  • Enfin nous utiliserons cette fonction dans un programme.

Essayez tout d’abord d’imaginer par vous même comment réaliser un télérupteur en littéral.

Résumons le problème. A l’instant où l’on appuie sur un bouton, on inverse l’état d’une sortie. Nous aurons donc besoin d’une entrée, d’en extraire un front montant, et une sortie.

Les front en littéral.

L’exécution d’un front en littéral est un peu moins « naturel » qu’en ladder (petit rappel des fronts en ladder). Ici nous devons déclarer le front comme une variable à part entière, alors voyons:

  • Créez un programme en littéral (ST) nommé PLC_PRG.
  • Ajoutez la bibliothéque nommée standard via le gestionnaire de bibliothèque (petit rappel sur comment intégrer une bibliothèque).
  • Retournez dans le programme principal, faites un clic droit dans l’écran de déclaration des variables entre VAR et END_VAR, et sélectionnez déclarer automatiquement.
  • voici les paramètres à choisir: classe: VAR / Nom: frontEntree; /  Type: cliquez sur le bouton avec les 3 points, choisissez Bloc Fonctionnels Standard, dans le dossier trigger, cliquez deux fois sur R_TRIG; commentez et validez.
    Déclaration d'un front montant en littéral sous codesys

    Déclaration d’un front montant en littéral sous codesys

     

  • Toujours dans l’écran de déclaration des variables, déclarez une variable entree:BOOL et sortie:BOOL.
  • Enfin tapons notre programme:
Programmation d'un télérupteur en littéral sous codesys.

Programmation d’un télérupteur.

La ligne de programmation du front mérite quelques explications.

Lorsque vous allez dans le gestionnaire de bibliothèques et que vous sélectionnez le front montant, vous devriez voir cet écran:

Variables de la fonction R_TRIG sous codesys.

 

Nous observons, pour cette fonction, trois variables:

  1. Une variable d’entrée dans VAR_INPUT, nommée CLK et étant de type BOOL.
  2. Une variable de sortie dans VAR_OUTPUT, nommée Q et étant de type BOOL.
  3. Une variable interne dans VAR, nommée M et étant de type BOOL.

Nous considérerons cela comme une fonction, donc nous ne regarderons que les variables d’entrées et de sorties. Nous connaissons le but de cette fonction qui est de surveiller le moment où une entrée TOR passera de 0 à 1, et de passer sa sortie à 1 sur un seul cycle le moment venu.

Donc lorsque nous utiliserons cette fonction, nous savons que nous devrions affecter notre entrée à CLK, et que le résultat (le front) sera du même noms que celui déclarer dans l’écran de déclaration des variables suivi d’un .Q.

Maintenant vous devriez mieux comprendre la ligne:

frontEntree(CLK:=entree,Q=>);

Nous avons affecté entre à CLK, et après Q nous mettons => pour signifier que nous utiliserons le noms de la fonction comme front, c’est à dire frontEntree.Q

Le reste du programme est assez simple, vous pourrez d’ailleurs remarquer qu’il est bien plus facile d’effectuer un front en littéral qu’en ladder:

(* Programmation du télérupteur *)
IF frontEntree.Q THEN
sortie:= NOT sortie;
END_IF;

« Sur un front montant de l’entrée, j’inverse l’état de la sortie ».

Voila la façon d’effectuer un télérupteur en littéral! Pas mal non?

Transformer ce programme en fonction.

Alors maintenant essayons de faire de ce bout de programme une fonction. Voilà comment nous allons procéder:

  • Notre fonction nommée télérupteur ne recevra en paramètre d’entrée qu’un front et l’état actuel de la sortie.
  • Sur un front montant, on inversera l’état de la sortie, sinon, la sortie sera égale à l’état précédent.
  • Dans le programme principal, on créera le front (en ayant au préalable importé la bibliothèque standard).
  • L’entrée de notre fonction sera composée en premier du front, puis le la variable de sortie (de cette façon nous connaîtrons son état actuel).

Je pense que vous devriez être capable de faire cela seul, si ce n’est pas le cas suivez ce qui va suivre (mais essayez tout de même d’y penser un peu par vous même, cela sera très formateur).

Banniere du site automacile.fr

Image d’attente.

Création de la fonction télérupteur.

Après avoir créé un programme vierge avec un programme principal nommé PLC_PRG en ST, faites un clique droit sur modules dans l’arborescence/Insérer un objet. Dans noms vous marquez telerupteur, type de l’unité Fonction et langage de l’unité ST.

Dans l’arborescence cliquez deux fois sur telerupteur pour ouvrir la fonction.

Juste après VAR_INPUT, déclarez les variables entrée et etatActuel en booléen. Vous aurez donc:

entree:BOOL;

etatActuel:BOOL;

Puis dans la zone de programmation tapez le programme, qui sera:

IF entree THEN

     telerupteur:=NOT etatActuel;

ELSE

     telerupteur:=etatActuel;

END_IF;

Ce qui vous donnera:

Fonction télérupteur

Fonction télérupteur

Appelez votre fonction dans le programme.

Dans l’arborescence, ouvrez le programme PLC_PRG.

  • Déclarez 2 fronts montant nommés front1 et front2.
  • Déclarez quatre variables booléennes nommées entree1, entree2, sortie1, sortie2.

Et votre programme en fera que quatre lignes:

(* Premier télérupteur *)

front1(CLK:=entree1,Q=>);

sortie1:=telerupteur(front1.Q,sortie1);

(* Deuxième télérupteur *)

front2(CLK:=entree2,Q=>);

sortie2:=telerupteur(front2.Q,sortie2);

Testez et savourez le résultat!

Utilisation de la fonction telerupteur

Utilisation de la fonction

 

 

Pages : 1 2

Pages : 1 2

Pages : 1 2