IPA04 – Tutoriel programmation: les boucles while et for.

Pages : 1 2

Un nouveau type de variables: les tableaux.

Partons d’un constat. Imaginez que vous faites l’acquisition de la température des 10 pièces de votre maison. Votre idée sera donc de créer 10 variables, maintenant si vous souhaitez mettre 10 capteurs par pièce, allez vous créer 100 variables? Et bien une solution existe pour simplifier cela, les tableaux.

Un tableau peut se présenter comme un regroupement de plusieurs variables (que l’on appel éléments).

Un tableau à 7 éléments.

Un tableau à 7 éléments. (wikipedia)

Regardez le tableau à 7 éléments ci dessus que nous appellerons Valeur, et imaginez qu’à l’intérieur soit stocké la température de 7 pièces différentes. Nous savons qu’à la première place (l’élément (ou index) 0) se trouve le salon, puis la salle à manger (élément (ou index) 1), puis la cuisine (élément (ou index) 2), puis la salle de bain (élément (ou index) 3)…

Note: Sachez qu’en programmation, on commence souvent par 0, non pas par 1. Ce qui fait que lorsque que l’on parle, par exemple, d’un tableau à 7 éléments, il ne faut pas être surprit de voir que celui ci se termine par 6 (et non pas par 7).

Si je désire connaitre la température de la cuisine, je fais Valeur[2]. La valeur entre crochet correspondant à la « position » (ou élément ou index) à laquelle se trouve la variable qui nous intéresse.

Utiliser un tableau sous Codesys.

Dans l’écran de déclaration des variables, faites un clique droit / Déclarer automatiquement. Dans la classe, laissez toujours VAR, le Nom mettez temperature, dans type, cliquez sur le bouton avec les trois petits points, et dans types standard, choisissez ARRAY.

Un écran nommé Limites du tableau s’affichera. Pour l’instant nous ne faisons que des tableaux à 1 dimension, donc à droite du 1, dans Démarrage, mettez 0 et dans Fin mettez 9. En dessous, dans le type, choisissez INT (car nos températures seront comprises entre -32768 et + 32767, du moins je l’espère). Commentez et validez.

Déclaration d'un tableau sous codesys

Déclaration d’un tableau

Voilà votre tableau déclaré. Maintenant vous allez faire un morceau de programme qui va initialiser votre tableau avec des températures positive et négative. Puis vous les regarderez une par une, et à chaque fois qu’il y en aura une négative, vous incrémenterez un compteur. Ainsi ce compteur indiquera le nombre de pièces dans lesquelles la température est négative.

Detection de temperatures negative sous codesys

 

Note: Ne soyez pas étonné de voir les IF sur la même ligne, cela fonctionne aussi. C’est un peu moins lisible (à mon gout), mais ça fait gagner pas mal de place.

Exécutez ce programme, vous devriez voir que la température est négative dans quatre pièces.

Les boucles de programmation.

La première grosse partie étant faite, passons à la suivante, les boucles while et for. Pour cela nous allons partir de notre dernier exemple qui compte le nombre de températures négative pour les simplifier en intégrant ces fameuses boucles.

Les boucles while, « tant que ».

La boucle WHILE s’exécute  TANT QUE une condition est valable. Pour cela il faut commencer par le mot clé WHILE suivi par la condition, puis DO. Ensuite vient la partie du programme à exécuter en boucle et à la fin de celle ci le mot clé END_WHILE.

Commençons par faire une boucle qui initialise notre tableau de température. Comme celui ci stocke dix variables, nous devons utiliser une variable pour parcourir chacune de ses valeurs (ces variables s’appel des index). Regardez avec cet exemple:

Initialisation grace a une boucle while

 

Petite analyse de ce qui s’est passé:

  • Lignes 1 à 3: Ce sont les initialisations. indexTableau est la variable entre les accolades de notre tableau. Elle évoluera de 0 à 9.
    valeurAleatoire est une variable « bidon ». Il n’y a pas d’intérêt à vouloir initialiser notre tableau avec une boucle si c’est pour devoir taper une à une chaque des valeurs à la main(comme cela a été fait des lignes 2 à 11 de l’exemple précédent). J’ai donc créé une variable de format SINT (donc allant de -127 à 127), à laquelle on rajoutera 43 (nombre choisi au hasard) à chaque passage dans la boucle. Cela donne 50, puis 93, puis -120, puis -77… afin d’avoir des valeurs « pseudo-aléatoire » (l’informatique a, en général, beaucoup de difficultés à générer des nombre aléatoire).
  • Ligne 6: Nos fameux WHILE et DO, et notre condition. Nous voulons remplir notre tableau de 10 valeurs, donc avec un index allant de 0 à 9 (donc étant strictement inférieur à 10).
  • Ligne 7: On assigne notre valeur « aléatoire » dans la case (ou élément ou index) du tableau correspondant (selon la valeur d’indexTableau).
  • Ligne 8: A chaque passage dans la boucle WHILE, on augmente de 1 la valeur d’indexTableau. Ce qui fait qu’au début du 1er passage, avant la ligne 8 elle vaudra 0 (valeur d’initialisation) et à après elle  vaudra 1. Puis au début du 2e passage elle vaudra toujours 1, puis après la ligne 8 elle passera à 2… Et ceci TANT QUE indexTableau est STRICTEMENT INFÉRIEUR a 10!
  • Ligne 9: Ici on génère notre valeur aléatoire en rajoutant 43 à la valeur actuelle.
  • Ligne 11: END_WHILE indique l’endroit ou le programme doit continuer une fois qu’il sort de sa boucle.
  • Ligne14: Elle sert uniquement lorsque, une fois connecté, on veut connaitre la valeur contenue d’une case du tableau. Il suffit de donner à la variable affichage la valeur de la ligne désirée et cela affichera la valeur du tableau associé.

Vous êtes encore avec moi?

Si la valeur aléatoire vous embête ignorez la, elle existe simplement pour remplir la tableau (cela évite de se retaper les dix lignes d’initialisation de l’exemple précédent).

Le plus important est de comprendre l’évolution de l’index du tableau et le rebouclage du while.

Maintenant nous allons développer notre programme pour y intégrer un compteur qui comptera le nombre de valeurs négatives. Voyez vous une façon (parmi les dizaines possible) de faire?

Je vous laisse essayer:

Banniere du site automacile.fr

Image d’attente.

Compteur de valeurs négatives

 

Rajouter une deuxième boucle WHILE est possible mais cela compliquerai inutilement le programme. Etant donné que les conditions nécessaires à la boucle WHILE comptant les valeurs négatives sont les mêmes que celle qui initialise notre tableau (à savoir indexTableau<10), il est judicieux d’y intégrer notre compteur. Ainsi regardez les lignes 9-12, vous voyez l’intégration d’un IF qui incrémente la variable nombre_temperatures_negatives dès qu’une valeur du tableau est négative.

Gardez à l’esprit qu’il est important que vos programmes soient les plus simples possible. Actuellement vous possédez la plupart des connaissances de bases, et il pourrait être tentant de mettre des boucles, des tableaux et des IF imbriqués partout. Mais essayez de garder du recul sur vos programme, et régulièrement, faites le point. Intégrer ici une deuxième boucle WHILE n’aurait pas été une erreur, votre programme aurait fonctionné, mais cela aurait encombré inutilement celui ci. Dans notre cas cela n’est pas grave, mais si vous faites cela dans un programme de plusieurs centaines, ou milliers, de lignes, je vous souhaite bonne chance pour le débogage.

Les boucles FOR.

Les boucles FOR utilise une variable qui évolue à un rythme régulier à chaque passage. Il y a 3 conditions à paramétrer (contrairement au WHILE ou c’est vous qui faite évoluer la variable):

  1.  La valeur de début de boucle.
  2. La valeur de fin de boucle.
  3. Le « pas » d’évolution de la variable.

Boucle FOR

Traduction:

  • FOR indexTableau:=0: On indique que la variable que la boucle FOR fera évoluée est indexTableau, et que lors du 1er passage dans la boucle, nous l’initialiserons à 0.
  • TO 99:  La boucle s’exécutera jusqu’à ce que la variable indexTableau sera égale à 99.
  • BY 1 DO: A chaque fois que l’on rencontrera le END_FOR, la variable indexTableau s’incrémentera automatiquement de 1.

Donc ici nous exécuterons 100 fois la boucle en incrémentant la variable de 1 à chaque passage.

Danger: Les boucles infinies !

Les boucles vous seront vites indispensables, mais attention, elles peuvent générer de gros bug (si elles sont mal programmées).

Regardez ces deux exemples et essayez de les comprendre:

Exemple de boucles infinies

 

Pour chacun de ces exemples, la variable utilisée pour sortir de la boucle est réécrite à l’intérieur de celle ci. Cela implique que:

  • Pour la boucle WHILE, réécrivant indexTableauWhile à 5 lors de chaque passage, celle ci sera donc forcement toujours inférieur à 10. Donc le programme ne sortira jamais de la.
  • Pour la boucle FOR, réécrivant indexTableauFor à 50 lors de chaque passage, celle ci sera donc forcement toujours inférieur à 99. Donc le programme ne sortira jamais de la.

Conclusion.

C’est sur cet avertissement que se termine ce chapitre ainsi que la partie consacrée au littéral.

Je pense que vous avez pu voir la puissance de ce type de programmation, et vous disposez maintenant de bases solides afin de taper vos premiers programmes. Cela dit, comme dans tout enseignement, vous disposez des outils nécessaire à l’élaboration de vos programmes, mais n’oubliez pas que c’est l’expérience qui vous permettra de réaliser vos projets les plus ambitieux.

Le prochain chapitre sera bien plus concret car nous appliquerons nos acquis à l’arduino, alors d’ici là exercez vous le plus possible, pensez au forum si vous avez des questions, et je vous donne rendez vous dans le chapitre intitulé: « Tutoriel arduino: Découverte de la carte et du logiciel ».

 

Lien de la section du forum associée:http://automacile.fr/forum/viewforum.php?f=7

Lien de la chaine youtube: https://www.youtube.com/channel/UChYxOrIAM-SdgvE3gTkGnzA

Pages : 1 2

Pages : 1 2

Pages : 1 2