• 15 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Faites des boucles et des calculs

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans tout apprentissage, la pratique reste souvent un bon moyen de mieux comprendre la théorie.

Ce chapitre va tourner autour de la réalisation de deux programmes qui devraient vous permettre d’appliquer les connaissances que vous venez d’acquérir dans ces premiers chapitres :

  1. Le premier programme va vous permettre de vous amuser avec les variables en laissant le programme les modifier à votre place. Nous en profiterons pour réviser la notion de condition et aborder la notion de boucle qui permet bien des choses en programmation.

  2. Le second devrait faire appel à tout ce que vous avez vu dans ces premiers chapitres, et aura pour objectif de programmer des affichages sur le moniteur.

Pour ceux qui se demandent "quand-est-ce qu'on branche des matériels électroniques", et bien rassurez-vous, nous l'aborderons dans les chapitres suivants, mais il me semble primordial de passer par le côté logiciel et programmation avant d'aborder l'électricité et l'électronique. Le titre du cours, je vous le rappelle est Programmez vos premiers montages avec Arduino. ;)

Programme "Arduino compte seul"

L'objectif de ce programme est de faire compter l'Arduino tout seul. Je m'explique :

  • Tout d'abord, l'Arduino doit afficher sur le moniteur série le nombre 1 et allumer une fois la LED 13.

  • Puis, après un temps d'arrêt d'une seconde, il doit afficher le nombre 2 et faire clignoter 2 fois la LED 13 (à 2Hz, je vous laisse revoir le cours sur les fréquences ).

  • Encore un arrêt d'une seconde, puis affichage du chiffre 3 avec 3 clignotements ( toujours à 2 HZ).

  • L'opération se répète jusqu'au nombre 20, puis l'Arduino envoie "Ayé !" sur le moniteur série et plus rien ne se passe.

Pour réaliser ce programme, nous allons procéder en deux temps. Mais avant de nous lancer, laissez-moi vous présenter quelques notions dont vous allez avoir besoin.

Calculs sur variable

Tout d'abord, il vous faut savoir qu'une variable peut être modifiée par calcul. Jusque là, nous avions écrit :

int uneVariable; //uneVariable contient on ne sait trop quoi
uneVariable=10; //uneVariable contient 10
uneVariable=32; //uneVariable contient 32

Et bien il est possible d'écrire :

int uneVariable; //uneVariable contient on ne sait trop quoi
uneVariable=10; //uneVariable contient 10
uneVariable=10+22; //uneVariable contient 32 (résultat de 10+22)

Mais là où ça devient intéressant (si si, je vous assure), c'est qu'on peut écrire ceci :

int uneVariable;
uneVariable=10;
uneVariable=uneVariable+22;

:waw:... ben oui.

Comment ça marche ? Tout simplement comme votre cerveau si je vous dis :

"Imaginez un bus. Dans ce bus, il y a 10 personnes. Il en monte 22, combien le bus contient de passagers ?"

 Voilà ce que vous faites et ce que fait l'ordinateur :

Phrase

Action humaine

Action machine

Code

Imaginez un bus

vous allez d'abord imaginer le bus

déclaration de la variable bus

int bus;

Dans ce bus il y a 10 personnes

vous allez y mettre 10 personnes

 initialisation de la variable à 10.

 bus=10;

Il en monte 22

vous allez reprendre le nombre de personnes

appel de la variable bus

bus

Il en monte 22 (suite)

vous lui ajoutez 22

calcul sur la variable bus

bus+22

Il en monte 22 (fin)

vous mettez tout le monde dans le bus

affectation du résultat dans la variable bus

bus=bus+22;

Si vous avez compris cela, la suite ne devrait pas vous poser de problèmes. Voici ce qui est encore possible :

//Déclarations
int a;
int b;
int c;

//Initialisations
a=3; // a vaut 3
b=5; // b vaut 5
c=0; // c vaut 0

//Calculs
c=b+a; // c vaut maintenant 8
a=a+c; // a vaut maintenant 11 car 3+8
b=a+b; // b vaut maintenant 16 car 11+5
c=a+b; // c vaut maintenant 27 car 11+16

Prenez un instant pour être sûr(e) de bien avoir saisi ce code. Faites les calculs de tête, vérifiez.

Nous allons faire un petit programme sur l'Arduino qui compte de 1 en 1  et qui nous l'affiche sur le moniteur. Vous pouvez essayer de le réaliser seul(e) avant de regarder le code.

int compteur; //déclaration d'une variable compteur

void setup()
{
    Serial.begin(9600); //initialisation communication
    compteur=1; // initialisation de compteur
}

void loop()
{
    Serial.println(compteur); //affiche la valeur de compteur
    compteur=compteur+1; //on ajoute 1 à compteur
}

Saisissez le code, téléversez-le et ouvrez le moniteur. Si tout se passe bien, vous voyez l'affichage qui progresse de 1 en 1.

Devinette : Si vous laissez tourner ce programme, Arduino n'atteindra jamais 33000. Essayez de trouver pourquoi... (indice : c'est en rapport avec le type de la variable)

Le fait d'ajouter 1 à une variable s'appelle incrémenter, et le fait d'enlever 1 c'est décrémenter. Ce sont des mots de vocabulaire à connaître.

Bon, si nous reprenions notre objectif de programme de début de chapitre, nous pourrions dire que faire compter l'Arduino jusqu'à 20 va être finalement assez simple. Il faut juste savoir comment l'arrêter... quelqu'un a une idée ?

(non Lukas, le débrancher n'est pas la réponse que j'attendais...)

Et bien nous allons utiliser une condition ! Nous allons dire à Arduino : tant que le compteur est inférieur ou égal à 20, tu comptes, sinon tu ne fais rien. Ce qui donne en pseudo-code :

déclaration de la variable compteur

void setup()
{
    initialisation de la communication
    initialisation de compteur à 1
}

void loop()
{
    si (compteur est inférieur ou égal à 20)
    {
        affichage de la valeur de compteur sur le moniteur
        incrémentation de compteur
    }
}

Je vous laisse le traduire en vrai code, c'est un bon exercice.

L'utilisation de pseudo-code est assez efficace pour organiser son programme. Il permet aussi de présenter ce qu'on attend en s'affranchissant des mots-clés précis du langage. Un développeur de C pourrait sans problème le traduire pour un affichage sur la console.

Allez, voici le code pour l'Arduino :

int compteur;
void setup()
{
    Serial.begin(9600);
    compteur=1;
}
void loop()
{
    if (compteur<=20)
    {
        Serial.println(compteur);
        compteur=compteur+1;
    }
}

Comme nous l'avons vu au chapitre précédent, si vous appuyez sur le bouton d'affichage du moniteur (la loupe), ça relance le programme sur l'Arduino. Mais une partie des envois précédents a eu le temps de passer et de s'afficher. Tout cela manque parfois de clarté. On peut donc ajouter une ligne de présentation juste après l'initialisation de la communication :

Serial.println("*** Debut du programme ***");

Ce n'est pas obligatoire, mais c'est plus sympa :soleil:. Vous êtes libres d'écrire ce qui vous plaît en plus. Moi j'aime bien un : "Bonjour maître, je commence."

Ok, mais maintenant, comment on peut faire que la LED 13 clignote le nombre de fois spécifié danscompteur ?

Ha ! Ça fait plaisir de voir que ce cours vous maintient en haleine (non merci pas trop près Lukas) et vous pousse ainsi vers le savoir !

Et bien pour répondre à cette excellente question, je vais en profiter pour aborder une notion particulièrement utile : les boucles !

La boucle "for"

La programmation nous permet de réaliser des boucles dans un programme. C'est à dire qu'on peut exécuter un bloc de code plusieurs fois avant de passer à la suite. Cette répétition ouvre un grand nombre de possibilités.

Il existe plusieurs sortes de boucles, nous les verrons progressivement. Nous allons commencer par la bouclefor. Elle permet de répéter un code un nombre de fois connu à l'avance.

Elle se présente un peu comme une condition : elle commence par un mot-clé (for ), suivi de certaines choses entre parenthèses, puis des accolades qui contiennent le code à exécuter. Voici un exemple :

for (int t=0;t<10;t=t+1)
{
    code à exécuter
}

Le plus difficile à comprendre se situe entre les parenthèses. Il y a trois informations importantes séparées par des points-virgules :

  1. Initialisation de la variable qui va servir de compteur. Dans notre exemple, on déclare et on initialise (dans le même temps)  une variable t de type "int" :int t=0 .

  2. Condition à tester pour continuer ou non la répétition. Ici, on exécute le code tant que t est inférieur à 10 :  t<10.

  3. Action sur le compteur à chaque tour de boucle. Dans notre cas, t est augmenté de 1 à chaque passage : t=t+1.

Ce qui est encore plus fort, c'est que cette variable t (le compteur) peut être utilisée dans le code à exécuter ! Du coup, voici notre programme de comptage modifié avec une boucle for. Observez-le, testez-le et comprenez-le !

void setup()
{
    Serial.begin(9600);
    Serial.println("*** Debut du programme ***");
}
void loop()
{
    for (int compteur=0;compteur<=20;compteur=compteur+1)
    {
        Serial.println(compteur);
    }
}

Il compte bien jusqu'à 20, mais reprend ce comptage sans arrêt !

C'est normal, nous n'avons pas indiqué à Arduino qu'il ne doit le faire qu'une seule fois. Il va donc falloir creér une variable à tester pour le lui indiquer.

Le type boolean

Je vais donc en profiter pour vous parler des variables de type boolean (ou booléens). Ce sont des variables qui ne peuvent prendre que deux valeurs : soit 1 (true, c'est-à-dire vrai), soit 0 (false, c'est-à-dire faux). Les booléens sont des variables pratiques pour faire des tests comme celui dont nous avons besoin pour vérifier si le compteur de notre programme “Arduino compte seul” a fini de compter jusqu’à 20.

Observez le bout de code suivant :

boolean etat; //déclaration de la variable etat de type boolean
etat=true; //initialisation de etat à VRAI
if (etat) // test si etat est VRAI
{
    //bloc de code exécuté si etat est VRAI
}

Vous remarquerez que l’on n’a pas besoin d’écrireif(etat==true)  dans la condition, il suffit d’écrireif(etat) qui signifie la même chose (mais les deux sont corrects).

Il faut comprendre que si vous créez une variable booléenne “drapeau” avec l’instruction suivante :

boolean drapeau;

Les trois instructions suivantes lui assigneront la même valeur “true” :

drapeau=true;   //drapeau vaut true
drapeau=1;      //drapeau vaut true, car true c'est 1
drapeau= 3<5;    //drapeau vaut true, car 3 est inférieur à 5

Testez ce petit programme sur l'Arduino :

boolean etat;

void setup()
{
    Serial.begin(9600);
    etat=true;
}
void loop()
{
    etat=3<5;
    Serial.println(etat);
}

Il affiche des 1. Caretat  vaut 1(true) résultat du test (3<5). 

Allez, on modifie notre programme "Arduino compte seul" pour y ajouter notre test de fin :

boolean affichage; //variable pour stopper l'affichage
void setup()
{
    Serial.begin(9600);
    affichage=true;  //initialisation de la variable à true
    Serial.println("*** Debut du programme ***");
}
void loop()
{
    if (affichage) // test si affichage vaut true
    {
        //boucle de comptage
        for (int compteur=0;compteur<=20;compteur=compteur+1)
        {
            Serial.println(compteur);
        }
        affichage=false; // on passe affichage à false
    }
}

Vous voyez ici un bel entrelacement d'accolades. Pour s'y retrouver, il est conseillé, à chaque nouveau niveau d'accolade de faire une tabulation. Ainsi c'est plus lisible. Vous avez un outil de formatage automatique dans le menu Outils de l'IDE. C'est très pratique, essayez-le.

De plus, l'IDE vous propose un repérage simplifié des paires d'accolades ou de parenthèses. En effet, si vous sélectionnez ou cliquez à la droite d'une parenthèse ou d'une accolade, vous verrez que sa compagne s'encadre en bleu.

On avance pas mal, non ? Si vous trouvez ce dernier code encore trop inaccessible, je vous conseille de vous arrêter ici. De faire une pause, de relire tranquillement le chapitre (voire les chapitres précédents) pour chercher ce qui a pu vous échapper. Ce cours ne vous sera pas d’une grande utilité si vous copiez le code sans le comprendre ;).

Et maintenant, le clignotement ! Rappelez-vous, si le compteur vaut 1, on clignote 1 fois, s'il vaut 2, 2 fois, etc.  Quand on regarde le programme, on se dit que ce serait bien que le code de clignotement soit juste après l'affichage de compteur (donc après la ligne 15 dans le code ci-dessus). Comment faire ? Là encore c'est la bouclefor qui va nous servir. Voici un code pour faire clignoter 10 fois la LED 13 (affiché en coloration syntaxique du langage C)  :

int nombreDeFois; // variable pour le nombre de fois
int numeroPin; // variable pour le pin utilisé
boolean faireCode; // variable pour arrêter le clignotement

void setup()
{
    numeroPin=13; // initialisation pin à 13
    pinMode(numeroPin,OUTPUT);
    nombreDeFois=10; // initialisation nb de fois à 10
    faireCode=true; // initialisation à true
}

void loop()
{
    if (faireCode) // test si true
    {
        for (int t=0;t<nombreDeFois;t=t+1) // boucle clignotement
        {
            //allume
            digitalWrite(numeroPin,HIGH);
            delay (250);
            //éteint
            digitalWrite(numeroPin,LOW);
            delay (250);
        }
        faireCode=false;
    }
}

Ce code ne devrait pas vous poser de problèmes si vous lisez les commentaires. J’utilise la même structure que le code précédent, mais sans l’affichage sur le moniteur série.

Le problème est qu’avec ce code, la LED13 clignotera 10 fois à chaque tour (cf ligne 9). Il faudrait pouvoir faire varier cette valeur. Et bien nous utiliserons en fait la valeur de compteur (qui va de 0 à 20) dans la bouclefor du clignotement !

Je vous livre le code final car il est intéressant à étudier pour bien appréhender les variables, les conditions et les boucles. Observez-le, dépecez-le, et surtout, essayez de le refaire seul(e)s.

Code final du programme "Arduino compte seul"

Voici le code avec les commentaires :

boolean affichage; //variable pour stopper l'affichage
int numPin;

void setup()
{
    numPin=13;
    pinMode(numPin,OUTPUT);
    Serial.begin(9600);
    affichage=true; //initialisation de la variable à true
    Serial.println("*** Debut du programme ***");
}

void loop()
{
    if (affichage) // test si affichage vaut true
    {
        //boucle de comptage
        //compteur s'augmente de 1 à chaque tour
        for (int compteur=1;compteur<=20;compteur=compteur+1)
        {
            Serial.println(compteur);
            
            //boucle de clignotement
            //compteur sert de limite à la boucle
            //donc le nombre de clignotements augmente à chaque tour
            for (int nbClignote=0;nbClignote<compteur;nbClignote=nbClignote+1)
            {   
                //allume
                digitalWrite(numPin,HIGH);
                delay(250);
                //eteind
                digitalWrite(numPin,LOW);
                delay(250);
            }
            delay(1000); //attente de 1s
        }
        affichage=false; // on passe affichage à false
        Serial.println("*** Ayé ! ***");
    }
}

Notez que l’on pourrait écrire ce code de manière plus efficace, mais il faudrait faire recours à des notions que vous n’avez pas encore vues donc pour l’instant on va se contenter de cette version.

N'oubliez pas d'ouvrir le moniteur, et amusez-vous à modifier lesdelay, les limites des boucles, etc. 

Essayez de comprendre pourquoi dans les bouclesfor, la variablecompteur est initialisée à 1, alors qu'on initialisec à 0.

Pour incrémenter une variable il existe trois codes possibles qui sont tous corrects :

int variable;

// pour incrémenter
variable=variable+1; // celui-ci vous connaissez
variable+=1; // autre façon, plus courte
variable ++; // autre façon encore plus courte

// pour décrémenter
variable=variable-1;
variable-=1;
variable --;

Petit exercice : Essayez de simplifier le code de "Arduino compte seul" sans que le résultat ne soit changé (aide : il faut enlever ou modifier certaines boucles et tests).

Vérifiez la solution ! 

Nous avons réalisé ensemble pas à pas ce programme de clignotement, je vous propose maintenant d’en faire un tous seuls comme des grands !

TP : Programme “Table de multiplication"

Dans ce programme, je vais vous demander d’afficher la table de multiplication par 7 des nombres de 0 à 14. Voici quelques règles à respecter :

  • Le programme devra afficher la table de multiplication une seule fois, il faudra donc utiliser une condition pour vérifier si elle a été affichée.

  • Pour rendre le programme facile à modifier, vous stockerez le nombre 7 dans une variable de type int. Nous apprendrons plus tard comment envoyer une information à l'Arduino depuis le moniteur, ce qui nous permettra d'afficher la table de notre choix.)

  • Le moniteur devra afficher une table qui ressemble à ça :

Rendu sur la console du programme
Rendu sur la console du programme "Table de multiplication"

Quelques pistes  utiles

  • Pour afficher un saut de ligne, il suffit d'utiliser l'instruction suivante : Serial.println(), sans rien entre les parenthèses.

  • Pour faire un calcul de multiplication dans un programme, on utilise l’étoile *. Donc “3x4” en humain s’écrit “3*4” en machine. Et la division s’écrit avec le slash / en machine.

Allez, je vous laisse travailler, je vais faire une sieste. Ne désespérez pas au premier problème rencontré, relisez le cours, essayez, modifiez. Il n'y a pas de pièges dans la conception de ce programme.

Code pour le programme "Table de multiplication"

Voici le code attendu, vous devriez vous y retrouver facilement car tous les mots vous sont maintenant familiers :

int numTable; // variable pour la table concernée
boolean affiche; // variable d'affichage

void setup() {
  affiche = true; // initialisation à true
  numTable = 7; // iniialisation à 7
  Serial.begin(9600); //initialisation de l'affichage
  
  //Affichage de l'entête du programme
  Serial.println("***********************");
  Serial.println("Table de multiplication");
  Serial.print("La table de : "); //pas de retour à la ligne
  Serial.println(numTable); // affichage de la variable
  Serial.println(); // saut de ligne pour aérer
}

void loop() {
  if (affiche) // test si vrai
  {
    // boucle de progression pour la multiplication
    for (int t = 0; t < 15; t++)
    {
      int resultat = numTable * t; // variable pour stocker le résultat
      
      // Affichage de la ligne
      Serial.print(t);
      Serial.print(" x ");
      Serial.print(numTable);
      Serial.print(" = ");
      Serial.println(resultat);
    }
    Serial.println(); // saut de ligne
    Serial.println("***********************");
    affiche=false; // passage à false pour ne plus afficher
  }

}

Quelques remarques :

  • Ligne 21 : j'utilise la méthode d'incrémentation simplifiée t++, c'est identique à t=t+1.

  • ligne 23 : la déclaration, l'initialisation et l'affectation de la variable est faite en une seule ligne. C'est tout à fait correct, légèrement plus gourmand en place mémoire.

  • La variable "resultat" créée en ligne 23 et affichée en ligne 30, n'est pas une obligation. Nous aurions très bien pu écrire en ligne 30 directement : Serial.println(numTable*t); 

Bon c'était là encore une bonne partie (de rigolade ?) bien chargée de connaissances.

Dans l'état actuel de votre savoir programmistique, si vous avez réussi à réaliser seul(e)s ce dernier programme, voire celui d'avant, on peut dire que vous êtes fichtrement avancés maintenant en programmation.

Vous êtes donc largement prêt(e)s à passer à l'étape suivante : les connaissances électriques des montages.

Exemple de certificat de réussite
Exemple de certificat de réussite