Les lignes de code des programmes Arduino 2

par | Cartes arduino

 I ) Les structures de contrôle conditionnelles

a ) Les instructions conditionnelles avec « If Else »

if-else

void loop() {
tempSalon = recupererTemperature(); //tempSalon sera égal à la température actuelle

if (tempSalon < 20){Serial.print("Il fait froid, on allume le radiateur.");
//La, on met une commande pour allumer le radiateur 
} 
else {Serial.print("La température est raisonnable, on ne fait rien.");
// On ne fait rien 
}
}

 

Un if…else c’est bien mais… est ce qu’on peut mettre plus de conditions ?

Bien sur, grâce au else if.

Le else if est tout simplement une répétition du if rajoutant plusieurs conditions, voici l’exemple ci-dessus modifié grâce au else if.

if (tempSalon < 20){Serial.print("Il fait froid, on allume le radiateur.");
//La, on met une commande pour allumer le radiateur.
} 
else if (tempSalon == 25) {Serial.print("On a atteint une bonne température, on éteint le radiateur");
//La, on met une commande pour éteindre le radiateur.
}
else if (tempSalon > 25) {
Serial.print("Il commence à faire chaud, on allume la clim");
//La, on met une commande pour allumer le climatiseur d'air.
}
else {
Serial.print("La température est raisonnable, on ne fait rien.");
// On ne fait rien.
}

 

remarque : si vous avez besoin de beaucoup de else if, il va falloir songer à utiliser une autre structure de contrôle baptisée le switch.
Le switch est un if…else optimisé permettant d’avoir beaucoup plus de possibilités rapidement

 

 II ) Les structures de contrôle itératives

a ) Structure de contrôle While ( tant que )

Tant qu’il pleut, je ne sors pas.

La structure de contrôle while (« tant que » en français) est une boucle qui répète une ou plusieurs instructions tant que la condition que vous indiquez est vraie.

Admettons que nous déclarions ceci :

int maVariable = 0;

while

 Exemple :

while(position_volet == "ouvert")
{
    //instructions qui font descendre le volet
}

 

a ) Structure de contrôle do While ( tant que )
//variable compteur = 5
int compteur = 5;
 
do
{
    compteur++;  //on incrémente la variable compteur à chaque tour de boucle
}while(compteur < 5);  //tant que compteur est inférieur à 5, on boucle

Le mot do vient de l’anglais et se traduis par faire. Donc la boucle do…while signifie « faire les instructions, tant que la condition testée est fausse ». Tandis que dans une boucle while on pourrait dire : « tant que la condition est fausse, fais ce qui suit ».

Il y a une différence qui a son importance ! En effet, si on prête attention à la place la condition dans la boucle while, on s’aperçoit qu’elle est testée avant de rentrer dans la boucle.  Tandis que dans une boucle do…while, la condition est testée seulement lorsque le programme est rentré dans la boucle.

Qu’est-ce que ça change ?

Et bien, dans une while, si la condition est fausse dès le départ, on entrera jamais dans cette boucle. A l’inverse, avec une boucle do…while, on entre dans la boucle puis on test la condition.
Donc avec la boucle Do .. While même si la condition est fausse dès le départ on fait quand même un tour dans la boucle au moins une fois.

 

c ) Structure de contrôle For

for-explain

Cette boucle est particulière, elle est exécutée X fois.
Contrairement aux deux boucles précédentes, on doit lui donner trois paramètres.

D’abord, on crée la boucle avec le terme for (signifie « pour que »). Ensuite, entre les parenthèses, on doit donner trois paramètres qui sont :

  • la création et l’assignation de la variable à une valeur de départ
  • suivit de la définition de la condition à tester
  • suivit de l’instruction à exécuter
for (/*initialisation de la variable*/ ; /*condition à laquelle la boucle s’arrête*/ ; /*instruction à exécuter*/)
for(int compteur = 0; compteur < 5; compteur++)

 

III ) La boucle infini

La boucle infinie est très simple à réaliser, d’autant plus qu’elle est parfois très utile.
Il suffit simplement d’utiliser une while et de lui assigner comme condition une valeur qui ne change jamais. En l’occurrence, on met souvent le chiffre 1.

while(1)
{
    //instructions à répéter jusqu'à l'infinie
}

On peut lire : « TANT QUE la condition est égale à 1, on exécute la boucle ». Et cette condition sera toujours remplie puisque « 1 » n’est pas une variable mais bien un chiffre. Également, il est possible de mettre tout autre chiffre entier, ou bien le booléen « TRUE » :

while(TRUE)
{
    //instructions à répéter jusqu'à l'infinie
}

C’est l’équivalent de la fonction interne arduino, la fonction loop() 

 

IV ) Fabriquer une fonction

Pour fabriquer une fonction, nous avons besoin de savoir trois choses :

  • Quel est le type de la fonction que je souhaite créer ?
  • Quel sera son nom ?
  • Quel(s) paramètre(s) prendra-t-elle ?
Nom de la fonction

Pour commencer, nous allons, en premier lieu, choisir le nom de la fonction. Par exemple, si votre fonction doit récupérer la température d’une pièce fournie par un capteur de température : vous appellerez la fonction lireTemperaturePiece, ou bien lire_temperature_piece, ou encore lecture_temp_piece.

Les types et les paramètres

Les fonctions ont pour but de découper votre programme en différentes unités logiques. Idéalement, le programme principal ne devrait utiliser que des appels de fonctions, en faisant un minimum de traitement. Afin de pouvoir fonctionner, elles utilisent, la plupart du temps, des « choses » en entrées et renvoient « quelque chose » en sortie.
Les entrées seront appelées des paramètres de la fonction et la sortie sera appelée valeur de retour.

Remarque : une fonction ne peut renvoyer qu’un seul résultat à la fois. Notez également qu’une fonction ne renvoie pas obligatoirement un résultat. Elle n’est pas non plus obligée d’utiliser des paramètres.

Les paramètres

Les paramètres servent à nourrir votre fonction. Ils servent à donner des informations au traitement qu’elle doit effectuer. Prenons un exemple concret. Pour changer l’état d’une sortie du microcontrôleur, Arduino nous propose la fonction suivante :
digitalWrite(pin, value)

  • – paramètre pin: le numéro de la broche à changer
  • – paramètre value: l’état dans lequel mettre la broche (HIGH, (haut, +5V) ou LOW (bas, masse))
  • – retour: pas de retour de résultat

Par exemple, vous voulez faire une fonction qui met en pause votre programme, vous pouvez faire une fonction

Pause() et déterminera la durée pendant laquelle le programme sera en pause. On obtiendra donc, par exemple, la syntaxe suivante : void Pause(char duree)
Pour résumer un peu, on a le choix de créer des fonctions vides, donc sans paramètres, ou bien des fonctions « typées » qui acceptent un ou plusieurs paramètres.

On utilise donc le type void pour dire que la fonction n’aura pas de retour. Une fonction de type void ne peut donc pas retourner de valeur. Par exemple :

{
    int var = 24;
    return var; //ne fonctionnera pas car la fonction est de type void
}

Ce code ne fonctionnera pas, car la fonction a un retour de type void (donc ne renvoi rien) et on veut renvoyer un int. Ce qui est impossible ! Le compilateur le refusera et votre code final ne sera pas généré.

Les fonctions « typées »

Si on veut créer une fonction qui calcule le résultat d’une addition de deux nombres (ou un calcul plus complexe), il serait bien de pouvoir renvoyer directement le résultat plutôt que de le stocker dans une variable qui a une portée globale et d’accéder à cette variable dans une autre fonction.

En clair, l’appel de la fonction nous donne directement le résultat. On peut alors faire « ce que l’on veut » avec ce résultat (le stocker dans une variable, l’utiliser dans une fonction, lui faire subir une opération, …)

void loop()
{
    calcul = 10 * maFonction();
}
 
int maFonction()
{
    int resultat = 44;  //déclaration de ma variable résultat
    return resultat;
}

Dans cet exemple dans la fonction loop on obtient un calcul qui dépend du résultat d’une autre fonction.

Les fonctions avec paramètres

Le fait de mettre des paramètres à une fonction permet de simplifier le code, cela permet de faire plusieurs opérations avec une seule fonction paramétrée plutôt que de devoir créer plusieurs fonctions sans paramètres.

int x = 5;
int y = 10;
 
void loop()
{
    //le paramètre "opération" donne le type d'opération à faire
    maFonction(x, y, operation);
}
 
int maFonction(int param1, int param2, int param3)
{
    int resultat = 0;
    switch(param3)
    {
    case 0 : //addition, resultat = 15
        resultat = param1 + param2;
        break;
    case 1 : //soustraction, resultat = -5
        resultat = param1 - param2;
        break;
    case 2 : //multiplication, resultat = 50
        resultat = param1 * param2;
        break;
    case 3 : //division, resultat = 0 (car nombre entier)
        resultat = param1 / param2;
        break;
    default :
        resultat = 0;
        break;
    }
 
    return resultat;
}

Vous voulez faire plusieurs opérations différentes (addition, soustraction, etc.) et bien au lieu de créer plusieurs fonctions, on ne va en créer qu’une qui les fait toutes ! Mais, afin de lui dire quelle opération faire, vous lui donnerez un paramètre lui disant : « Multiplie ces deux nombres » ou bien « additionne ces deux nombres.

Vous pouvez remarquer dans l’exemple ci-dessus l’instruction break qui est utilisée pour sortir d’une boucle do, for ou while, en passant outre le déroulement normal de la boucle. Cette instruction est également utilisée pour sortir d’une instruction switch.

 

V ) Fonction et procédure

Dans le langage C utilisé pour arduino ou le langage Python, il n’y a pas de manière différente de coder une fonction ou une procédure.
Une procédure est tout simplement une fonction qui ne renvoie pas de résultat.

Exemple simple de fonction :

fonction exemple1(entier a, entier b)
    retourner (a + b)
fin de fonction

Exemple de procédure sans paramètre :

procédure AfficherMessageAttente()
    écrire "patientez svp…"
fin de procédure

Cette procédure ne prend aucun argument en entrée et ne retourne aucun résultat, elle ne fait qu'afficher un message.

Exemple de procédure avec paramètre :

procédure AfficherMessage(chaîne message)
    écrire message
fin de procédure

Cette fois, le message est passé en paramètre de la procédure, elle ne retourne toujours pas de résultat mais affiche le message que nous lui passons. Elle devient donc ré-utilisable avec différents messages.

 

VI ) Utiliser les librairie arduino

Comment installer les librairies (bibliothèques) Arduino

VII ) Organiser son code en plusieurs fichiers

Voir article http://eskimon.fr/1803-arduino-mini-tuto-organisez-votre-code-en-fichiers

 

VIII ) La communication série avec arduino

Dans une carte arduino il y a deux diodes qui indiquent une communication série

arduino-uno-TX-RX

  • TX : s’allume lors d’une transmission
  • RX : s’allume lors d’une réception

Pour établir une communication série avec arduino il faut l’initialiser et ensuite indiquer dans la boucle ce que l’on souhaite envoyer avec la fonction Serial.println

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println("Coucou");
}

Dans la fonction setup, on initialise simplement le port série en donnant sa vitesse avec Serial.begin(9600). En effet, pour que la carte et l’ordinateur communique correctement, ils doivent « parler » à la même vitesse.
Dans la fonction loop, on se contente d’envoyer "Coucou" avec Serial.println("Coucou").

Vérifier le résultat de la transmission avec le moniteur série

Vérifiez dans Outils > Carte que la bonne carte est sélectionnée et dans Outils > Port série que le bon port est choisi. Si tout est bon, utilisez le bouton Téléchargements pour envoyer le code sur la carte.

Ouvrez le moniteur série avec Outils > Moniteur série. Vérifiez en bas à droite que la valeur est bien à 9600 Bd. Si tout va bien, vous devriez voir le moniteur se remplir de Coucou.

 

 

Les meilleurs tuto internet :

Le blog Ekimon  Tuto 1   Tuto2
Robomotic Arduino les bases

Documents de synthèse

Les structures de contrôle

Imprimer