Dans les deux dernières pages nous avons vu comment allumer une led dans la fonction loop ainsi qu’utiliser l’interface Série, mais on peut faire beaucoup plus de choses. On peut faire des actions sous conditions, on peut faire des boucles et plus encore. Il sera d’ailleurs indispensable de savoir maîtriser ces choses là afin de pouvoir réalisé des codes un peu plus complexe. Cependant pour faire un programme plus complexe, le comprendre et l’expliquer il peut être très intéressant de savoir le représenter sous une forme ou une autre. Dans cet optique on va voir comment formaliser un programme grâce aux algorigrammes.

Introduction aux algorigrammes :

Pour que vous puissiez mieux comprendre le fonctionnement des boucles, je vais tenter de vous les expliquer à l’aide d’algorigrammes, diagrammes permettant de modéliser les suites d’actions, ils peuvent être utiles si vous avez besoin d’expliquer le fonctionnement d’un programme à de tierces personnes n’ayant pas forcément de connaissance en programmation. Si vous souhaitez plus d’information sur la construction d’algorigramme, vous pouvez ouvrir ce spoiler :

En savoir plus sur les algorigrammes

Si vous souhaitez vous aussi en créer, je vous conseille Dia (disponible en français pour Windows, Linux et MAC) qui est un logiciel gratuit très simple à utiliser.

Les cellules :

Les algorigrammes sont composés de différentes cellules permettant une lecture simplifiée et rapide. Mais ne vous inquiétez pas, il n’y en a que 4 :

Début, fin, interruption

On l’on l’utilise le plus souvent pour la cellule du début, elle correspond à la fonction « setup » dans un programme Arduino.

Traitement/Opération interne

Sert à symboliser les actions internes qui ne font pas appel à des entrées ou des sorties. Par exemple Attendre x secondes sera symboliser par un rectangle dans un algorigramme.

Décision

Toutes les boucles ainsi que de nombreuses structures sont basées sur cette cellule, c’est généralement une question, une comparaison.

Sous-programme

Servent à symboliser des portions de programmes telles que des fonctions auxquelles ont fait appel dans un programme.

Premier exemple :

Il va donc nous falloir les relier pour créer un algorigramme, comme par exemple celui-ci qui représente l’exemple Blink vu précédemment :

Cette structure est une structure linéaire, les actions se déroulent selon le sens des flèches à partir de la cellule début soit de haut en bas puis on revient juste après le début (à cause de la fonction loop() qui se répète à l’infini).

Et voici ce que donne cette algorigramme en Arduino :

void loop() {
  digitalWrite(LED, HIGH);
  delay(PAUSE);
  digitalWrite(LED, LOW);
  delay(PAUSE);
}

Mais il existe d’autres structures, qui permettent de répéter ou exécuter uniquement certaines parties de code et qui rendent le code plus lisible.

Les conditions et les boucles en Arduino :

Donc nous allons voir maintenant comment utiliser les différentes conditions et boucles essentielles avec Arduino grâce à des exemples ! Mais pour commencer, voyons comment créer une condition.

Une condition est une équation (ou une inéquation) qui doit être vraie pour que la boucle se déroule. Par exemple ces lignes sont des conditions car elles utilisent des opérateurs de comparaison (les ==, <, >, …) :

led == 0 //égal à
potentiometre >= 127 //supérieur ou égal à
position < 90 //inférieur à
distance != 0 //différent de

Ils sont à ne pas confondre avec les opérateurs booléens qui permettent de tester 2 conditions en même temps. Par exemple si on veut allumer une led seulement si les deux autres sont éteintes on écrira quelque chose comme ceci :

if (led1 == false && led2 == false)
{
  digitalWrite(L3, HIGH);
  led3 = true;
}

Si… Alors…Sinon…

On va commencer par le plus simple à comprendre et celle que l’on a déjà utilisé dans la communication Série. Nous allons voir ici l’exécution d’une partie de code sous conditions avec Si… Alors… Sinon…, mais sachez que le sinon n’est pas obligatoire. Voici l’algorigramme correspondant au programme « Dori rencontre quelqu’un » :

Voici un autre petit programme se basant sur le Blink et permettant d’utiliser la boucle Si…Alors…Sinon…:

#define LED 13          //Pin sur lequel la led est branchée
#define PAUSE 500       //Pause entre chaque changement d'état de la led
boolean etat = false;   //Variable stockant l'état de la led

void setup() {
  pinMode(LED, OUTPUT);   //On déclare le pin lié à LED comme une sortie
  digitalWrite(LED, LOW); //On éteint la led (vérification)
}

void loop() {
  if ( etat == false ) //Si l'état de la led est faux (éteint)
  {                    // Alors :
    digitalWrite(LED, HIGH);    //On allume la led
    etat = true;                //On attribue à etat la valeur true (allumée)
    delay(PAUSE);               //On attend PAUSE ms
  }
  else //Sinon (si la condition précédente n'est pas vérifiée) :
  {
    digitalWrite(LED, LOW);     //On éteint la led
    etat = false;               //On attribue la valeur false à etat
    delay(PAUSE);               //On attend PAUSE ms
  }
}

Premier exemple Si... Alors...

N’hésitez pas à le modifier et observer le résultat.

Maintenant que vous connaissez la boucle de base, nous allons lui ajouter une partie supplémentaire entre le Si… Alors… et le Sinon… nommée Sinon Si… Alors… . Elle permet d’ajouter une condition et un résultat à votre boucle. Par exemple, avec le programme précédent peut importe la valeur différente de « false » le sinon s’exécutera mais si vous souhaitez ajouter des actions lorsque la valeur est « true » ou aucune des 2 (en cas d’erreurs):

#define LED 13          //Pin sur lequel la led est branchée
#define PAUSE 500       //Pause entre chaque changement d'état de la led
boolean etat = false;   //Variable stockant l'état de la led

void setup() {
  pinMode(LED, OUTPUT);   //On déclare le pin lié à LED comme une sortie
  digitalWrite(LED, LOW); //On éteint la led (vérification)
}

void loop() {
  if ( etat == false ) //Si l'état de la led est "faux" (led éteinte)
  {                    // Alors :
    digitalWrite(LED, HIGH);    //On allume la led
    etat = true;                //On attribue à etat la valeur true (allumée)
    delay(PAUSE);               //On attend PAUSE ms
  }
  else if( etat == true ) //Sinon si l'état de la led est "vrai" (led allumée)
  {
    digitalWrite(LED, LOW);     //On éteint la led
    etat = false;               //On attribue la valeur false à etat
    delay(PAUSE);               //On attend PAUSE ms
  }
  else //Sinon faire : (dans le cas où il y a une erreur dans la valeur de la variable)
  {
    etat = false; //On met etat à false
  }
}

Exemple Si...Alors...Sinon si...Sinon...

Les boucles for « pour »:

La boucle for permet de répéter un morceau de programme autant de fois que nous le souhaitons sans avoir à nous répéter. Vous pourrez par exemple faire clignoter la led rapidement 3 fois :

// Blink avec #define
// Pour prendre les bonnes habitudes dès le départ

#define LEDPIN 13 //Associe 13 au mot " LEDPIN " dans le programme
//ce qui a pour conséquence de tout simplement remplacer tout les LEDPIN dans le programme par  13.

#define LENT 500
#define RAPIDE 100

void setup() {

pinMode(LEDPIN, OUTPUT); //Déclare le numéro de pin associé à LEDPIN comme une sortie = pinMode(13, OUTPUT);

}

void loop() {

for(uint8_t i = 0; i<=3; i++) //On entre les valeurs (Initialisation, Condition, Incrémentation)
{
  digitalWrite(LEDPIN,HIGH); //Place le pin digital 13 à l'état HAUT (5V) -> Led allumée
  delay(LENT);
  digitalWrite(LEDPIN,LOW); //Place le pin digital 13 à l'état BAS (0V) -> Led éteinte
  delay(LENT);
}

for(uint8_t i = 0; i<=3; i++)
{
  digitalWrite(LEDPIN,HIGH); //Place le pin digital 13 à l'état HAUT (5V) -> Led allumée
  delay(RAPIDE);
  digitalWrite(LEDPIN,LOW); //Place le pin digital 13 à l'état BAS (0V) -> Led éteinte
  delay(RAPIDE);
}

}

Blink utilisant des boucles for

Et voici un autre exemple de boucle for, essayez de comprendre comment il agit et n’hésitez pas à les modifier !

// Blink avec #define
// Pour prendre les bonnes habitudes dès le départ

#define LEDPIN 13 //Associe 13 au mot " LEDPIN " dans le programme
//ce qui a pour conséquence de tout simplement remplacer tout les LEDPIN dans le programme par  13.

#define PAUSE 500
#define CLIGNOTEMENT 100
uint8_t tour = 0;
void setup() {

pinMode(LEDPIN, OUTPUT); //Déclare le numéro de pin associé à LEDPIN comme une sortie = pinMode(13, OUTPUT);

}

void loop() {

for(uint8_t i = 0; i<=tour; i++) //On entre les valeurs (Initialisation, Condition, Incrémentation)
{
  digitalWrite(LEDPIN,HIGH); //Place le pin digital 13 à l'état HAUT (5V) -> Led allumée
  delay(CLIGNOTEMENT);
  digitalWrite(LEDPIN,LOW); //Place le pin digital 13 à l'état BAS (0V) -> Led éteinte
  delay(CLIGNOTEMENT);
}
tour++;
delay(PAUSE);

}

Second exemple de boucle for

Les boucles while, « tant que » :

La seconde boucle que nous allons voir est la boucle « Tant que… » (while en anglais), celle-ci permet d’exécuter un morceau de code tant que la condition est vérifiée. Par exemple si vous souhaitez que Dori répète son message de bienvenue tant qu’il n’y a pas de nouveau message reçu alors vous pourrez faire ce genre de programme :

// define 
#define TEMPSENMEMEOIRE 3000 // votre arduino est un poisson rouge qui retient votre prénom pendant 3000 secondes

//Variables :
String msg = "  "; //Variable de type suite de caractères qui est initialisée avec un espace vide

void setup()
{

Serial.begin(9600); //Initialisation de la liaison Série
Serial.println("Salut ! Quel est ton prenom ?"); //Afficher la phrase entre " et "

}

void loop()
{

while (Serial.available() == 0)
 {
  delay(1000); //Attendre 1seconde (1000 ms)
  Serial.println("Salut ! Quel est ton prénom ?");
 }

if (Serial.available() ) 
 { 
  msg = Serial.readString(); //Stocke le message sous forme de String dans msg
  Serial.print("--> "); //Affiche une flèche
  Serial.println(msg); //Puis votre message
  Serial.print( "Salut " ); 
  Serial.println(msg); //Puis votre 
  Serial.println(""); //Puis on saute une ligne
  delay(TEMPSENMEMEOIRE); // on attend que le temps de mémoire qu'on a choisi en defien
  msg =" "; //On oublie le prénom , on vide la mémoire
  Serial.println("Salut ! Quel est ton prénom ?");
 }
}

Dori et l'utilisation d'une boucle while

Ce qui donnera un algorigramme de ce type :

Les boucles Do … While « Faire… Tant que… » :

Les boucles while est bien utile lorsque l’on doit répéter un morceau de code un nombre indéterminé de fois mais si la condition n’est pas vérifiée alors la boucle ne sera pas exécutée ce qui peut poser des problèmes dans certaines applications. C’est pourquoi je voulais vous parler du Faire… Tant que… qui permet de résoudre ce problème et qui s’écrit de cette manière, avec la condition à la fin :

do
{
  //Votre partie de programme
} while (condition à tester);

Les boucles infinies … :

En générale on cherche à l’éviter mais parfois elles sont très pratiques ! Il y a plusieurs façons de les écrire !

Les variables à connaitre :

Les variables sont, comme nous l’avons vu dans les précédents programmes, des éléments permettant d’y stocker une information selon sa nature et sa taille. Outre les variables il nous arrivera d’utiliser des #define, que nous avons déjà utilisé au par avant. Le but du #define est de remplacer un chiffre fixe par un mot clef.

#define LEDPIN 13
#define NOM 0

Pour simplifier la lecture, tous les defines seront écrit en majuscule afin de ne pas les confondre avec les variables.

Passons aux variables, celles contenant un nombre entier sont désignées par le radical « int ». La désignation change en fonction de l’espace que nous voulons leur allouer :

int nombre = 0; //Nombre compris entre -32 768 et 32 767 soit 2 bytes
int16_t nombre2; //Reviens au même que int
uint16_t nombre 3; // Nombre sur 2 byte mais compris entre 0 et 65 535
int8_t petitnombre; //Nombre compris entre -128 et 127
uint8_t pnombrepositif; //Nombre compris entre 0 et 255

Les autres variables populaires permettent de contenir différents types de contenus comme du texte pour les variables de type Strings, des nombres décimaux pour les floats,…

String phrase = "Hello World :"; //Variable stockant une suite de caractères
float pi = 3.14; //Variable stockant un nombre décimal
boolean etat = true; //Variable de type booleene Vrai ou Faux

Bien sûr il en existe bien d’autres, que vous pourrez retrouver sur la page « Reference » du site d’Arduino 😉

Et si vous souhaitez un conseil pour optimiser un peu vos codes , vous pouvez jeter un œil à cet article pour adapter la taille de vos variables en fonction de vos besoins.

<- Retourner à la page précédente | Passer à la page suivante ->

3 réflexions sur « 1.6 Algorigrammes, boucles, conditions et variables »

autodiagnoskamal dit :

22 mars 2021 à 1 h 09 min

excellente démonstration, très clair, merci pour le partage

Répondre
autodiagnoskamal dit :

22 mars 2021 à 1 h 10 min

merci pour l explication

Répondre
Boukili brahim dit :

6 août 2021 à 23 h 49 min

Merci beaucoup pour l’explication.
C est clair.

Répondre